Quilt as Agent Substrate

01The problem: today's agents are stateless

Every LLM call today is a one-shot. You send a prompt, you get a response, the context evaporates. There is no memory of what was tried, no provenance for what was produced, no way to compose the output with anyone else's work, no way to roll back to a known-good state, and no way to share a result with the next agent without re-deriving it from scratch.

It is the worst of both worlds: as fragile as a shell pipeline, and as expensive as a kernel boot. We have all the machinery of distributed systems — content addressing, capability negotiation, deterministic replay — and none of it is in the agent stack.

The spec we're implementing is small — five primitives — but it is the same shape as the rest of the internet works (URIs, content addressing, signed manifests, immutable logs). We are not inventing a new model. We are catching up.

02The five primitives

The spec defines five operations. Every other feature — caches, retries, replay, lineage, capability routing — is a composition of these. They are deliberately minimal so that any agent (Claude, GPT, a custom LLM, a shell script) can implement them.

// spec
const a = await resolveArtifact("quilt://demo/dataset:abc123", { run_id: "abc123" });
// → { uri, hash: "sha256:9f86d0...", bytes, kind }

// Quilt — every cell IS a content-addressed artifact
import { Engine } from '@quilt/core';
const engine = await Engine.load();
const cell   = engine.cell(`/demo/dataset:abc123`);  // pinned
await engine.flush();                            // resolve & cache

// spec
const r = validateManifest({ name: "classifier-dag", version: "1.0.0", cells: [...],
  preconditions: ["model_requirements.provider == 'openai'"] });
// → { ok: true }  or  { ok: false, errors: [{ path, msg }] }

// Quilt — ajv for schema, sensor + validate listeners for preconditions
import { validate } from '@quilt/sdk';
const r = validate(manifest);
if (!r.ok) throw new ManifestError(r.errors);

// spec
const uri = await publishArtifact("./dist/classifier-dag.yaml",
  { name: "classifier-dag", version: "1.0.0", author: "team@quilt" });
// → "quilt://team/classifier-dag:a3f1b9c"  (sha256-prefix)

// Quilt — content-addressed storage, signed metadata
import { publish } from '@quilt/sdk';
const uri = await publish({ path: './dist/classifier-dag.yaml', registry: 'quilt://team' });

// spec
const uri = await publishRunTrace({
  manifest_uri: "quilt://team/classifier-dag:a3f1b9c",
  run_id: "01HXY...", started: "2026-01-15T14:22:01Z",
  steps: [{ cell: "load", ok: true, ms: 128 },
          { cell: "embed", ok: true, ms: 2410 }] });

// Quilt — engine.serialize() IS the trace (reactive history)
const trace = engine.serialize();   // { nodes, edges, evals, timing, hashes }
const uri   = await publish({ path: trace, registry: 'quilt://traces' });

// spec
resolveTemplate("quilt://demo/dataset:{{run_id}}", { run_id: "01HXY" });
// → "quilt://demo/dataset:01HXY"

resolveTemplate("quilt://{{org}}/{{name}}:{{tag}}",
  { org: "team", name: "classifier", tag: "v1" });
// → "quilt://team/classifier:v1"

// Quilt — 4 lines, used by resolveArtifact() before lookup
export function resolveTemplate(uri, ctx) {
  return uri.replace(/\{\{(\w+)\}\}/g, (_, k) => {
    if (!(k in ctx)) throw new Error(`missing var: ${k}`);
    return ctx[k]; });
}

03How Quilt already implements this

The mapping is not 1:1 — Quilt has its own vocabulary, and the right way to read this table is "the existing concept is the realization of the spec concept". In every case, the Quilt equivalent was either already the right primitive or was a small, principled generalization of one.

04The insight: reactive > imperative

The most-quoted sentence in this design is also the most undersold. If you internalize it, the rest of the spec falls out for free.

Before: the imperative agent

After: the reactive agent

The shift is small in code, but enormous in what becomes possible:

