The Chio platform
Choose where the kernel runs, what survives a worker's exit, and how far authority travels across nodes, agents, and operators.
On this page
The kernel decides one governed operation at a time. The rest of the platform answers what that decision needs once it leaves a single process: a host that keeps its keys and stores, an identity for work that outlives the program running it, control state that several nodes agree on, and terms on which another operator's kernel admits your agents.
Kernel
Kernel
Admits each governed operation under the caller's capability and the operator's policy, runs guards inside admission, dispatches through an adapter, and signs a receipt for the decision.
Read more in Kernel overview.
Each answer is its own contract, and they compose without widening authority. Hosting and coordination describe where decisions run; delegation and federation describe whose authority they carry. A node hosts kernels, a cluster coordinates control state within one operator, a swarm binds delegated work, and federation crosses the boundary between operators.
The kernel decides, and a node gives each decision a durable home
The kernel admits each governed operation under the caller's capability and the operator's policy, runs guards inside admission, dispatches through an adapter, and signs a receipt for the decision. Kernel covers the decision contract, the guard model, capabilities, and policy.
A node is the process around that decision: listeners, session runtimes, durable state, signing keys, health, and shutdown. It runs in process, as a sidecar beside an HTTP service, as a local MCP bridge, or as a process host. Starting a node governs only the operations routed to its kernel, so the deployment decides which other routes it closes.
Read more in Node.
Work keeps its identity when the worker running it exits
An agent process keeps an agent's identity, narrowed authority, checkpoints, and named calls across worker restarts and replacement. A replacement worker resumes the same process, so a lost reply resolves to the original call and no restart mints a fresh allowance. A process tree runs under one root grant, and cancel and revoke cascade through it.
Read more in Agent Processes, or run the Python and Node handoff first.
Several nodes of one operator share one control state
A cluster shares authority, revocations, receipts, and budget exposure across the trust-control nodes of one operator. A leader holds a lease fenced by its term, and replication carries each committed entry to every peer, so a revocation written on one node reaches the next under a known contract. A partitioned peer refuses covered writes and catches up from a snapshot when the partition heals.
The cluster's replication contract matters however many agents you run. It stays inside one trust domain: independently controlled operators share no database and federate instead.
Read more in Cluster.
Delegated work narrows as it branches and crosses to other operators
A swarm binds delegated work to a signed task graph that bounds depth and fan-out. Each child holds less than its parent, results join where the graph declares, and delegated agents draw on one shared budget pool that a restart never replenishes. Several agents can share one node, and a delegated task can also run on another operator's kernel. Swarm covers the graph, its budgets, and joint authorization.
Federation is the standing relationship between operators who share no key. Adding a partner card pins the partner's kernel key, a treaty names the actions the two operators cooperate on, signed authority and evidence cross the boundary, an authenticated transport admits each endpoint, and an enterprise identity provider's principals become stable Chio subjects. Each kernel admits work at its own door under its own policy.
Read more in Federation.
Each platform contract traces to the crate that implements it
The Crate Map indexes the workspace by operational responsibility, from kernel and runtime to integrations, economy, and tooling. Component Responsibilities names the component that owns each kind of state, Spec-to-Crate Index moves from a normative specification to its crate, and Metric Families lists every registered metric.
None of these sections is a setup step for a first governed call. A cluster matters once you distribute control state, and the Security area composes these components into a protected application, with formal proofs, threat coverage, and compliance evidence in its Assurance collection.