The Agent Cockpit Wars: A Product Category Is Being Born in Real Time

On June 12, 2026, a developer named Randy Daniel launched Conan on ProductHunt — a native macOS app that wraps Claude Code in a live HUD. Nine days earlier, Vignesh Warar shipped Handler , a Mac app for reviewing AI-generated edits as they happen. On the same day, Kemone Phillips dropped Bob's CLI , a local-first coding agent that profiles your behavior and never sends code to a cloud API.

That's three products with different approaches, same underlying diagnosis, all within a single 9-day window. And that's not counting cmux (the Ghostty-based terminal with agent notifications) and SessionCast (remote Claude Code access from any browser), both of which landed in recent months and occupy the same conceptual territory.

This is not a coincidence. This is a product category crystallizing in real time.

The Invisible Agent Problem

The root cause is simple: AI coding agents have crossed a capability threshold. They're productive enough that ignoring them is expensive, but opaque enough that trusting them is uncomfortable. Every developer who uses Claude Code , Codex , or OpenCode seriously has felt this tension.

The terminal doesn't help. You see scrollback, but you don't see what's happening right now — which tool just fired, how full the context window is, whether your skill actually ran or was just considered. The feedback loop between "agent is doing work" and "I understand what it's doing" is broken.

Randy Daniel put it plainly in his Conan launch post :

"I use Claude Code all day, and I kept losing track of what it was actually doing. It'd go heads-down for two minutes firing tools and burning context, and the terminal showed me everything except what I cared about."

This resonates. The ProductHunt forum thread asking "How do you stay aware of what your AI coding agents are doing?" generated an unusually high engagement signal that tells you this pain is widespread and unresolved.

The Contenders

Each tool approaches the visibility problem from a different angle.

Conan — The Cockpit

Conan ( conan.sh ) is the most literal interpretation of the "cockpit" metaphor. It sits beside Claude Code as a native macOS app and streams every event: prompts, tool calls, skill activations, context window fill level, token burn rate. The timeline is live — not polled — because it uses Claude Code's hooks-first system to push events to a local gateway as they happen. Randy confirmed in the comments that "Claude Code itself tells Conan the moment something happens" — no refresh loop.

The context-window gauge is the standout feature here. Randy Daniel, the maker, reports changing his behavior when he saw the gauge fill: at 60% context usage, he now prefers to "compact/handoff instead of gambling" because the live visualization makes the cost visible. That's the kind of behavioral change that separates a dashboard from a tool.

Conan also keeps everything local — "No telemetry, nothing about your code or prompts ever leaves the machine." It's free to use with a $29 one-time Premium unlock (lifetime 1.x updates, no subscription).

Handler — The Review at Generation Time

Handler works during code generation, not after. It breaks the agent's output into individual reviewable edits — each with an explanation, a side-chat, and accept/reject controls. Vignesh Warar, the solo developer behind it, describes the problem as:

"I noticed myself losing the mental model when agents gave me 300–500 line changes. Tests would pass, the diff would look reasonable, and I'd start skimming instead of really understanding what changed."

Handler works with Codex and OpenCode (not just Claude Code), uses Git worktrees so parallel runs don't collide, and includes a built-in terminal and JSON viewer. It positions itself before traditional review tools like CodeRabbit or Greptile — not replacing them, but filling the gap between "agent generated the code" and "code lands in a PR."

Bob's CLI — The Agent That Knows You

Bob's CLI is the most ambitious entry in the list. It's a full AI coding CLI that runs entirely on your hardware with auto-detected local models. The headline feature is behavioral DNA profiling — a system called the Frank Engine (built alongside NVIDIA and Google Cloud) that builds a dual-structure memory of short-term interaction patterns and long-term behavioral preferences. The maker, Kemone Phillips, describes it as: "Bob's responses aren't just contextually accurate — they're you-accurate."

But the most practical feature is SovereignLink: run bob serve on your desktop, then send commands from any device via a web app. Your home machine processes them, reads your actual files, and writes the result — your code never leaves your house.

Bob's CLI is MIT-licensed with a public repo, installable via pnpm add -g bobsworkshop-cli. It landed at #6 on ProductHunt with the strongest launch signal in this group.

