Operator

A Mac app I'm building for the way I actually work. I run two or three Claude Code sessions at once, often on the same repo, each one delegating to subagents. In separate terminals that means constant window-switching, no view of who delegated to whom or what any of it costs, and agents tripping over each other's changes.

Operator is the place I launch and watch them from. Each project gets a board and a team of lanes, every tool call and subagent shows up live on a timeline, and each agent works in its own git worktree so nothing collides.

A field of dots pulling into a circle: many agents, one center.

The first instinct with a tool like this is to wrap the agent: proxy its traffic, install a runtime, own the session. I didn't want that. The moment Operator becomes something you install into the loop, it can break the loop.

So it stays a pure observer. It pins each session's id at launch and rebuilds the timeline from Claude Code's own transcripts. Nothing is installed, there's no global config, and if Operator isn't running the agents work exactly as before. Even permissions stay where they were: Claude Code asks in its own terminal, and Operator never intercepts.

• The board is the project: Four columns, Backlog, Running, Waiting, Done, each scrolling on its own so a long Done list never pushes live work off screen. You open a project and see the work, not an org chart of idle agents; the team is one tab away
• A team of agent lanes: Operator, Research, Code, Review, Design, QA, each pinning a model, a reasoning effort, an optional isolated worktree, and a standing charter. Live lanes show as full cards, idle ones collapse to a launchable row, and the Operator lane routes work to the best-suited lane or does the job itself when none fits
• Lanes scoped to the task, not the session: A lane that reports done closes itself after a keep-warm window; the next dispatch brings it back with the same conversation, on the branch it left. Silence is not success: a lane that never reports gets closed by a backstop and its work marked abandoned rather than done
• Hand-offs that land: An agent delegates with one line. Operator types it into the target lane if it's running, or launches the lane with the task as its opening brief, then tells the sender how it landed. Every outcome is observed rather than assumed: delivered means a turn actually began
• An authority gate, per dispatch: Work one agent commissions from another lands in Waiting for you to Approve or Decline, one card at a time. No approve-all and no timeout, because a timeout that approves is not a guardrail
• Reports through a tool, not prose: A small MCP surface hands results to the coordinator and marks tasks done or blocked the moment it happens, so the board stops inferring completion from the shape of a transcript
• Console, Chat, and Preview: The real terminal, a document-style read with its own composer, and a live preview of the app being built on a port that is attributed rather than guessed. Pin annotations or inspect an element down to its component and file, and send either back to the agent
• Worktrees with provenance: Each agent in its own git worktree; fan one task across several agents, each badged. Before any worktree is removed, uncommitted edits are committed first, and if that commit fails the removal is cancelled. Every task carries who ran it, where, the diff it produced, and an optional check that has to go green before it reads done
• Around the edges: An agent library with per-task models and cost hints, a usage and cost dashboard, crash-safe resume for whole projects, three themes in light and dark, a Cmd+K palette, a menu-bar tray of live sessions, and one-click self-updates

Operator pins each session's id at launch (claude --session-id <uuid>) and tails its transcript to rebuild the timeline live, so it stays a pure observer of the sessions it starts, with nothing installed and no global config.

Permissions are handled by Claude Code itself in the terminal, as usual; Operator doesn't intercept them. A claude you run yourself in iTerm or VS Code is completely unaffected.

React 19, Vite, and Tailwind 4 on the front, an Electron 43 main process behind it. node-pty with xterm.js for the embedded terminals, a transcript tailer for the timeline, and a durable session store. The builds are signed and notarized, and the terminal has its own headless test harnesses, because the terminal is the hard part.

Open source as of August 2026, MIT, at github.com/juanmnl/operator. At v0.17 and moving: signed, notarized builds with one-click updates, built and used daily by its author, issues and PRs welcome. This site is maintained by agents running inside it.