The Fabric

What every thread inherits

An agent joining the fabric writes one handler. Everything else — identity, delivery, retries, audit, cost — is woven in underneath it.

The envelope protocol

Every message signed, addressed and deadlined

All fabric traffic moves over four topic exchanges — messages out to actors, results back, a control channel for registration and heartbeats, and an audit stream every action is published to. Every message is a signed envelope carrying a correlation id, a deadline, the sending service's identity and the requesting user.

Actions are point-to-point: one capability, one competing-consumer queue, one handler. Events fan out: anything on the mesh may subscribe. Capabilities are namespaced, so the portal asks for fabric.ai.classify without knowing — or caring — which agent replica answers.

envelope 
capability: fabric.ai.classify
correlation_id: c1f7…
deadline_at: +30s
service_id: portal          # HMAC-signed
requesting_user: user:1042  # identity travels
payload: { … }

Bus integrity

Per-service HMAC signatures on every envelope — a message claiming to be from the portal has to prove it. Scheduled work carries synthetic system principals, so even cron has a name in the audit log.

Callback auth

When an agent calls back into an upstream application it presents OAuth2 bearer tokens — the same authorisation path a human client would use, never a shared backdoor.

Delivery, guaranteed

Three retries on an escalating ladder — 5s, 30s, 2m — then the dead-letter queue with operator replay. Idempotency by request id, deadlines enforced, graceful drain and a 30‑second heartbeat.

Anatomy of a fabric envelope: capability, correlation id, deadline, HMAC-signed service identity, requesting principal and payload — each field called out around one sealed message, with the four exchanges as compass markers fabric.control fabric.messages fabric.results fabric.audit payload { … } capability fabric.ai.classify correlation correlation: c1f7… deadline_at +30s — or fail honestly service_id: portal HMAC-SHA256 seal requesting_user: user:1042 identity travels reply_to: results.portal the answer knows its way home
Transducers

Workflows that are data, not deployments

A transducer is a named, versioned graph — agent calls, sub-transducers, transforms and control flow — authored visually and executed by a runtime. Publishing one is saving it, not shipping code.

Six ways to fire

Manual, cron schedule, inbound webhook, queue listener — the primary reactive mode — the result of another actor, or a pattern matched in the audit stream. The same graph can carry any of them.

Typed at the ports

Ports derive from each agent's declared input and output schemas. Connections are JSON‑Schema validated at authoring time — an edge between incompatible shapes is refused before the workflow can ever run, not discovered in production.

Dissection of a transducer: six annotated anatomy slides, one per trigger type — manual, cron, webhook, queue listener, result-of and audit-pattern match — each a membrane-bound node organism with trigger receptors, agent organs, control-flow valves, vessels and fine anatomical callouts run-report manual · v3 · live trigger · manual run ▸ obj agent call fabric.data.report ×3 retry node_run obj obj transform ƒ · format → pdf obj str output · email report.pdf → str 01 typed port · json schema 02 capability · namespace.domain.action 03 retry ×3 · 5s / 30s / 2m → dlq 04 state persisted per node_run 05 membrane = version boundary · pinned per run 06 every node = one fabric request 07 hop_count guard ≤ 10 08 exit channel · typed result nightly-compliance cron 02:00 · v5 · live trigger · cron 02:00 obj parallel agent call net.port-scan ×3 node_run agent call net.ssl-check ×3 node_run agent call net.headers ×3 node_run join · all agent call report.compose ×3 node_run output portal 01 fan-out · parallel chambers 02 join-all · waits for every branch 03 retry ring · ×3 then dlq.{agent} 04 every node = one fabric request 05 runs as system principal 06 heartbeat-live agents compete on queue 07 exit channel · portal doc-intake webhook · v2 · live trigger · webhook /intake obj agent call document.extract ×3 retry node_run obj obj if · valve conf ≥ 0.8 t f transform ƒ · to record obj output · db write row output human-review dlq 01 on_error: route → 02 branch predicate is data, not code 03 incompatible edge refused at author time 04 hmac-signed envelope in 05 retry ×3 · 5s / 30s / 2m 06 state per node_run 07 typed t / f channels 08 exit channel · db sensor-enrich queue · v7 · live trigger · queue iot.readings obj transform ƒ · normalise obj obj agent call iot.detect-anomaly ×3 retry node_run obj obj switch · severity low med high output discard output · viz console output · webhook alert 01 switch · multi-way valve 02 large value → fabric-ref:// (minio) 03 competing consumers · one queue per type 04 idempotent · processed:{request_id} 05 deadline_at checked before work 06 retry ×3 → dlq 07 state per node_run 08 exit channels ×3 escalate result-of · v3 · live upstream · enrich v2 trigger · result-of enrich ✓ obj sub-transducer · triage v3 escalation.triage · own membrane, same run agent call ai.summarise ×3 node_run obj str output webhook 01 transducers compose transducers 02 same run · inline execution 03 cell within a cell · nested membrane 04 fires on upstream result 05 llm · targeted subtask only 06 retry ×3 per node 07 named + versioned · postgres rows cost-guard audit match · v1 · live trigger · audit match matched motif obj transform ƒ · window 24h Σ obj num if · valve spend > budget output · webhook budget alert ok · no-op cost_rules base + per-token · £ priced from audit.ai.call 01 fires on patterns in fabric.audit 02 no polling — the stream is the trigger 03 windowed aggregate organ 04 predicate is data · edit & republish 05 per-tenant · timescale hypertable 06 cost_rules editable at runtime · no deploy 07 hop_count guard on the loop 08 exit channel · alert manual cron webhook primary queue result-of audit

