Content-routed coordination
for agent systems

Routing without agent-to-agent wiring

Direct calls make each participant depend on the identity and interface of the next one. Adding a capability can require changes to every caller that might use it. This becomes difficult when agents are deployed independently or owned by different teams.

Radia stores work as records. A worker registers a pattern such as { kind: "document", match: { type: "scan" } } and claims records that match it. Publishers do not hold references to workers or choose a destination.

Starting a worker makes its pattern available to the space. If no eligible worker is running, matching records remain available until one can claim them.

Authorization by record content

A summarizer may be allowed to process public filings but barred from confidential ones. The restriction should hold for every worker implementation, including a faulty or compromised one.

A grant identifies a principal, an operation and a record kind. An optional pattern restricts the grant to records whose contents match it.

{ "principal": "agent:summarizer",
  "kind": "document",
  "operations": ["take", "query"],
  "pattern": { "classification": "public" } }

The runtime applies the grant while selecting a claim. The worker receives only records that satisfy both its request and its grant.

This makes the payload part of the authorization decision, rather than leaving the check to agent code. Read about authorization →

Immutable records, mutable claim state

A completed worker does not update its input. It writes a result record that names the input as a parent. The original document remains unchanged.

A result is another routable record. Downstream workers match it in the same way they match an initial request, and parent links preserve how each result was produced.

Follow one document through the whole system →

Getting started

One command starts a space with storage, a web console and a credential already provisioned. From there you can drive it from the shell.

$ deno task dev                     # space + console, in one process
$ deno task compile                 # -> ./radia; put it on your PATH
$ radia put document '{"type":"pdf","classification":"public"}'
$ radia take document --lease 30 --json > claim.json
$ radia ack - --result-kind summary --result '{"text":"..."}' < claim.json

Run it from the checkout: compile it as above, or deno run -A src/main.ts <verb> directly. The npm and pip packaging is built but unpublished, so nothing installs radia for you yet and npx radia does not work today.

The CLI, TypeScript and Python SDKs, web console and MCP adapter all use the public /v0 API. None has a private runtime interface.

A worker declares its patterns and supplies a handler:

import { RadiaClient } from "radia";
import { agentLoop } from "radia/loop";

await agentLoop(new RadiaClient(url, { token }), {
  name: "summarizer",
  patterns: [{ kind: "document", match: { type: "pdf" } }],
  handle: async (rec) => ({
    kind: "summary",
    body: { text: await summarize(rec.body) },
  }),
});

The loop claims matching work, renews the lease while the handler runs and settles the claim with the returned record. If the process exits before settlement, the lease expires and the record becomes claimable again.

What is built

Radia currently runs on SQLite and PGlite for embedded use and PostgreSQL for multiple runtime instances. The same storage contract suite covers all three adapters.