Quilt as a Universe Model

00The SuperInstance

The name fits. A Quilt sheet is a SuperInstance — a self-contained universe that:

• Has state (the cell values)
• Has laws (the formulas, programs, listeners)
• Has inhabitants (the cells — anything from a number to a robot)
• Has physics (the propagation rules — when a cell updates, who else updates)
• Has time (tick-by-tick simulation, or event-driven reactivity)
• Can be observed (the values, the graph, the trajectory)
• Can be forked (clone the sheet, change one thing, compare)
• Can be evolved (@quilt/evolve — RLAIF as a first-class operation)

Each sheet is one universe. You can run thousands in parallel. You can compose them. You can have universes that contain universes. The cell model is the substrate; everything is a cell.

01Cells as engine wrappers

The key architectural move: a cell can wrap any external system that has state. The cell exposes the engine's state as Quilt cells, and translates between Quilt reactivity and the engine's API.

The engine cell pattern

For each engine, a Quilt adapter exposes the engine's state as cells. The adapter is a thin shim that translates between Quilt reactivity and the engine's API.

# A paper trading cell
- id: trading.btc_price
  kind: engine
  engine: coingecko
  symbol: BTC
  # Wraps the CoinGecko API; the cell's value is the current price

# A backtest cell
- id: backtest.equity
  kind: engine
  engine: backtest
  strategy: moving_average_crossover
  data: trading.btc_price
  # Wraps a backtester; the cell's value is the equity curve

# A Minecraft cell
- id: minecraft.player_pos
  kind: engine
  engine: minecraft
  player: Steve
  # Wraps a Minecraft server; the cell's value is the player's coords

# A Jupyter cell
- id: jupyter.last_output
  kind: engine
  engine: jupyter
  kernel: python3
  # Wraps a Jupyter kernel; the cell's value is the last execution result

Each engine cell is reactive. When the wrapped engine's state changes, the cell updates. When a Quilt cell changes that the engine cares about, the engine is notified.

02The engines

These are the engines that can be wrapped as Quilt cells. Each is a real system with state and an API. The cell model makes them all addressable from one substrate.

03Architecture: the engine adapter

An engine adapter is a small module that exposes an external system as a Quilt cell. The adapter handles:

• Connection — establish a link to the engine (TCP, HTTP, WebSocket, etc.)
• Subscription — listen for state changes in the engine
• Translation — convert engine events into Quilt cell updates
• Command — convert Quilt cell changes into engine commands
• Schema — declare which cells the engine exposes

// An engine adapter in TypeScript
abstract class EngineAdapter {
  abstract name: string;
  abstract schema: CellSchema[];  // which cells this engine exposes

  abstract async connect(): Promise<void>;
  abstract async disconnect(): void;

  // Engine → Quilt: when engine state changes, update the cell
  abstract on(cellId: string, handler: (value: any) => void): void;

  // Quilt → Engine: when a Quilt cell changes, send to engine
  abstract async send(cellId: string, value: any): Promise<void>;
}

// A concrete adapter for paper trading
class CoinGeckoAdapter extends EngineAdapter {
  name = "coingecko";
  schema = [
    { id: "trading.btc_price", type: "number", source: "https://api.coingecko.com/..." },
  ];

  async connect() {
    // poll CoinGecko every 30s
    setInterval(async () => {
      const price = await fetch("...").then(r => r.json());
      this.emit("trading.btc_price", price);
    }, 30000);
  }

  async send(cellId: string, value: any) {
    // write to our local paper trading ledger
  }
}

04Backtesting alternative universes

The killer app: fork the universe. You have a strategy. You want to know how it would have done with different decisions. In Quilt, this is trivial:

# The base universe — the strategy you ran
- id: universe.base.strategy
  kind: engine
  engine: "backtest"
  rules: "buy when MA(20) > MA(50), sell otherwise"

# An alternative universe — the same strategy, different timing
- id: universe.alt1.strategy
  kind: engine
  engine: "backtest"
  rules: "buy when MA(20) > MA(50) + RSI < 70, sell otherwise"

# Another alternative — different exit
- id: universe.alt2.strategy
  kind: engine
  engine: "backtest"
  rules: "buy when MA(20) > MA(50), sell on +5% or -2%"

# Compare the three equity curves
- id: multiverse.equity_chart
  kind: formula
  value: "[universe.base.equity, universe.alt1.equity, universe.alt2.equity]"

Each "universe" is a Quilt cell that wraps a backtest engine. The "multiverse" is a Quilt cell that aggregates them. The user sees three equity curves, side-by-side, on one sheet. The substrate is the same — every universe is just cells.

05Engines as cells: the full table

06The implications

1. Any simulator becomes a Quilt cell

If it has state and an API, it's a cell. The Quilt cell model is the universal interface to any simulator. You don't have to choose between Minecraft and Isaac and Jupyter — they coexist in the same sheet.

2. Simulators compose

An Isaac cell (robot) and a Minecraft cell (world) and a Jupyter cell (code) can be in the same sheet. The robot acts in the world, the world reacts, the code runs the analysis. One sheet, three engines, one reactive system.

3. The multiverse is a graph

Forking a universe is just cloning a sub-graph. Comparing universes is just having two sub-graphs side-by-side. The "multiverse" is a Quilt sheet of Quilt sheets.

4. AI is just another engine

An LLM cell is an engine wrapper — it wraps the OpenAI / z.ai / Kimi API. The same pattern as Isaac or Minecraft: external state exposed as cells, reactive updates, cell changes trigger commands. AI is a simulator too — one that simulates language.

5. The world model is a cell

Cosmos is a world foundation model — a neural network that generates physically-grounded video. Wrap it as a cell: cosmos.predicted_next_frame. The cell's value is the next frame. The cell updates when prompted. Other cells can observe it. This is the world model as a first-class Quilt citizen.

07From spreadsheet to multiverse

The cell model started as a spreadsheet. It became reactive. It became cellular. It became a runtime. It absorbed LLMs. It became self-improving. And now: it absorbs any simulator.

The trajectory is:

• v0.1 — spreadsheet with named, reactive cells
• v0.2 — production runtime, 8 cell kinds, 9 repos
• v0.3 — AI cells, self-improvement loops, Cloudflare, mesh, ESP32
• v1.0 — universe model: any engine wrapped as a cell, multiverse sim, embodied AI in spreadsheets

The cell model is the substrate. The SuperInstance is the artifact. The multiverse is the goal.

Try it