FAFO™ is a member of the NVIDIA Inception Program.
Agent SwarmThe distributed execution runtime for governed AI work.
Agent Swarm runs thousands of sandboxed AI agents across hosts you control, from a workstation to a datacenter. One work order can fan out into hundreds or thousands of specialized agents, coordinated over an open agent-to-agent mesh.
AgentOS decides what should happen and what counts as done. Agent Swarm decides where the work runs, which worker performs it, how workers find and talk to each other, how a dead worker is replaced and the work continues, and how thousands of agents become one coherent workforce. Keeping the runtime separate from the rules is what lets each evolve without breaking the other.
AgentOSGoverns the work · decides what is authorized
Agent SwarmRuns the work · distributed execution across hosts
FAFO™ MemoryGrounds the work · supplies what is known
Inference FabricPowers the work · keeps the GPUs fedAgent Swarm has its own command surface: deploy a swarm, spin up agents, route work to them, and watch them live. One work order can fan out into hundreds or thousands of specialized agents, each spawning more as the work demands. Here is what makes that fast, safe, and yours.
Every agent in its own sandbox, observed and budgeted. A dead worker is replaced and the work continues.
Every tool, built-in or no-code, runs through one hardened invocation pipeline: validation, authorization, rate limits, quotas, sanitization, audit, and automatic observation. A new tool implements only the one step unique to it, so the catalog scales to thousands without re-litigating safety.
Compose existing tools, wrap a command line, or wrap a REST API in declarative config, with typed, injection-safe parameters. People and agents author new tools without writing code, and a tool ships only with its tests.
A persona is a complete, declarative contract for an agent class: its container, workspace, model routing, allowed tools, network egress, approvals, budget, and who it may talk to. Snapshotted at spawn, so running agents stay deterministic and catalog edits never break in-flight work. Ships with a library of personas and generators to author new ones.
Secrets never touch disk. A secure credential service holds them in memory and a broker releases only what a specific action needs. A privileged agent can perform a narrow action with brokered credentials and return the result, so no keys ever pass between agents.
Agents discover and call each other over an open-standard agent protocol. Every message is signed and verified locally for sub-millisecond peer authorization, with no central round-trip, and a per-host router bridges the mesh across machines.
Every agent registers on spawn and heartbeats its presence, capabilities, and load. Peers discover who can do a job and route to the least-loaded one, and if an agent goes offline its in-flight work is reclaimed automatically.
Hosts are interchangeable. Add, drain, or federate one without disturbing the swarm; every new host inherits the full tool catalog, persona library, and registry the moment it joins. Agent containers are featherweight, so hundreds run per host while GPU model endpoints scale on a separate axis.
Per persona and per turn, the runtime routes each agent to the right model: leading frontier models like Claude, GPT, and Gemini, any OpenAI-compatible endpoint, or local open-weight models on your own GPUs, chosen by policy, load, and budget. Agents never hold a model URL or key; the runtime proxies every call.
Every agent runs in a hardened container with dropped privileges, a read-only root filesystem, and a network egress allowlist. Every meaningful action is captured automatically, and every agent is cost-bounded at the runtime, enforced at spawn and on every model call.
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, specialized worker with a defined role. Agent Swarm composes them from a shared catalog, runs them across hosts, and coordinates them through the mesh. Completed work is the only thing that leaves the system.
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, no runtime ever holds the state. The authoritative work graph lives in PostgreSQL, outside the runtime, so workers, containers, hosts, and even models are disposable. When one dies (and they always die), another reads the current node, dependencies, evidence, contract, and gates from the authoritative work graph and continues. Nothing is reconstructed, because the work state already exists. This is continuation, not recovery, never lost, never duplicated.
Authority and progress live in an authoritative 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.