Juan Manuel Cornejo

Work, 01 of 10
(2025 to now)

Operator

A Mac app for Claude Code. You run the agents: decide what each one does, then tune every lane's model and effort so the plan runs close to its limit and never past it.

When
2025 to now
For
Independent
Built with
React, Vite, Tailwind, Electron, node-pty, xterm.js
Links
The landing
Source on GitHub, MIT
The Operator board: tasks as cards in columns, an agent as a chip on each.
The team and the board, as the landing draws them at true scale.

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.

The Operator mark: a field of dots pulling into a circle.
The mark.

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.

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.

Run agents in parallel without collisions. One git worktree per task, so nothing touches your working tree until you say so.

The dispatch log, one dispatch held for approval.
Comms. One dispatch held for approval. Nothing here retries on its own.
The agents panel, each agent with its model and effort.
Agents. Each one pins a model and an effort; the flag travels at launch.

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.

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.

The plan meter: session, week and model usage as bars.
The plan meter. Absent is not zero.
The review panel showing a diff.
Review. The diff read in the window before it lands.

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 leaves alone: quitting out from under a working agent, pushing a message into a busy lane, letting two agents talk forever, hosting or proxying the model, sending anything to a server, and estimating what a session cost.

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.

Index