You start from a growing catalogue of ready-made workflows rather than a blank page — and every graph you publish teaches the planner to draft the next one.

Cost attribution

Metered at the moment it happens

Metered at source

Cost events land in time-series hypertables as work happens — queryable by tenant, by transducer, by trigger, with continuous aggregates keeping year-scale queries fast.

Operator-tunable rules

Pricing rules live in an editor, not a deploy: adjust a model's rates and the meter reflects it — no release, no restart.

Chargeback-ready

Tenants bring their own provider keys or pay platform rates — a per-tenant billing mode the vault resolves per request. Either way, the spend report writes itself.

Every token has an owner: token particles fall from an AI call into a per-tenant cost meter like coins, an editable pricing rule updates the rate live with no deploy, and the slices deposit into daily time buckets audit.ai.call · 42 in · 157 out cost by tenant tenant-a · own key tenant-b · platform tenant-c · platform cost_rules gpt-4o-mini / 1k out £0.0020 £0.0026 edited live — no deploy fabric_cost_events · daily mon tue wed
The AI supply chain

Any model, resolved per request

Whatever lives inside an agent, its model calls travel one supply chain — resolved, priced and audited by the fabric.

Tenancy Vault

Provider, model routing and billing mode resolved per tenant, per request — API keys AES‑GCM‑encrypted and never leaving the vault. Agents hold an OpenAI‑compatible client and nothing else: swap the provider, not the code.

Inference Specialist

Curated open models behind the same OpenAI‑compatible surface, dispatched by opaque model name — embeddings and small specialised tasks at fabric quality without cloud-provider rates.

House style

Guidance, not law: deterministic code where it can do the job, targeted model calls for the genuinely fuzzy steps, full LLM orchestration reserved for problems that justify the cost — which is also where MCP belongs.

Inside an agent, three ways to use models: a pure deterministic code path, the recommended default of code with one targeted LLM call, and a rare fully LLM-orchestrated hub with tools — with a bar showing most work lives in patterns one and two 1 · pure code parse · route · transform — no model anywhere 2 · targeted subtasks default classify code drives · the model answers one question 3 · llm-orchestrated mcp the model drives — rare, costed, justified where the work lives 1 · most work 2 · the fuzzy steps 3 · rare

For agent-to-fabric paths the envelope protocol already carries identity, schemas and audit — adding MCP there would add cost and complexity with no benefit.

See a thread run end to end

A briefing walks a real workflow through the fabric — envelope to result, with the cost meter running.

Request a technical briefing Read the principles