The operator model

Command Center is built on one working model, and every surface in the product expresses it: you direct, agents execute. You think in systems — what should exist, what done looks like, what must never happen — and you hand the execution to agents that read your intent from files, do the work in the open, and come back for judgment at the moments that matter.

Once this model clicks, the rest of the platform reads as one coherent machine. Until it clicks, the platform looks like a large collection of views. Start here.

Two doors into one room

Every capability in Command Center has two surfaces: the view you click, and a tool an agent can call. Both drive the same backend. The Cortex graph you browse is the same graph your agents query; the Missions Board you read is the same mission state a fleet works against; the terminal panes you watch are the sessions your agents run in.

The consequence is worth stating plainly: directing an agent is never a degraded path. Anything you can do in the interface, an agent can do on your instruction — which is what makes "describe the outcome, dispatch the work" a real working method rather than a slogan.

Competence comes from files, not memory

A freshly started agent knows nothing. It becomes competent by reading: the operating contract at the root of your workspace, its own agent definition, the protocols that govern how work is done, and whatever context you attach to its session. All of these are plain Markdown files you can open, read, and edit — and edits take effect the next time an agent starts.

This is the platform's core design bet: the intelligence lives in the model, but the competence lives in the architecture. You improve your system by editing documents, not by retraining anything.

Where you stay in the loop

Delegation is only useful if it is safe. The platform keeps you in the loop at three levels:

• Everything runs in the open. Agents dispatched as a fleet work inside regular terminal panes in the Terminals view. You watch them type, you can click into any pane and take over, and one control pauses all agent terminal activity at once. Every mutating agent action on the terminal plane is written to an audit log.
• Outbound always stops at you. Anything that leaves your machine addressed to another human — an email, a post, a newsletter — lands in a review queue as a draft. Agents draft; you approve. This gate is unconditional and does not weaken with any autonomy setting.
• Big decisions escalate. Agents decide the tactical and reversible on their own (which file to edit, how to sequence a build). The strategic, the irreversible, and the expensive — deletions, deployments, large fleets, paid API spend — come back to you as questions.

What the model asks of you

The operator's job is small in volume and high in leverage:

1. Write intent down. Standing priorities and constraints go on the blackboard; larger goals become missions with explicit success conditions; task context becomes a context artifact.
2. Dispatch the right surface. A quick bounded job goes to a one-shot agent; recurring work becomes a routine; a long, watched, multi-part effort becomes a mission fleet.
3. Judge the output. You evaluate results against what you asked for, approve what crosses the human gate, and correct course by editing the files agents read.

You do not write the detail. You decide what the detail should achieve.

Where to go next

• Missions, operations & the fleet — how larger goals become coordinated multi-agent work
• Context artifacts & grounding — how a fresh session starts already knowing your task
• Routines & automation — the scheduled arm of the same model
• The agent roster — the specialists you direct