Arbiter is the OS-level orchestration brain that sits above your LLM clients and beside your tools. It dispatches and supervises your agents, terminals, and long-running jobs. It routes each to the right model, schedules them around peak-hour throttling, and brings interrupted work back after a crash or power cut.
Agnostic by design. Bring any client, any provider, or none at all. Early access is opening soon.
$ arbiter run "refactor the auth module" --client claude-code --worktree
run f3a1 queued
run f3a1 routed → opus (sufficient for this job)
run f3a1 deferred → off-peak window (acct-2 quota in 34m) ...
run f3a1 running worker 48211 · worktree wt/auth
-- power cut · machine reboots -- $ arbiter hydrate
run f3a1 recovered resumed from checkpoint, worker re-attached
[ok] 1 run resumed, 0 lost
Illustrative. Arbiter is in active development.
The problem
LLM clients run one session well, but they don't orchestrate many across processes, machines, accounts, and time. Memory tools remember and code tools verify, but neither dispatches. The orchestration layer is simply missing, so today it's run by hand.
Many clients, each good at one session: Claude Code, Codex, Gemini, Cursor, Windsurf. Running ten of them means ten terminals and a mental map you have to hold yourself.
Every provider has its own quotas and peak-hour throttling. Keeping work on whichever account still has headroom is a babysitting job nobody should have.
Long jobs sprawl across terminals, branches, and machines. The moment the power blinks or you reboot, the in-flight work is gone and the day with it.
What Arbiter does
Arbiter is the muscle and the dispatcher. It never runs the coding turns itself. It dispatches the clients that do, and owns everything around them: routing, accounts, scheduling, processes, and recovery.
One command center for terminals, processes, git worktrees, work-groups, and sub-jobs, across Windows and modern Linux. Everything you launch, in one place to see and steer.
Every job lands on the model that fits it, and it refuses to overpay when a cheaper tier is just as capable. The right model at the right cost, without you thinking about it.
Defer runs to dodge peak-hour throttling and quota walls, and move work onto whichever account still has headroom. Your jobs run when the lane is clear.
Steer or stop any run from your phone over Signal, Telegram, or WhatsApp, or from an HTTP control plane, your editor, or an MCP client. The control surface is wherever you are.
Power cut mid-run, reboot, and the interrupted jobs come back. Crash recovery is built in, not bolted on, so an outage costs you minutes, not the whole day.
A multi-account credential pool picks where work runs and rotates around exhaustion, so a dead key or a throttled account reroutes instead of stalling the queue.
Watch it run
No slideshow, no mockups. This is the running daemon on a real machine, unedited: routing across providers, live runs, approvals, and the local brain doing the deciding.
Silent screen capture, 8:02. Prefer YouTube? Watch it there.
The headline
The thing that ends most long AI sessions is not a bug. It's an outage: a reboot, a dropped connection, a blink in the power, and a day of in-flight work evaporates because nothing was holding it.
Arbiter holds it. Runs are checkpointed as they go, so after a restart a single
arbiter hydrate brings interrupted jobs back, resumed
where they left off or cleanly marked if they can't be. Recovery isn't a feature you
remember to turn on. It's the default posture of the whole system.
$ arbiter status
3 runs were interrupted by an unclean shutdown.
$ arbiter hydrate
run f3a1 recovered resumed from checkpoint
run 9c0e recovered resumed from checkpoint
run b27d suspended needs approval to retry
[ok] 2 resumed · 1 held · 0 lost
Illustrative output.
Model routing
The model you reach for by reflex is usually the most expensive one, even when a cheaper tier would do the exact same job. Arbiter decides where each job runs so you get the right capability at the right cost, every time, without thinking about it.
Trivial edits don't need a frontier max-thinking model; planning and investigation shouldn't run on a weak one. Arbiter sorts that out per job, automatically.
When two models are effectively the same for the work in front of you, paying more for the bigger name is waste. Arbiter takes the capable option, not the expensive one.
Every routing choice is explainable, and you can pin hard rules the optimizer can never cross. The worst case is "spent a little less," never "did something risky on a hunch."
Agnostic by design
Arbiter is built to run with zero providers and zero sibling tools, and to get sharper as you add them. Swap any client or provider out and it still runs. If it only had value when you ran the whole stack, it would have failed its own test.
Arbiter
The orchestration brain
Dispatches, routes, schedules, and recovers everything below it. This app.
Your LLM clients
Dispatch targets
Claude Code, Codex, Gemini, Cursor, Windsurf, or your own. Bring any, or none.
Your providers
Accounts & quota
Every account you hold, pooled and rotated around exhaustion and throttling.
Your tools
Optional delegates
Memory and code-analysis tools plug in when present, and are never required.
Standalone-first. Integrations are additive, never load-bearing. Arbiter is the dispatcher above them all, not a member of the set.
Where this is going
One instruction, and Arbiter handles the dispatching, the accounts, the timing, and the recovery underneath it. These are the north-star behaviors the whole system is built toward.
“Run this across off-peak hours on whichever account still has quota.”
“Spin up 10 workers on this monorepo, each on its own git worktree; recover them if I reboot.”
“Text me on Signal when the suite goes green, and let me stop any run from my phone.”
“Index the repo, warm it with the project's standards, then dispatch the fix to whichever client I prefer today.”
The ecosystem
Five focused tools for shipping with AI agents. Each stands on its own; together they cover code, action, orchestration, memory, and proof.
TheAuditor
Don't let agents guess about your code.
theauditortool.com →Warden
Let agents act safely, across any provider.
wardenclient.com →Arbiter
The command center for your AI operation.
you are hereCurator
Don't let agents guess about you.
curatormcp.com →BenchProctor
The SAST benchmark you can't game.
benchproctor.com →● In active development
Arbiter is being built in the open. The architecture is laid down and the work is underway, and what you see here is where it's headed, described honestly. The best way to follow along, and to be first in line when access opens, is the blog.
No signup form yet. We're not collecting emails until there's something to hand you.