FAFO™ AgentOS · The operating system for autonomous work

The operator never hands an agent raw freedom. Before anything runs, the Work Order Compiler derives an execution contract from the conversation: allowed scope, allowed roots, forbidden paths, permitted tools, and the authority the worker acts under. Once compiled, the work order is the authority for execution. Workers act inside it, never past it.

The full lifecycle is governed end to end: scope, work order, contracts, acceptance, execution, QA, governance, close. Work that would cross a contract boundary, such as authority or budget, stops and escalates instead of proceeding, so the blast radius of any worker is bounded before it acts.

The conversation is the planning phase. From it, the Work Order Compiler compiles both halves of a governed execution system at once: the execution side (the workforce, the task graph, the grounding, the routing) and the governance side (the contracts, the budgets, the review chain, the evidence requirements, the recovery topology).

The work order is the source program; the governed execution system is the compiled program. That is why governance here is automatic rather than layered on afterward: it is emitted by the same compilation that creates the workers. The operator defines intent. AgentOS derives execution.

Autonomy here does not mean unsupervised. It means the operator stops directing individual steps. The goal is defined once, and AgentOS advances the work through its governed state machine until the acceptance criteria are met.

The only interruptions are the ones that genuinely require operator judgment: real ambiguity in the work, or a contract boundary such as authority or budget. Everything else proceeds, is evidenced, and is verified without a human in the loop.

Completion is a property of evidence, not of an agent's confidence. As work executes, an evidence bundle accumulates against the acceptance contract: what ran, what changed, what was produced, and what verified it. Nothing closes without satisfying that contract.

The proof is not a log dump. Evidence packets are structured artifacts on disk with reproducible commands, and an independent gatekeeper checks them against the acceptance contract before close. Every capability claim on this site is backed by one.

ONE WORK ORDER · ON DISK

  workorder/                  3 files     the signed contract
  dispatch_design/            4 files     architect plan
  dispatch_work_packages/    78 files     task packets handed to devs
  gate_evidence/<task>/   4–38 files     evidence per task (×11 tasks)
  gate_evidence/generated/  8,438 files     auto-checksummed verdicts
  grounding/                152 files     per-role resume overlays
  observations/               4 files     banked decisions + discoveries
  standdown/checkpoint/       1 file      RESUME packet
  gatekeeper_workspace/    ~48k files     live gatekeeper state + transport

The authoritative work graph is the system of record for everything: 26,866 governed objects and 36,515 recorded transitions in the production estate, every one naming its actor, its authority source, and its evidence. Every change of state, scope, authority, or acceptance is an explicit transition; the graph is always in a known, auditable state, never a guess about what happened.

It is not an internal abstraction. The graph renders, and you can replay real production work through it: who did what, grounded by which knowledge, at what cost, verified by whom.

Cost is recorded per action as work executes, then rolled up by phase, role, model, and work order. The production canon run: 11,193 priced model calls, 3.197 billion tokens, $1,990.52 of actual spend against a $10,603 uncached equivalent, at a 94.5% cache hit rate.

Budgets are declared in the execution contract and enforced during the run, not reconciled after it. Planning, architecture, development, QA, review, and governance each carry their own attributed cost, down to the action that spent it.

Before a worker acts, FAFO™ Memory onboards the task with a grounding bundle: the relevant code from a 674,025-edge symbol graph, prior decisions, and the references the work depends on. Results are cited from what the organization already knows, not improvised by the model.

The memory compounds. 289,304 observations from past work are retrievable across the fleet, so nothing is rediscovered twice, and every retrieval is recorded on the work graph as part of the grounding record for the task it served.

No model, agent, session, or host ever holds the state. Authority, progress, evidence, and routing live on the authoritative work graph outside every runtime, so workers, containers, and even models are disposable.

When a worker dies, and workers always die, another worker resumes from the graph deterministically in under 5 seconds, with nothing lost and nothing duplicated. Continuation, not reconstruction: there is nothing to rebuild, because the work state already exists outside the runtime.

State is not the model. Authority, evidence, and work exist outside every provider, and models are routed per task: in the canon run, orchestration ran on Claude Opus 4.8, development on Claude Sonnet 4.6, and QA, review, and gatekeeping on Codex GPT-5.5.

Frontier models are deprecated, repriced, and retired without notice. If a model is no longer available, your organization is not: the next model picks up the same work order with the authority, evidence, and history intact. Local and frontier models are interchangeable execution resources under the same governance and the same cost ledger. The organization survives the model.