You already have an AI fleet. You just don't have a commander.
Arbiter is the OS-level brain above your agents, providers, and jobs: agnostic, survivable, and running on a local GPU. Alone it tames the chaos, and over the full stack it runs the whole operation.
If you build with AI for a living, your setup has quietly become a fleet: two or three coding clients, a stack of provider accounts, a SAST tool, a memory layer, background jobs that run for an hour and die at minute fifty-nine. Every piece is useful, but nothing actually runs the operation. You are the orchestration layer, babysitting tabs, copy-pasting between tools, and restarting dead runs.
Arbiter is the layer above the pile: an OS-level command center that dispatches, routes, schedules, and recovers everything underneath it. It’s standalone-first and provider-agnostic, and it thinks with a brain that runs on your hardware.
On its own, it ends the chaos
Most “agent platforms” assume you’ve already surrendered to one vendor. Arbiter assumes the opposite:
- Agnostic to the core. It drives your clients and any provider API you own, and it also runs with none of them. No vendor owns your workflow.
- Its brain is local. Routing and triage run on a small model on your own GPU, not a metered cloud call, so the decision layer itself has no vendor and no per-token bill.
- It pools your accounts and routes around the walls. When an account is rate-limited or exhausted, work reroutes to one with headroom. Every routing decision is auditable, never a black box.
- It survives. After a reboot, a crash, or a power cut, a durable, encrypted run transcript means in-flight work is re-accounted and preserved instead of vanishing or running forever.
- A hard risk floor. Destructive operations are never auto-routed to the cheapest model, and they’re flagged for approval, so the cost optimizer can’t override safety.
A pile of tabs can’t do any of that. One commander over the fleet is the difference between an operation and a hobby.
Over the full stack, it runs the whole operation
Arbiter is the conductor, and the rest of the stack are the instruments: each strong alone, each sharper under the baton.
- Warden is the agent it dispatches across every provider you hold.
- TheAuditor is the ground truth it routes your code-questions against.
- Curator is the evolving memory it feeds into the right job at the right time.
- BenchProctor is the proof layer its analysis runs answer to.
From one place, you dispatch the agent, ground it in truth, keep the memory of the engineer, and prove the result. It runs on Windows and Linux and is drivable from your terminal, an editor, an HTTP control plane, an MCP client, or your phone. Five tools become one operation instead of a dozen dying tabs. That is a step change in how the work runs, not just a nicer workflow.
Read the same point from each of their seats: TheAuditor, Warden, Curator, and BenchProctor.
The old way is already over
Manually shepherding a fleet of AI tools is the unglamorous tax nobody put on the invoice: the dropped runs, the throttled accounts, the context you re-typed for the fifth time. The teams scaling AI work aren’t grinding harder. They put a commander over the fleet and stopped paying the tax.
Get in before everyone else figures this out
Arbiter is in active development, with early access opening soon. Provider-agnostic, survivable, and brained on your own silicon: that design is the part we won’t compromise. We’re building it in the open, so follow along or grab the RSS feed, and start with Introducing Arbiter.
The whole stack, in its own words: TheAuditor · Warden · Arbiter (you’re here) · Curator · BenchProctor