You hired five coding agents and became their project manager.
Arcadia Mission Control decides what they build next, keeps the sessions from colliding, and proves the work actually landed.
Arcadia is real software in active development. It is not finished, it has no customers yet, and early users help decide what it becomes.
The problem
Writing the code stopped being the hard part
Agents got good, and they got cheap. If you run several of them across several projects, you have probably noticed the bottleneck move somewhere less comfortable.
- “Tell me what to work on next, and why, without rebuilding the whole picture first.”
- “Keep five agent sessions from stepping on each other and on my main branch.”
- “Let work continue while I'm away, but stop at the decisions that are actually mine.”
- “Show me evidence the work is really done, not an agent's summary of itself.”
- “Stop making me re-explain my project to every new session.”
The approach
A layer above the agents
Mission Control does not write code. It decides what the things writing your code should be doing, and checks what they hand back.
Maintained intent
What you are building and why lives in one place that stays current, instead of being reconstructed at the start of every session.
Decisions and approval gates
Consequential calls stop and wait for you. Everything else keeps moving. You choose where that line sits.
One prioritized queue
A single answer to “what is next,” derived from your actual priorities rather than from whichever tab is open.
Evidence of completion
Work is done when it meets criteria written before it started — not when an agent says it is.
How it works
Intent becomes verified software
One loop, running continuously. Each step is inspectable, and each step is somewhere you can intervene.
What it is built to do
Three situations this is aimed at
These are the scenarios Mission Control is designed for. They are descriptions of intent, not customer stories — there are no customers yet.
Five sessions, three repositories, one Tuesday
Each session knows which project it is in, which action it owns, and which branch it may touch. None of them are working on something you already decided against.
A week away, with the work still moving
Approved work continues under the gates you set. What needed your judgment is waiting in one list when you get back, with the consequence of each choice stated.
A vague idea, by Friday, as something executable
“The onboarding is confusing” becomes a plan with actions, acceptance criteria, and an order — without you writing the plan yourself.
Your agents
It does not replace Claude Code, Codex, or OpenCode
Mission Control is agent-neutral on purpose. Your agents execute. Mission Control decides what they work on, holds the session and branch discipline around them, and verifies what comes back. As agents become interchangeable, the layer that decides is the part that has to be yours.
How this differs from orchestration frameworks and issue trackers →
Where it actually is
What works today, and what does not
Arcadia governs its own development — these tags describe that system, as it is right now.
Plans, actions and a work pointerWorking
Governed documents with one active plan and one current action.
Agent session managementWorking
Isolated worktrees per action, across Codex, Claude Code and OpenCode.
Decisions and approval gatesWorking
Consequential calls are recorded and wait for a human answer.
Completion evidenceWorking
Acceptance criteria are checked before an action can be marked done.
Multi-project portfolio viewIn progress
One surface across every project you are running.
Install on someone else's machineIn progress
Cold-start setup for a person who is not the author. Early access waits on this.
Hosted Mission ControlExploring
Today it runs locally, on your machine and your repositories.
Cost-aware model selectionPlanned
Spend the cheapest model that can actually do the work.
Fit
Who this is for
A good fit
- You run two or more active software projects.
- You use AI coding agents most days, seriously.
- You are the bottleneck between direction and execution.
- You have lost work to a session that forgot the context.
- You want autonomy, but not unsupervised autonomy.
Not a fit, yet
- You want a better code-generating agent. This is not one.
- You have one repository and no coordination pain.
- You need SSO, audit certification, or procurement review.
- You want finished, supported, stable software today.
- You are not willing to run experimental tools on real work.
Early access
What you would actually be signing up for
You get
- Direct access to the person building it.
- Real influence over what gets built next.
- Hands-on help setting up your first repository.
- Free use through the early-access period.
We ask
- One structured piece of feedback after first real use.
- Bug reports and observations as they happen.
- One conversation at the start, one a couple of weeks in.
- Honesty when it does not work.
What we do not promise: stability, support response times, data durability across versions, that any feature survives, or that this becomes a commercial product at all.
Pricing
We don't know what this should cost yet
That is a real answer, not a coy one. Nobody has paid for this, so any price on this page would be a guess dressed as a fact. We are weighing a monthly subscription, per-project pricing, a self-hosted core with a paid hosted service, and a setup package for getting your first projects in.
If you sign up, the second step asks what you would actually consider credible. That answer is worth more to us right now than a sale.
Help work out what this should be
If the problem above is your problem, the most useful thing you can do is tell us how you actually hit it.
Arcadia is real software in active development. It is not finished, it has no customers yet, and early users help decide what it becomes.