Specialized AI workers that perform the work AgentOS authorizes. Every task carries an execution contract: authority, grounding, evidence requirements, and a cost budget. The model never gets to skip a clause.
An assistant runs on the human's working memory. A worker runs on a contract. That difference is what makes autonomous work possible at scale, without dragging a human into every local ambiguity.
Each persona is a small, replaceable worker with a defined role. AgentOS holds authority, contracts, and evidence rules. Completed work is the only thing that leaves the system.
Each worker is a small, specialized seat under AgentOS authority. The mechanics are the same whether you have five workers or five thousand.
Architect, developer, witness, reviewer, gatekeeper, operator stand-in, and more. Each persona has a defined role, allowed tools, and a contract about what it may and may not do. No worker is a polymath; the system composes them.
Authority, allowed roots, forbidden paths, evidence requirements, a cost budget, and the close-bar that defines done. The contract is a required field, not a suggestion, and it is enforced at the boundary before the worker runs.
Coordination happens on a durable, addressable mesh: messages, ACKs, assignments, escalations, all written to disk and observable. No "the conversation got lost" failure mode, because there is no conversation; there is a transcript.
Cheap, fast local models handle bulk grounding and class-bounded work; frontier models handle decision-class work. The scheduler routes by task class and cost class, not by who shouted last. Frontier-model share is a KPI, not a year-end finding.
Producers cannot emit a task without a contract. The contract names what the task may touch, how completion is proven, and what it may spend. These are required fields, not suggestions.
Every emitted task carries an AgentOS execution contract. No work leaves the gate without authority, scope, evidence requirements, and a cost budget.
Every work package carries grounding from FAFO Memory. Smaller context, cheaper models, cited results, not hallucinated narratives.
Spend tracked per task at sub-penny precision. Fail-closed at the boundary when budget is exhausted. Cost is a property of the task, not a monthly surprise.
It does, in the absence of governance. Under AgentOS, scale is the point: thousands of small, governed, evidenced tasks running in parallel, each completing or failing cleanly, none free to invent its own scope.
Producers cannot emit a task without an execution contract. Allowed roots, forbidden paths, evidence requirements, and a gatekeeper packet are required fields. A worker that tries to step outside is stopped at the boundary, not after the damage is done.
Decisions, fixes, and patterns from completed work bank into FAFO Memory and ground the next round. The fleet does not redo solved problems. The longer it runs, the less the marginal task costs.
No model, no agent, no session ever holds the state. When a worker dies (and workers always die), AgentOS replaces it from the durable work graph. The work continues from the last recorded state, never lost, never duplicated.
Authority and progress live in a work graph outside any single worker. Execution picks up exactly where it left off, with the same contract and the same grounding.
A dead Claude, Codex, or session is replaced. Workers are temporary; the work system is permanent. A new worker takes the contract and continues.
Crash, kill, or restart, with no operator intervention. The work survives the worker. Operator gets the finished outcome, not a stack trace.
Agent Swarm is part of AgentOS. Become a design partner and put it to work on yours.