• Replay becomes free. The engine's reactive history IS the replay log. No separate trace to maintain.
• Lineage becomes free. Each cell knows its parents (declared in derived_from). Provenance walks the graph.
• Rollback becomes free. The engine's state is serializable. engine.load(snapshot) restores any prior state exactly.
• Composition becomes free. An artifact is a URI. A URI can be embedded in another artifact's manifest. No glue code.
• Provenance becomes free. The trace is the engine state. There is no other place to write to.

05The QuiltAgent class

The whole spec, condensed into four methods. An agent is anything that can plan (decompose a goal into artifacts), execute (run them in the substrate), replay (re-run with new inputs), and inspect (look at what actually happened). The class below is a working reference implementation — about 60 lines on top of @quilt/sdk and @quilt/core.

// QuiltAgent — the 4-method interface every agent implements.
// The substrate does the rest.

import { Engine } from '@quilt/core';
import {
  resolveTemplate, resolveArtifact, validateManifest, publishRunTrace, publish,
} from '@quilt/sdk';

export class QuiltAgent {
  constructor(private llm: LLM, private reg = 'quilt://team') {}

  // ① plan — goal in, manifest out. LLM picks artifacts & wires them.
  async plan(goal: string) {
    const catalog = await this.listCatalog();
    const manifest = await this.llm.json({
      system: `You are a planner. Pick artifacts and return a Quilt manifest.`,
      user:   `Goal: ${goal}\nCatalog:\n${catalog}`,
    });
    return { manifest, uris: manifest.cells.map(c => c.ref) };
  }

  // ② execute — validate, resolve, run, trace. Four steps, all substrate.
  async execute(plan, inputs) {
    const v = validateManifest(plan.manifest);
    if (!v.ok) throw new Error(`manifest invalid: ${v.errors}`);
    await Promise.all(plan.uris.map(u => resolveArtifact(resolveTemplate(u, inputs))));
    const engine = await Engine.fromManifest(plan.manifest);
    await engine.flush();
    const trace_uri = await publishRunTrace(engine.serialize());
    return { trace_uri, outputs: engine.outputs() };
  }

  // ③ replay — same plan, different inputs. Reactive engine = free replay.
  async replay(plan, _prior, inputs) { return this.execute(plan, inputs); }

  // ④ inspect — what actually happened? Read the trace, walk the graph.
  async inspect(trace_uri: string) {
    const t = await resolveArtifact(trace_uri);
    return { manifest: t.manifest_uri, ms: t.duration_ms,
      cells: t.steps.map(s => ({ name: s.cell, ms: s.ms, ok: s.ok })),
      tokens: t.tokens, cost: t.tokens * 0.000002 };
  }
}

// Usage:
const agent  = new QuiltAgent(gpt4);
const plan   = await agent.plan("classify these 1000 reviews");
const result = await agent.execute(plan, { dataset: "s3://..." });
const report = await agent.inspect(result.trace_uri);

That is the entire agent surface area. plan → execute → replay → inspect. Everything else — caching, retries, parallelism, rollback, lineage — is provided by the substrate for free, because the engine already implements it.

06Playground — try the primitives

All three examples run in the browser. No server, no API keys. Paste a manifest (JSON), click a button, see the substrate work.

The point of these three boxes is not to be a full implementation — it is to show that the substrate's contract is small enough to demonstrate end-to-end in 50 lines of JS. When you read the SDK, you will find the same shape, just with the I/O filled in.

07Provenance-first UX

One backend, three surfaces. Every surface shows the same thing: where did this result come from? The TUI is for power users, the GUI is for the rest of us, the voice interface is for the visually impaired and the impatient. All three hit the same QuiltAgent instance — there is exactly one source of truth.

08Roadmap

Where we are, where we are going. The first three rows are shipped; the rest are in flight.

If you build on the substrate, your work goes here. The next row could be yours — the registry is open, the schema is open, the SDK is open.

Where to go from here

Three doors, depending on what brought you here.