Quilts that link to other quilts

01The insight: double-entry is already reactive

In a Quilt sheet, every computed cell has a list of parents — the cells it reads from. When a parent changes, the engine recomputes the child. The child pulls from its parents. From the parent's perspective, the same event is a push — it just published a new value to whoever depends on it.

The engine doesn't care which direction the arrow points. The propagation is symmetric. This is double-entry bookkeeping, and it is already the reactive model. A change in cell A flows to cell B; A and B don't agree on who initiated, they only agree that a propagation happened.

Everything else on this page is the consequence of that one observation. The URI scheme, the two new SDK functions, the FederatedQuilt class, the Codespaces-native orchestrator — they are all the same reactive engine with a wider reach.

• Local cell → in-process subscriber, push via in-memory event
• LAN cell → WebSocket subscriber, push via JSON-over-LAN
• Codespace cell → HTTPS subscriber, push via JSON-over-MCP
• Fleet cell → wildcard subscriber, push to every matching instance

One engine, one subscription model, one audit log. The network is just a slow bus.

02The URI scheme

The URI is the only thing that changes between local and remote. It is deliberately similar to other well-known schemes you already trust — and the grammar is small enough to implement in 10 lines.

The instance-id is a logical name for a running engine — local, jetson-lab, codespace-7c3, or an ESP32 serial number. The sheet-id is the name of the manifest loaded in that engine. The cell-path is the dotted path to a cell within the sheet, and supports the + wildcard for fleet-wide subscriptions.

Five shapes you will use

Resolution algorithm (10 lines)