cmux — The Terminal Thought for Agents

cmux predates this recent wave by a few months but solves the same problem from the infrastructure layer. It's a native macOS terminal (Swift/AppKit, no Electron) built on Ghostty that adds vertical tabs, notification rings, and a built-in browser with a scriptable API.

The key insight: when an agent needs your attention, its pane glows blue and the sidebar tells you why — not just "Claude is waiting" but the actual notification context. With 22.1k GitHub stars on its open-source repository , cmux has the strongest community in this group. It's GPL-3.0-or-later licensed and free .

SessionCast — The Remote Access

SessionCast fills a simpler but real gap: you can't always sit at your development machine. It provides browser-based remote access to Claude Code sessions with zero VPN/SSH configuration. Run the agent, open a browser, and you're connected. It supports multi-session monitoring and even includes a relay integration library for building custom remote-access tools on top.

Why Now? The Trust Threshold

The dominant framing for this category is "agent observability as a technical challenge." But that misses the deeper story.

These tools exist because agents crossed a trust threshold: they're capable enough to not be ignored, but opaque enough to not be trusted. Every cockpit tool is a symptom of a deeper discomfort — we're deploying agents we don't fully understand.

The irony is that this problem is getting worse as agents improve. Better agents run longer, fire more tools, consume more context, and make more autonomous decisions. The gap between "agent output" and "human understanding" widens with every model release. Conan's context gauge, Handler's edit-by-edit review, Bob's CLI's behavioral memory — each is a different strategy for closing that gap, but the gap itself is structural.

The bottleneck in AI-augmented development has shifted. It's no longer about model capability or code generation speed. It's about human comprehension speed. We can generate code faster than we can understand it, and a growing stack of cockpit tools is the market's response.

What This Means for Developers

If you use coding agents seriously, you need at least one of these tools. The question is which one fits your workflow:

• If you live in Claude Code on macOS and want surgical visibility into what your agent is doing: start with Conan. The context gauge alone will change your session management behavior.
• If you feel like you're rubber-stamping 500-line diffs: install Handler. Edit-by-edit review with accept/reject is the difference between "I skimmed it" and "I understood it."
• If you want a fully local agent with behavioral adaptation and remote execution: Bob's CLI is the most complete package in this space, though it's still early.
• If you run multiple agents in parallel and your terminal can't keep up: cmux is the infrastructure play. The notification rings alone justify the download.
• If you need to check on long-running sessions from your phone: SessionCast solves this with zero friction.

This category is days old, not years old. The tools that exist today will look primitive in six months. Conan's hooks-first architecture, Handler's worktree isolation, Bob's CLI's local-first sovereignty — these are design bets, not settled standards. The winner of the cockpit wars won't be the tool with the most features today. It'll be the one that best solves the fundamental tension: agents that are powerful enough to delegate to, but transparent enough to trust.

Further Reading

1. Conan Official Site — Product page, features overview, and download. The official site documents the hooks-first architecture, context gauge mechanics, and pricing model. Best source for understanding what Conan does and how it works under the hood.
2. Conan on ProductHunt — Product page with maker comments and discussion. The launch thread has valuable back-and-forth on hooks-first architecture, context gauge behavior changes, and the multi-session use case. Primary source for Conan details.
3. Handler on ProductHunt — Launch with detailed problem statement from the solo developer. Vignesh's framing of "stacked PRs at generation time" is the clearest articulation of the review-time bottleneck. Includes discussion on fork chat and worktree isolation.
4. Bob's CLI on ProductHunt — Product page with the most detailed technical discussion in the group. The comments on local-first architecture, sovereign data design, and the Frank Engine's dual-structure memory system are worth reading for anyone evaluating local agent tooling.
5. cmux GitHub Repository — Open-source terminal for coding agents with 22.1k stars. The README documents the notification system, vertical tabs, built-in browser with scriptable API, and Claude Code Teams integration. Best source for understanding the infrastructure layer of this category.
6. ProductHunt Forum Thread: "How do you stay aware of what your AI coding agents are doing?" — Community discussion on the agent visibility problem. The thread captures developer frustration across Claude Code, Cursor, and Codex users. Primary signal for the pain this category solves.