Mission control for your AI agents.
A native Mac app that puts a team of AI agents to work on your real projects, with one AI conducting them and you in command.
Set the operating boundary once. Then give Cerebro the mission. The Conductor coordinates Claude and Codex agents, keeps work moving, and shows you the key decisions, handoffs, and recorded results.
Give it a goal. The team does the work.
Give the outcome to the Conductor, then watch agents, workflows, terminals, and handoffs move across one operating surface. Mission shows what is running, blocked, resolving, and complete.
Four things a chat box can't do.
A living canvas you can reskin, workflows you can read, receipts you can trust, and a brain that knows your world. Everything else on this page serves these four.
Nine things that hold up under real work.
Agents are easy to demo and hard to trust. These are the properties that survive a long project, a cancelled run, a switched model, and a question asked a week later.
The store outranks the model.
An agent can lose the thread and tell you its work is gone. The stored run does not lose it. Verbatim recaps, complete transcripts, and a rebuildable index sit in files on your Mac. We have watched an agent report its output lost while the run's event log still held every character of it.
Memory that crosses runs, agents, and models.
Distilled working state seeds every fresh run. Agents pull earlier recaps and search memory through kernel tools. The Brain answers questions about the entities in your notes. Ask an agent what it was doing before you cancelled it, and the answer comes out of the store instead of a guess.
Switching models is a feature, not a migration.
Swap Claude and Codex mid-thread with a compiled handoff. Set the provider per agent. One delegation can fan out to Codex and Claude workers running at the same time, which we have watched complete live with receipts for each worker.
A forensic record, not a chat log.
One execution path and one receipt type, plus recorded decisions, context read receipts, and tool ledgers. Any change that steers a later run carries its provenance. A week afterwards you can still reconstruct who acted, under whose authority, and why.
Authority fails closed.
Capabilities are typed, each binding is scoped to a single run, and an agent's reach stops at its own subtree. We have watched the kernel refuse a cross-subtree nudge it had no permission for. A managed provider environment refuses to start without credentials rather than quietly falling back to your real home directory.
It cannot push work that was never verified.
A workflow will not push or open a pull request unless a dominating system verification actually ran and exited clean, with HEAD and the working tree unchanged at the moment of execution and the GitHub command bound to the exact repository and commit. That is a structural gate, not a prompt asking a model to be careful.
You can see what the context cost.
Granted and used accounting per category, spend reconciled while the run is still going, a preview of the prompt before it is sent, and the outcome joined back to it afterwards. That instrumentation is how we caught a handoff block quietly taking half of a prompt.
A staff, not a list of chats.
Durable agents with objectives and lifecycles. Projects with briefings and their own document libraries. A Conductor that coordinates them and asks before it crosses a line you set. Delegation batches that come back with a receipt per worker.
It can prove its own behavior.
A headless harness boots the app's real wiring and asserts against the store, so the agent behavior described here can be demonstrated rather than promised. It has caught bugs in itself that way, which is the point of having it.
One AI runs the whole team.
Describe the result, not every turn. The Conductor creates the plan of motion, delegates to the right agents, follows handoffs, and keeps verification moving.
- Projects stay coherent. Agents share a goal, working state, and the current next step.
- Claude and Codex work together. Use the provider that fits each role, without losing the mission thread.
- Real blockers surface. An agent asks only when missing information or authority actually stops useful work.
Autonomy without the black box.
After you choose the autonomous top-level boundary, the Conductor and agents have full operational control inside the selected workspace and connected services you chose for the mission.
- Set the boundary once. A small number of top-level settings replaces per-action tuning.
- Stay in command. Pause, stop, redirect, or answer a genuine blocker without managing every agent turn.
- Know what changed. Key decisions and recorded actions remain visible while the mission advances.
Builder
Implementing the selected workspace change.
Reviewer
Waiting for the verified handoff.
Redirect
Change the outcome without dismantling the fleet.
Full Operator
Chosen deliberately for this workspace and its connected services.
Multi-step work that runs itself.
A goal contract defines done. Phases then advance on a layered graph you can actually read: parallel lanes, edges routed around nodes, and mission-level pause or stop always in reach.
Goal contract first
You approve what done means before anything runs. The workflow earns its autonomy from that agreement.
Readable by design
Lanes stay separated, status lives on every node, and the map keeps the whole run in one glance.
Honest blockers
A provider timeout becomes a visible attention item with a retry, never a silent stall.
Receipts, not babysitting.
Audit, run history, and working state answer the practical question: what happened while you were out? Recorded actions carry their actor, route, outcome, and time.
{
"actor": "Builder",
"action": "workspace.write",
"result": "succeeded",
"handoff": "Reviewer"
}
Actor and route, always
Every recorded action carries who acted, which route ran, and how it resolved.
Learning under review
Winning patterns surface as suggestions with evidence and impact estimates, reviewable in one place.
Why the agents are sharper here.
Every agent reaches your projects, files, and history through one thing Cerebro owns: the kernel. Nothing guesses, nothing rummages. That single doorway is what makes their memory last, their context fit, and their work reviewable.
Context that fits
The kernel hands each agent the slice that matters for the job in front of it, not your entire world. Less noise in, better work out.
Memory that lasts
Decisions, next steps, and open questions live in the app, not in a chat window. A fresh session picks up where the last one stopped.
A record by default
Because every read and action passes through one doorway, each one can be receipted. That is where the Audit view gets its evidence.
They remember your project.
Decisions, next steps, open questions, files, and recent activity survive provider sessions. When a real question blocks progress, the answer resumes the same thread.
// carried between sessions, not retyped objective: "ship the launch checklist" decisions: "waitlist first", "defer pricing" next_step: "verify the signed build" open_question: "which region first?" files: 4 touched this run
// Scout, mid-run blocked_on: "which region should the index cover first?" reason: "the brief names no default" state: waiting_for_input run: held open
// your reply, in the same thread answer: "EU first, then US" recorded: true state: running context: intact, same run
They get better at your work.
A successful pattern can become a project or Cerebro skill with its source run and evidence attached. The value is compounding capability you can inspect and reuse.
- Evidence stays attached. See which successful run taught the pattern.
- Scope stays clear. Reuse it globally, in a project, or for one agent.
- Files remain real. Skills live where agents can load and apply them.
Your notes become their memory.
Connect an Obsidian vault and Cerebro turns linked notes into bounded context the fleet can recall. App state and provider sessions stay under your ownership on your Mac.
- Local-first storage. Workspace state lives in the native app data root.
- Bounded recall. Agents receive the useful slice, not an indiscriminate dump.
- Provider ownership. Bring your own Claude Code or Codex installation and account.
Built for real work on your Mac.
Use Claude and Codex agents, durable workflows, report-only Project Workers, provider handoffs, and local tools from one native operating surface.
Your own subscriptions
Cerebro runs on the Claude Code and Codex accounts you already have. It never resells tokens or sits between you and your provider.
bring your own · Claude · CodexDurable workflows
Multi-phase runs keep their state, survive interruptions, and stay steerable from Flow Studio.
plan · build · review · verifyProject Workers
Page-owned background work returns a concise report and provenance without becoming another visible agent to manage.
report-only · scheduled or manualGet the signed public beta first.
Join for important release notes and the signed public-beta launch when email delivery resumes. Nothing unrelated.