Crate Map
Find the Rust crate behind a Chio capability, from portable authority checks to hosted execution, swarms, federation, and markets.
On this page
Behind each Chio capability sits a Rust crate. The crate index lists all 162 workspace members with each one's path, the Platform section that documents its behavior, and what it implements.
Search by crate name or by responsibility, such as receipts, admission, or settlement. Paths and membership come from the workspace manifest at the documentation pin; the section and the purpose line are written for each crate. 136 members keep an ARCHITECTURE.md beside their manifest.
Crate layers
Sixteen crates carry the authority path, layered so that every drawn dependency points down or across. The portable decision core sits below the hosted kernel that runs it.
chio-kernel-core
The decision core: no_std with alloc, built for wasm32 as well as native targets. It depends on chio-core-types alone. Portable kernel.
Layer: portable leaves. Libraries whose only workspace dependency is chio-core-types, among them the no_std decision core.
Depends on 1 workspace crate, 1 drawn; used by 7, 2 drawn. Its manifest describes it as “Portable (no_std + alloc) Chio kernel core: pure verdict evaluation, capability verification, and receipt signing.”
lib.rs:11//! This crate re-exports `chio-core-types` and the dedicated domain crates
//! (`chio-appraisal`, `chio-autonomy`, `chio-credit`, etc.) under a single
//! `chio_core::*` import surface for consumers that prefer a unified entry point.
// …
pub use chio_appraisal as appraisal;
pub use chio_autonomy as autonomy;
// …
pub use chio_credit as credit;
// …
pub use chio_federation as federation;
chio-kernel-core is the portable evaluator: no_std with alloc, built for wasm32 as well as native targets, with one workspace dependency (chio-core-types) and seven dependents. chio-kernel runs the same evaluation code alongside its own request matching, live stores, and execution stages.
A portable Allow is a decision about one request. Dispatch, approval, and receipt retention happen in the hosted kernel. The portable build disables default features, and hosted features such as the revocation snapshot view compile into the same crate, so check the enabled features before assuming a facility runs on the portable evaluation path.
Read more in Core & Shell.
Entry points by contract
Start from the behavior you are tracing. Each entry point links to its crate in the index.
- Signed authority and records. chio-core-types holds capabilities, receipts, protocol types, canonical encoding, and the signing and hashing code.
- Portable decision logic. chio-kernel-core evaluates supplied authority and context: scope matching, synchronous guard evaluation, and delegated-share admission.
- Hosted execution. chio-kernel runs admission, approvals, tool dispatch, accounting, and evidence finalization.
- Executable policy. chio-policy configures the guard implementations and compositions in chio-guards.
- Browser and mobile. chio-kernel-browser and chio-kernel-mobile adapt the portable core to each platform's interfaces.
- Delegated task execution. chio-swarm-authority holds task graphs, delegated budgets, joins, and execution authority.
- Cross-operator trust. chio-federation holds trust establishment, agreements between operators, admission, and shared signing.
One refused call across the crates
An outside buyer's agent asks the pricing service for a USD 120.00 refund on order-77. chio policy explain walks that call through the pricing project's compiled guards in order, admitting nothing and writing no receipt:
chio policy explain policy.yaml --server pricing --tool refund \
--params '{"order":"order-77","amount":"120.00"}'call pricing.refund {"order":"order-77","amount":"120.00"}
1 forbidden-path pass
2 egress pass
3 refund-ceiling deny USD 120.00 exceeds the USD 50.00 ceiling
stopped at guard 3 of 3; decision denyEach line belongs to a crate. chio-policy compiled the three guards from the HushSpec document, chio-guards implements them, and chio-kernel-core runs them in order and stops at the first deny. On a live call, chio-kernel then signs the deny receipt with refund-ceiling in its evidence array, using the types in chio-core-types.
Source files for one call
- What portable evaluation checks.
crates/kernel/chio-kernel-core/src/evaluate.rs - How input guards combine.
crates/guards/chio-guards/src/pipeline.rs - What happens to returned output.
crates/kernel/chio-kernel/src/post_invocation.rs - How a response is finalized.
crates/kernel/chio-kernel/src/kernel/responses/finalization.rs - What gates a swarm task.
crates/kernel/chio-swarm-authority/src/verifier.rs
Ownership by Platform section
Each crate entry names the section whose pages document its behavior. A section answers one question about the work the kernel mediates.
- Kernel: the authority and policy that permit a mediated action.
- Node: sessions, state, execution, and recovery inside one hosting process.
- Cluster: admission and trust state coordinated across one operator's fleet.
- Swarm: delegated authority over tasks, branches, and joins.
- Federation and compliance: trust between operators, and the evidence behind an external control.
- Formal assurance: which property rests on which implementation, model, or assumption.
- Economy: how authority, delivery, payment, and metering connect.
A source directory groups code, and the section follows behavior. A rate-limit guard belongs to kernel policy even though it reads state; the store behind it is a Node subject. chio-runtime-core lives under crates/kernel/ and owns orchestration and admission services, filed under Cluster. chio-swarm-authority, in the same directory, governs delegated task graphs under Swarm.
One crate can serve two sections. In chio-federation, threshold and bilateral signing support jointly authorized actions, documented under Swarm. Trust establishment, treaties, and admission support relationships between operators, documented under Federation.
Read more in Federation & Swarms.
Trusted enforcement base
The kernel, its signing keys, the configured native guards, and the runtime state they read form the trusted enforcement base. Agent input and tool output cross into it from outside. WASM isolation, process confinement, storage behavior, and network trust come from the deployment that hosts the kernel.
The market, underwriting, credit, reputation, web3, and payment-rail crates are optional modules, off in default builds of the kernel, core, control plane, and CLI.
Read more in the Assurance Model.
Crate index
Every workspace member, grouped by its directory under crates/, then the examples, harnesses, benchmarks, and packages that live elsewhere in the workspace.
Search for a crate, or a responsibility such as receipts, admission, or settlement. Each crate has its own link.
Core types and shared contracts
chio-core
One import surface over chio-core-types plus the economy and trust domain crates. Adds three contracts of its own: the extension and official-stack model, the identity-network model, and the portable-standards catalog. No I/O and no runtime state.
chio-core-types
The canonical protocol types and the crypto that signs them: capabilities, receipts, sessions, messages, manifests, canonical JSON, Ed25519 signing backends (the pq feature adds ML-DSA-65 and hybrid), and hashing plus Merkle. no_std plus alloc by source, so it cross-compiles to wasm32-unknown-unknown and other embedded targets.
chio-errors
Typed error codes and diagnostics. The published catalog is Reference, Schemas and Errors.
chio-adversarial-suite
The curated adversarial trust-boundary corpus and its case schema.
chio-arena
Deterministic arena scenario runner and replay-bundle writer.
chio-bounded
Bounded in-memory collections for serving processes: a ring, a capacity-and-TTL map, and a live size gauge. One process’s memory ceiling.
chio-supervisor
Task supervision and monotonic health flags for serving processes: restart with capped backoff, never self-heal, fail closed.
Kernel and runtime
chio-kernel
The full kernel. Its subject is the decision and the signed receipt. Its rusqlite-backed receipt, revocation, budget, and lineage stores, its transports, and its lifecycle are Node subjects even though the code sits here.
chio-kernel-browser
Browser bindings over the portable core through wasm-bindgen: evaluate, sign_receipt, and verify_capability with a browser clock and a WebCrypto RNG.
chio-kernel-core
The portable verdict path with explicit caller-supplied context and delegated-share admission. See the entry points.
chio-kernel-mobile
UniFFI wrapper over the portable core for iOS and Android.
chio-runtime-harness
Live runtime loopback harness for proof regeneration.
chio-swarm-authority
Task graphs, delegation witness chains, budget fan-out and fan-in pools, continuation tokens, route plans, revocation epochs, join and terminal graph receipts.
chio-runtime-core
Live runtime admission: admission profiles and bundles, signed verifier trust bundles, trust-floor state, orchestration plans, run leases, and the scheduler tick.
chio-runtime-proof-parity
Evidence manifest, proof-parity, and proof-regeneration report schemas. A verification gate.
chio-runtime
Facade over chio-runtime-core plus its JSON and SQLite stores. Exposes only the admission, trust-floor, orchestration, operations, and proof-regeneration APIs.
Guards and policy
chio-data-guards
Guards that inspect data-store semantics: SqlQueryGuard, VectorDbGuard, WarehouseCostGuard, and QueryResultGuard.
chio-data-guards-redactors-default
The default redactor behind the chio:guards/redact@0.1.0 world: secrets, basic PII, and bearer-token stripping, applied before any frame is buffered. A tenant may swap in a signed override module.
chio-external-guards
HTTP-backed provider checks that participate in kernel policy. Their connection, timeout, circuit-breaker, and endpoint-egress settings belong to the deployment contract.
chio-guard-registry
OCI distribution for .arcguard WASM components: pull, publish, cache, and offline bundling. One process answers this from its own cache. Signature verification delegates to chio-attest-verify.
chio-guards
The main guard catalog and the pipeline types: the sync pipeline, the advisory pipeline, post-invocation hooks, and the external adapter infrastructure.
chio-policy
The HushSpec policy format: schema types, evaluation, merge and inheritance rules, and compile_policy, which turns a document into a configured pipeline pair.
chio-wasm-guards
Host runtime for operator-authored WASM guards. Raw core modules and the chio:guard@0.2.0 Component Model world, backed by wasmtime with fuel metering. Module distribution and rollout are Node.
SDKs and bindings
chio-guard-sdk
Guest-side SDK for authoring WASM guards in Rust against the chio:guard@0.2.0 world.
chio-guard-sdk-macros
The #[chio_guard] attribute macro. Wraps a plain evaluate function in the raw core-module ABI and re-exports chio_alloc, chio_free, and chio_deny_reason.
chio-binding-helpers
Bindings-friendly invariant helpers shared by the multi-language SDKs. Reference, SDK.
chio-bindings-ffi
The C ABI for deterministic SDK invariant helpers: UTF-8 strings and byte buffers across an explicit allocation boundary.
chio-cpp-kernel-ffi
The C ABI for the C++ offline kernel SDK.
chio-eval-receipt
Reference verifier for chio.eval-report.bundle.v1 receipt bundles.
Observability
chio-lineage
The lineage and provenance DAG over one node’s receipts.
chio-log-redact
The tracing redaction layer and macro for operator-facing telemetry.
chio-metrics-spec
The workspace-wide metric registry. Metric names are settled here.
chio-otel-receipt-exporter
OpenTelemetry trace ingress and receipt-store sink.
chio-siem
SIEM export for the receipt audit pipeline. It polls one node’s receipt database on a cursor.
Platform services
chio-agent-web-interop
The Agent Web interop verifier for a proof bundle’s interop section.
chio-commerce-order
The commerce order passport verifier.
chio-config
The chio.yaml loader, with environment interpolation, strict deny_unknown_fields deserialization, and post-load validation.
chio-control-plane
The trust-control service, its client, issuance and registry operations, cluster health projection, bounded federation policy, and SCIM lifecycle.
chio-enterprise-export
The enterprise export verifier for a proof bundle’s export section.
chio-finding-market-port
Store-neutral ports and identity types for the hosted cognition market. Edge and application code depend on these rather than on a database, and an adapter that cannot answer fails closed.
chio-finding-market-migrations
The embedded SQLx migration ledger for the hosted cognition market. It depends on sqlx-core directly so migration support cannot pull SQLx’s SQLite driver into the workspace’s rusqlite graph.
chio-finding-market-store-postgres
Tenant-isolated PostgreSQL durability for the hosted market. Every tenant-scoped operation sets chio.tenant_id transaction-locally, and row-level security is enabled and forced, so a missing tenant context returns no rows and admits no writes.
chio-finding-hosted-edge
The hosted market’s authentication and edge security boundary. It authenticates one explicitly selected credential mode before a request body reaches a market handler.
chio-finding-worker
Firecracker-isolated execution for hosted market jobs: digest-pinned guest assets staged into a unique jail, started only through the jailer, exchanging bounded canonical JSON frames over vsock.
chio-manifest
The signed tool-server manifest: declared tools, their schemas, and their required permissions, signed with the server’s Ed25519 key. Verification at process start is a Node boot step.
chio-risk-comptroller
Risk comptroller report validation for a proof bundle.
chio-sqlite-file-identity
The audited boundary that binds a rusqlite connection to the exact main-database file SQLite borrowed, over the workspace’s pinned bundled build.
chio-store-sqlite
The persistence layer: receipt store and query path, budget, approval, lineage, revocation, execution-nonce, encrypted-blob, IOU, and dead-letter stores. It implements traits defined by chio-kernel.
chio-transaction-passport
Transaction Passport verifier primitives. The assembled bundle is Products, Proof Room.
chio-trust-market-context
The trust-market context verifier for a proof bundle.
chio-workflow
Skill and workflow authority: multi-step skill composition, manifests, and workflow receipts.
chio-workflow-preflight
The read-only preflight that bounds child scope before a plan runs.
chio-http-core
Protocol-agnostic HTTP security types for the kernel.
chio-http-session
The per-session journal: request history, cumulative data flow, and tool-invocation sequence. The guards that read it are Kernel.
Protocol integrations
chio-a2a-adapter
The thin A2A-to-Chio adapter for agent-card discovery and SendMessage mediation.
chio-a2a-edge
The A2A edge, which exposes Chio tools as blocking A2A skills. A process that hosts a kernel, which is what makes it a node.
chio-acp-edge
The ACP edge, which exposes Chio tools as ACP capabilities with a bridge-fidelity assessment.
chio-acp-proxy
The ACP security proxy that enforces capability-based access control on ACP agent sessions.
chio-ag-ui-proxy
The AG-UI proxy: capability-validated interception of agent-to-UI event streams.
chio-anthropic-tools-adapter
Mediates Anthropic Messages tool-use traffic, pinned to one API version. Build, Govern Any Provider.
chio-bedrock-converse-adapter
Mediates Amazon Bedrock Converse traffic over SigV4-signed calls, pinned to one workspace AWS SDK.
chio-cohere-tools-adapter
Mediates Cohere chat tool-use traffic, pinned to one API version.
chio-cross-protocol
Shared cross-protocol bridge contracts and the orchestrator runtime.
chio-edge-metrics
The shared receipt-write metrics sink for the edge crates.
chio-egress-contract
The typed HTTP egress contract for substrate adapters.
chio-envoy-ext-authz
The Envoy ext_authz gRPC adapter that bridges external authorization checks to the kernel.
chio-gemini-tools-adapter
Mediates Google Gemini generateContent tool-use traffic, pinned to one API version.
chio-groq-tools-adapter
Mediates Groq’s OpenAI-compatible chat completions tool-use traffic, pinned to one API version.
chio-mcp-adapter
The MCP wire adapter that wraps MCP servers as Chio tool servers.
chio-mcp-edge
The MCP edge runtime and its shared transport contracts.
chio-mcp-remote
The remote hosted MCP runtime surface.
chio-mistral-tools-adapter
Mediates Mistral chat-completions tool-use traffic, lifts tool_calls into the kernel fabric, and gates streamed responses.
chio-ollama-tools-adapter
Mediates Ollama chat tool-use traffic, pinned to one API version.
chio-openai-adapter
Intercepts OpenAI Chat Completions and Responses tool calls and mediates them through the kernel for capability validation and signed receipts.
chio-openapi
OpenAPI 3.x parser that generates a Chio ToolManifest. Build, Bridge OpenAPI to MCP.
chio-openapi-mcp-bridge
Presents governed HTTP APIs as MCP tool surfaces and routes every invocation through the kernel.
chio-provider-adapter-core
The primitives every provider-native adapter shares.
chio-provider-conformance
The replay harness for the provider adapters and their conformance fixtures.
chio-tool-call-fabric
Provider-independent tool dispatch and integration contracts, documented with node execution.
chio-tower
Tower middleware for capability validation and receipt signing.
chio-hosted-mcp
The hosted MCP runtime surface.
chio-http-serve
Graceful shutdown, connection drain, and server hygiene shared by every Chio HTTP service.
Identity and trust
chio-finding-challenge
The pure finding-challenge evaluator: a signed challenge plus the exact evidence its class selects in, one typed verdict the caller signs out. It fetches nothing, invokes nothing, reads no clock, touches no storage, and signs nothing.
chio-finding-verifier
The offline finding evidence verifier, which turns a raw finding plus a resolved evidence bundle and pinned trust roots into a structured facet report.
chio-replay-corpus
Replay corpus helpers for TEE captures: canonical invocation dedupe and default re-redaction.
chio-attest-buyer
The buyer attestation verification boundary. Products, Proof Room.
chio-attest-verify
The single source of truth for Sigstore verification across the workspace. Guard and image supply chain.
chio-custody-hw
Hardware custody: hybrid-backend-signed capabilities, a replay-resistant nonce store, and the revocation cascade, including the passkey path and its store. Key generation and rotation lifecycle are Cluster.
chio-signing-remote
Fail-closed remote signing backends for hosted deployments. Both pin an explicit public key and key version, and a transport response is accepted only after local strict verification over the exact input bytes.
chio-weights
The model-card surface: signed weights cards, the cosign bundle helper, kernel binding refusal, and chio bind --card. Learn, Model Cards.
chio-tee
The TEE shadow runner that captures one kernel’s decisions and emits signed, redacted replay frames. Hardware backends and assurance tiers are Cluster.
chio-tee-frame
The Chio TEE replay-frame wire format, with canonical encoding, structural validation, and tenant-signature verification.
chio-credentials
Portable reputation credentials and Agent Passport verification.
chio-did
Self-certifying did:chio documents and their resolution.
chio-disclosure-lineage
The lineage verifier reports for what was disclosed to whom.
chio-federation
Trust establishment, treaties, threshold signing, and bilateral authorization. See the federation split.
chio-federation-transport-iroh
The adapter for the optional iroh lane between federation peers on self-hosted relays, gating admission at accept time against an issuer-signed endpoint directory. It sits strictly under chio-federation and replaces no trust logic.
chio-governance
Governance charters and case evaluation. The escalation ladder is Swarm; charter authoring is Economy, Listing Disputes.
chio-attest-buyer-core
Offline proof-package verification for Chio buyers and auditors.
chio-federation-authority
Runtime issuance of federation authority artifacts.
chio-attest-loopback
The deterministic loopback proof package and its runtime harness.
chio-pheromone
The local signal store (the pheromone layer) and its observation-cost evidence types.
chio-pheromone-relay
The relay service that carries signals between parties, with its durable local state.
chio-pheromone-runtime
The local receiver runtime and its durable store.
chio-revocation-oracle
Signed sparse-Merkle epoch roots, freshness windows, and passport-bridge revocation lookups. A node’s local revocation store is Node; the oracle answers across authorities.
chio-reputation
Deterministic local reputation scoring for agents.
chio-selective-disclosure
BBS selective-disclosure projections and proof packages over receipts.
Economy
chio-anchor
Checkpoint anchoring and multi-lane proof normalization: EVM root-registry publication, checkpoint-to-Bitcoin super-root aggregation with OTS linkage, Solana memo records, and fail-closed bundle verification. Gated behind the web3 feature.
chio-appraisal
Runtime attestation appraisal artifacts and their evaluation. Reference, Economy Crates.
chio-autonomy
Bounded autonomy pricing, execution, and rollback contracts.
chio-credit
Credit, capital, and bonded execution contracts.
chio-fincred
Wire-neutral financial credential contract types.
chio-finding
The signed cognition-market finding artifact and every supporting market artifact family, with fail-closed pure validation and inline signing. No storage, no I/O, no kernel wiring.
chio-fiscal
Governed fiscal charter and schedule contracts.
chio-link
The oracle runtime for cross-currency budget enforcement.
chio-listing
Generic listing and trust-activation contracts.
chio-market
Liability-market provider, quote, and claims contracts.
chio-open-market
Open-market economics and penalty contracts.
chio-settle
The settlement runtime for web3 escrow and bond execution.
chio-underwriting
Underwriting decision, simulation, and appeal artifacts.
chio-web3
Web3 settlement, anchoring, and contract-surface artifacts.
chio-web3-bindings
Alloy bindings and packaged artifacts for the official web3 contract family.
chio-metering
Receipt metering and economics: cost attribution, budget enforcement, and billing export.
Tooling
chio-lsp
The language server: chio.yaml, manifest, and guard DSL diagnostics, completion, hover, and go-to-definition.
chio-conformance
Cross-language conformance scenarios, native and cross-peer harnesses, and compatibility reports for authoring and integration validation.
chio-verdict-matrix-driver-lambda
The Lambda deployment-shape driver for the verdict matrix. It loads the verdict-matrix scenario corpus and emits one verdict, reason-code, and scope-set tuple per scenario.
chio-release-evidence
The signed, exact-candidate release qualification manifest.
chio-spec-codegen
Schema-to-Rust codegen for the wire types, on a typify backend.
chio-spec-validate
The JSON Schema validator that checks documents against the committed spec/schemas/ set before integration. See Testing Guards and Policies.
chio-trace-validate
Offline validation of signed observation traces.
chio-test-support
Shared test-only assertion helpers for the workspace.
Products
chio-api-protect
Zero-code reverse proxy that protects HTTP APIs with signed receipts. Build, Protect an API.
chio-cli
The binary. Its command surface is Reference, CLI. What it starts is a node, and it stays a shell over chio-hosted-mcp and chio-control-plane.
chio-finding-market-migrator
The dedicated schema migrator for the hosted cognition market.
chio-finding-market-canary
The exact-job provisioner and verifier for hosted market qualification.
chio-finding-market-server
The authenticated PostgreSQL cognition-market HTTP server.
chio-finding-worker-daemon
The hosted market’s Firecracker worker daemon.
chio-mercury
The MERCURY product CLI.
chio-mercury-core
Typed MERCURY evidence contracts layered on receipt truth.
chio-proof-room
The Proof Room quickstart server.
chio-wall
The Chio-Wall companion-product CLI.
chio-wall-core
Typed Chio-Wall control-path contracts layered on guard and receipt truth.
Members outside crates/
Runnable examples, validation harnesses, benchmarks, and distribution packages also belong to the workspace.
chio-bedrock-control-plane
AWS Marketplace entitlement and metering contract helpers for the Bedrock listing. Deterministic and testable without AWS credentials.
chio-mcp-adapter-integration
The distribution package for the registry-listed MCP server: Streamable HTTP, OAuth 2.1 with PKCE, protected-resource metadata, and receipt emission over the chio-mcp-edge transport contract.
bilateral-invocation
A bilateral co-signed invocation demo with a partial local verifier over the resulting DSSE signature-slice envelope.
chio-three-vendor-example
A deterministic three-vendor buyer and auditor proof package.
cross-provider-policy
A dry-run policy demo proving cross-provider verdict equality.
chio-example-enriched-inspector
An example guard that reads the enriched action_type and extracted_path fields and calls the chio::log and chio::get_config host functions.
chio-example-tool-gate
An example guard that inspects the request tool name through the guard SDK and allows every tool except those on a deny list.
hello-a2a
An A2A edge wiring the adapter with receipt-bearing task results.
hello-acp
An ACP edge wiring the adapter with capability-gated prompts.
hello-mcp
An MCP edge wiring the adapter with receipt-bearing tool calls.
hello-tool
A tool server exposing one greet tool.
otel-genai
An OpenTelemetry GenAI demo for receipt and span lookup.
chio-formal-diff-tests
Differential testing: random inputs run against the reference spec and the production implementation, and the two answers compared.
chio-e2e
Integration tests that run the whole runtime stack.
chio-replay-gate
The deterministic-replay corpus driver and golden infrastructure for the kernel.
chio-chaos
The fault-injection chaos harness for the receipt store: a scenario vocabulary, a typed failure surface, and a deterministic seeded RNG.
chio-loadgen
The full-stack load generator. It boots a live kernel wired to a SQLite receipt store and a configurable-latency fixture.
healthcare-pilot-capacity
The sustained-load capacity harness for healthcare workloads, deterministic in continuous integration.
ttfrh-bench
The TTFRH bench harness, reporting p50 and p99 over a deterministic in-process simulation layer.
zed-chio
The Zed editor extension. It spawns chio-lsp through Zed’s LSP adapter API.