// resolve a quilt:// URI to a live subscriber handle
function resolveCell(uri, ctx) {
  const m = uri.match(/^quilt:\/\/([^/]+)\/([^#]+)#(.+)$/);
  if (!m) throw new Error(`bad URI: ${uri}`);
  const [_, instance, sheet, cell] = m;
  if (instance === 'local') return localEngine.cell(`${sheet}#${cell}`);
  if (instance === '*')       return router.fanout(sheet, cell, ctx);
  return transport.connect(instance).subscribe(sheet, cell, ctx);  // LAN / HTTPS / MCP
}

That's it. The rest of the federation story is what happens around that handle: how the subscription is set up, how pushes are routed, how the run trace is recorded. None of that changes the cell's evaluate() — it just calls derive() on its parents and the parents happen to be on a different quilt.

03The federation primitive

Two new SDK functions and one new class. They are deliberately minimal: resolve a cell, subscribe to a cell, and stitch multiple engines into one addressable graph. Everything else is composition.

import { resolveCell } from '@quilt/federation';
// local — instant, in-process
const rudder    = await resolveCell('quilt://local/boat-autopilot#rudder.angle');
// remote — opens MCP/HTTPS, streams values
const anomalies = await resolveCell('quilt://codespace-7c3/prod#anomaly.detector', { run_id: '01HXY' });
console.log(rudder.value, anomalies.value);  // current values

import { subscribeCell } from '@quilt/federation';
// "tell me whenever the cloud's PID tuning changes"
const off = subscribeCell('quilt://codespace-7c3/prod#tune.pid_kp', (kp, trace) => {
  console.log(`kp → ${kp.value} by ${trace.actor} at ${trace.t}`);
  algoPid.derived_from = ['kp'];  // rewire locally
});
// later
off();  // close the subscription, release the socket

The FederatedQuilt class

The class that stitches multiple engines into one addressable graph. It owns the routing table, the transport adapters, and the cross-engine propagation log. You can think of it as a superset of an engine — it has cells, and its cells can be on other engines.

// FederatedQuilt — a quilt of quilts. Each "node" is a real Engine (local)
// or a remote URI handle (remote). One trace log for the whole fleet.
import { Engine }      from '@quilt/core';
import { resolveCell } from '@quilt/federation';
import { transport }   from '@quilt/transport';

export class FederatedQuilt {
  constructor(name) {
    this.nodes = new Map();  // instance-id → Engine | Remote
    this.edges = [];          // { from, to, kind }
    this.trace = [];          // every cross-tier change
  }
  addLocal(id, engine) {
    this.nodes.set(id, engine);
    engine.on('change', (cell, _p, next, actor) =>
      this._propagate(id, cell, next, actor));
    return this;
  }
  async addRemote(id, ep) {
    const conn = await transport.connect(ep);
    this.nodes.set(id, conn);
    conn.on('push', (cell, value, actor) =>
      this._propagate(id, cell, value, actor));
    return this;
  }
  wire(from, to, kind = 'mirror') { this.edges.push({ from, to, kind }); }
  async resolve(uri, ctx = {}) { return resolveCell(uri, ctx); }
  private async _propagate(fromId, cell, value, actor) {
    this.trace.push({ t: new Date().toISOString(), from: fromId, cell, value, actor });
    for (const e of this.edges.filter(x => x.from.startsWith(fromId) && x.from.endsWith(cell))) {
      const [tier, path] = e.to.split(/#/);
      await this.nodes.get(tier.split(/\//)[0])._setCell(path, value, actor);
    }
  }
}

// 3 lines to federate a fleet
const fleet = new FederatedQuilt('boat-fleet');
fleet.addLocal('local', esp32Engine);
fleet.wire('local#mirror.rudder',        'jetson-lab/perception#mirror.telem');
fleet.wire('jetson-lab#perception.fused', 'codespace-7c3/prod#anomaly.input');

That is the entire federation surface. The class is ~90 lines; the rest is transport adapters and routing. Notice what is not there: no message broker, no service mesh, no API gateway, no protocol negotiation. The cells push and pull; the engine routes; the trace is one log.

04The killer example: Fed-Autopilot

A 3-tier Quilt stack for an autonomous boat. ESP32 at the bottom, Jetson in the middle, GitHub Codespace at the top. Each tier runs an engine; each engine has its own cells; the cells are linked by quilt URIs that cross the network boundaries. There is no separate message bus. The reactive graph is the bus.

What runs where

What pushes up, what pulls down

05Codespaces-native Quilt

GitHub Codespaces is the canonical orchestrator target. It gives you a real Linux box in the cloud, a browser-based terminal, a public HTTPS endpoint on a stable subdomain, and an env-var-based secret store — all without managing a server. For a fleet of boats (or any small fleet of edge devices), this is exactly the right shape of orchestrator: cheap, ephemeral, fully scriptable, and reachable from anywhere on the internet.

Six steps to a Quilt in a Codespace

06Live 3-tier demo

Three simulated Quilt engines, one reactive graph, real propagation. Click the buttons; watch the values flow; read the run trace. This is the same code path that runs on real hardware — just with fake sensors.

The buttons above trigger real propagation through the simulated federation. Every cell that receives a value pulses green (upstream) or blue (downstream). Every change appends to the run trace. The SVG edges between tiers are dashed at rest and light up as the value flows through them.

07Cross-Quilt observability

Every cross-tier change is a run trace. The trace is the same shape as the local trace — one log, append-only, hash-chained — but with an extra field: the origin_tier and the trace_id that lets you correlate the same value across every quilt it touched.

Example trace JSON

// one cross-tier change, 3 tiers, 6 cells
{
  "trace_id":     "01HXY2K9-7c3",
  "t":            "2026-01-15T14:22:01.482Z",
  "origin_tier":  "esp32-7c3-a1b2",
  "origin_actor": "sensor:rudder-pot",
  "hops": [
    { "tier":"esp32-7c3-a1b2", "cell":"sensor.rudder",    "value":0.42, "ms":0   },
    { "tier":"esp32-7c3-a1b2", "cell":"mirror.rudder",    "value":0.42, "ms":0,   "kind":"mirror" },
    { "tier":"jetson-lab",     "cell":"mirror.telem",     "value":0.42, "ms":11,  "transport":"websocket/lan" },
    { "tier":"jetson-lab",     "cell":"perception.fused", "value":0.44, "ms":28,  "kind":"formula" },
    { "tier":"codespace-7c3",  "cell":"anomaly.input",    "value":0.44, "ms":187, "transport":"https/mcp" },
    { "tier":"codespace-7c3",  "cell":"anomaly.detector", "value":true, "ms":203, "kind":"ai" }
  ],
  "totals":{ "ms":429,"cells":6,"tiers":3 },
  "hash":"sha256:f1b4...7e"
}

The ledger view

Each Quilt is its own "book" in the double-entry sense. The local trace is one ledger; the federated trace is a merge of ledgers with a common hash chain. To audit "what did the fleet do on Tuesday", you concatenate every per-quilt trace for that day and verify the chain.

08Security

A federated engine is a network service. It needs auth, transport security, and per-cell authorization. The cell types that touch the physical world (motors, brakes, money) need extra guarantees: an irreversible flag that makes a cell write-once, and a rollback path the federation can revert across.

09What ships today, what's next

Three things are in the repo and working. Three more are in design. The first three prove the primitive; the second three prove the orchestrator.

If you build on the federation, your work goes here. The primitives are open, the class is open, the Codespace config is open.

Companion reads

• Neural Cells — the deeper theory: every cell is a generalized message-passing node.
• Agent Substrate — the registry / resolver / substrate: how the engine already implements 5 agent-substrate primitives.
• Engines — the cell kinds that wrap external state (paper trading, backtest, simulator).
• Universe Model — a Quilt sheet as a self-contained universe, wrapping any engine (robotics sim, game engine, notebook).

Where to go from here

Three doors, depending on what brought you here.