Operator

The brief

I use Operator to work on projects. I run several Claude Code sessions at once, often on the same repo, and I decide what each agent does, hand work between them, and read the diff before it lands. Most of all I tune the model and the effort of every lane, so the plan runs close to its limits without reaching them: cheap models where the work is mechanical, high effort only where it pays.

It is a living tool, not a product. It changes whenever the way I work changes: no roadmap, no support queue, no telemetry, no account. The source is MIT, so if it is close but not quite right for you, it is yours to change.

The mark

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

Orchestrating

• Staff the project once, then work the board. Each lane pins a model, an effort level and permissions, so a correctly configured session is one click. The card is the task, the agent is a chip on it, and Waiting is the column that needs you. Finishing runs the project's check command, so done can read done and green.
• Hand work between agents, on the record. One agent routes a task to another and every hop lands in the dispatch log with its outcome on a chip. A dispatch from a lane that is not the coordinator is held until you approve it, chains brake themselves, and nothing retries.
• Watch the call tree as it happens. Nested tool calls, delegations, durations ticking as they run, and what is queued behind them, rebuilt from Claude Code's own transcript files. Nothing to instrument.
• Run agents in parallel without collisions. One git worktree per task, so nothing touches your working tree until you say so. Fan-out sends the same prompt to N of them at once; you read the diffs side by side and keep one.
• Keep every agent in peripheral view. Every active project stays in the left list, the one you are in unfolds its agents beneath it, and an agent appears exactly once. The foot carries the plan as a ring, never a number.

Tuning

• Set the model and the effort per agent. Haiku for extraction, Sonnet for the everyday, Opus where it earns its keep, and effort from low to max beside it. These two knobs decide what a lane spends, and Operator sets them in the .claude/agents files you already have.
• See what each model actually spends. Input, output and cache reads per model, per project, per day, read from the transcripts on disk. This is where a tuning shows: a lane moved to Haiku, an effort dropped a step. Tokens, never dollars.
• Run close to the limit, never past it. Session, week, and the model with its own cap, each with when it resets. Amber means tune the lanes down; headroom means turn one up. A timed-out read says no data, never 0%.
• Review the diff and land it in place. What the tokens bought comes back as a diff you read in the window, then commit, merge or discard.

Scope

Operator hosts Claude Code's own CLI over a pty and reads the transcripts it writes. Everything follows from that, including what it will not do.

It stops an agent mid-run with Claude Code's own interrupt, so the session survives and hands the turn back. It passes effort as a flag at launch, all five levels, because settings.json drops the fifth without a word. It leaves alone: quitting out from under a working agent (the dialog names every lane mid-turn), pushing a message into a busy lane (one queue per terminal, read at the turn boundary), letting two agents talk forever (a hop limit, and a brake on a pair sending too fast), hosting or proxying the model, sending anything to a server, and estimating what a session cost.

The landing

The page at juanmnl.com/operator-app is one framed sheet of cells, with true-scale specimens of the app's own panels doing the arguing: the board and the team, the dispatch log, the call tree, the worktrees, the left list, then the four tuning panels. Each one runs its own small state machine while on screen. ⌘K opens a palette that jumps to a section or pins a scheme.

Behind the sheet the page is written on: phrases in my own handwriting and Operator's own doodles, the switchboard and its cords, a headset, a rotary dial, the effort ladder, coins for tokens. The same hand this site is written in.

Under the hood

React, Vite and Tailwind on the front, an Electron main process behind it. node-pty with xterm.js for the embedded terminals, a transcript tailer for the timeline and the usage, a durable session store. Signed and notarized builds with one-click updates. Apple Silicon.

Where it stands

v0.17.2, September 2026. Free, MIT, open source at github.com/juanmnl/operator, built and used every day on this site and the others. The download is on the landing at /operator-app/. Public in case it resembles your setup.