Compute Push Distribution

WASMComputeDistributed

Beta Works · surface still evolving · multi-node; surface still evolving

What it is

Compute Push is the distributed-execution mode for compute cells. When you invoke a cell against a table whose data is spread across many nodes, the coordinator does not fetch rows. Instead it sends the cell’s compact bytecode (typically tens of kilobytes) to each node holding relevant data. Each node runs the cell locally against its own data, produces a small summary with its partial result, and ships only that summary back. The coordinator merges the summaries into the final answer.

Because bytecode is content-addressed by hash, nodes cache it transparently — the bytes only travel on first invocation, and subsequent calls send just the cell’s id and version. The query optimizer treats estimated network bytes saved as a first-class signal, so push is chosen automatically when it wins and skipped when it doesn’t.

Why it matters

For a global aggregation across, say, 100 nodes each holding 50 GB of rows, the traditional data-pull approach moves terabytes across the network just to compute one number. Compute Push moves about a megabyte.

Orders-of-magnitude less network traffic — a global aggregation that would pull terabytes instead ships a handful of tiny summaries.
Wall-clock drops from seconds to milliseconds for network-bound queries.
No separate compute cluster — no external query engine to operate alongside storage.
Your language, your logic — push arbitrary cell code, not just SQL aggregations.
Smart routing — the optimizer picks push or pull per query, based on expected network savings.

flowchart LR
  classDef coord fill:#1f2640,stroke:#7c5cff,color:#e8eaf0
  classDef node  fill:#1f2640,stroke:#00d4ff,color:#e8eaf0
  classDef sum   fill:#1f2640,stroke:#4ade80,color:#4ade80

  C[Coordinator]:::coord
  C -->|cell + 20 KB wasm| P1[Node 1<br/>local exec]:::node
  C -->|cell id only| P2[Node 2<br/>cached wasm]:::node
  C -->|cell id only| P3[Node 100<br/>cached wasm]:::node
  P1 -.->|1 KB summary| C
  P2 -.->|1 KB summary| C
  P3 -.->|1 KB summary| C

How you use it

Push is mostly invisible — you invoke a cell, and the optimizer decides whether to push or pull. You can also hint or force a push for queries you know are network-bound.

-- Deploy an aggregator cell. The coordinator will fan it out.
DEPLOY CELL regional_revenue
  VERSION 1
  FROM '/build/regional_revenue.wasm'
  ON orders
  RETURNS TABLE(region TEXT, total DECIMAL(38,2));

-- Invoke against the cluster. The optimizer chooses push automatically
-- when it can ship bytecode cheaper than rows.
SELECT region, SUM(total) AS revenue
FROM CELL(regional_revenue, since => DATE('2026-01-01'))
GROUP BY region
ORDER BY revenue DESC;

-- Force push for a known network-bound query:
SELECT * FROM CELL(regional_revenue, since => DATE('2026-01-01'))
  WITH (execution = 'push');

The cell is sent once and cached on every node by content hash. Run the same query again and zero bytecode bytes cross the wire.

Key concepts

Concept	Meaning
Summary	A compact result structure returned from each node to the coordinator.
Bytecode caching	Cells are content-addressed by hash; a node downloads bytecode only the first time it sees it.
Merge cell	A small cell that combines per-node summaries into the final result on the coordinator.
Fan-out	The coordinator step that sends an invocation to every node holding relevant data.

Notes & caveats

WASM Compute Cells →

The execution model for the cells that travel via push.

Logic Registry & Deploy →

How cells get their content hashes and become pushable artifacts.

Logic Loom →

Multi-cell flows that can themselves run across the cluster.

Query Data →

The cost model that decides push vs pull on every query.