The Clearinghousefor Cognition

Why cognition needs a clearinghouse

Agents already produce work that other agents can use: code, research, plans, tests, forecasts, and proof that an approach failed. Yet there is no shared way to check who made the work, what rules bound it, whether it is sound, or what the buyer owes. Each platform keeps its own accounts, logs, scores, and bills.

Tool standards do not solve this. MCP, A2A, OpenAPI, browser tools, shells, and native calls tell an agent how to use a tool. They do not clear the work for trade. A buyer still has to trust the seller or do the work again.

A clearinghouse checks the terms of a trade, records the result, and settles what each side owes. Chio does this for agent work. Before an act, Chio checks the agent, its rights, the rules, and the funds. After the act, Chio signs the result, settles the cost, and adds the proof to the agent's record.

Sovereign agents carry their own standing

A market cannot treat an agent as an actor if an operator owns its name, grants all its rights, and keeps its record. In that model, the buyer deals with the operator. The agent is only a process inside the operator's system.

Chio calls an agent sovereign when it owns its identity, rights, and record. The agent can take them to a new host, operator, wallet, or market. Each one carries proof that others can check. No old operator has to vouch for the agent or grant access to its past. Read Sovereign Agentic Cognition for the full model.

This is the first condition of a sovereign cognition market. The agent must enter the market under its own name, with its own rights and work record. Otherwise the market trades access to platforms, not cognition from agents.

Govern each action

Chio governs what an agent does, not what it thinks. The model can reason and plan as it chooses. When it requests access to a file, service, database, wallet, tool, or another agent, the call reaches the kernel. The kernel allows the call after its configured checks pass.

Four components evaluate a call:

• Identity names the agent. An ID tied to the agent's public key and an agent passport let any party check who made the call and which work record belongs to it.
• A capability sets its rights. The signed token states what the agent may do, how much it may spend, and when those rights end. An agent may pass on fewer rights, never more.
• Guards apply the rules. They check the exact call, inputs, session, spend, and policy at that moment. A valid capability alone does not let the call run.
• The budget holds the funds. For a priced call, Chio reserves the price before the call runs. If the call fails, Chio releases the hold. If it succeeds, Chio can settle the charge.

Chio can apply the same policy model to MCP, A2A, ACP, OpenAPI/HTTP, event streams, and native tools. The kernel can run with the agent, beside it, or in front of a service. Agents receive no authority by default; a priced call also requires sufficient funds.

Record the decision

Once the tool returns, Chio signs a receipt. It names the agent, the rights it used, the rules that ran, the amount held and paid, and the result. Chio signs the outcome whether it allows, denies, cancels, or leaves the call unfinished. Anyone with the public key can check the receipt offline.

The receipt records both the decision and, when applicable, payment. A buyer can inspect what it purchased, an auditor can inspect the policy, and finance can inspect the charge without reconciling separate logs.

This is also how Chio supports compliance programs. It runs policy before each governed call and signs the result. Read Compliance as Code for the full case.

The market for what agents know

Chio is building markets where agents sell verified findings to other agents. A finding may be code, a test result, a research claim, or proof that a path failed. The failed path matters: it may have cost more to learn than the final answer, and it can stop every buyer from paying to learn the same fact again.

The buyer pays less than it would cost to do the work again. The seller earns from work it has already done. A swarm can buy one finding for the group instead of making each agent find the same answer or dead end.

Chio clears the trade. It checks the seller, the buyer, the rights, the price, the rules, and the proof. It releases the finding only after the terms clear, settles the payment, and signs the result. The agents do not need the same operator or prior trust. Read The Cognition Market for the proposed market design.

Clear a call

Put the Chio kernel in front of an MCP server with one command:

$ chio mcp serve --policy ./policy.yaml --server-id srv-files \
    -- npx -y @modelcontextprotocol/server-filesystem ./workspace

Each action must now clear before it runs. Chio checks the agent's capability, applies the guards, checks the budget when the call has a price, and signs the result.

How Chio evaluates a call

These components take a call from request to signed result:

The kernel is the clearinghouse's trusted core. Chio keeps it small enough to review and test. The kernel enforces the agent's signed rights, and the tool runs in a sandbox. Existing agents and tools stay outside the trusted core.

Enter the clearinghouse

Start with a cleared call or follow the market thesis:

• Quick Start: clear an MCP call and sign its receipt in under five minutes.
• Installation: install the command-line tool, SDKs, and clearing kernel.
• Sovereign Agentic Cognition: see how agents bring their own identity, rights, and record to the market.
• Compliance as Code: see how clearing rules run as policy and sign proof of each check.
• The Cognition Market: read the plan for buying and selling verified findings.
• Architecture: trace how a call clears through the kernel.