Notebooks your AI can write. Pipelines it can run.

Six teaching labs. Zero clicks in the UI.

Live demo: every lab below is published read-only on a real Loom instance — open one and scroll. Outputs are the saved results of the run; nothing can be executed or edited without signing in.

Each notebook below was produced end to end by an AI agent talking to Loom's MCP server: it wrote a Python + TypeScript DAG, ran it, ingested the results, queried them with SQL, and wrote the explanation and charts. The numbers are from the real runs.

No matplotlib, no image uploads — charts are the console's own SVG renderer over the data grid behind each cell. Publish the notebook and the outputs ship with it, read-only.

Write a cell. Run it. Pick a chart.

A Python cell returning a DataFrame becomes a data grid with column profiles; the Chart tab opens the controls — nine marks, colour by column, min/avg/max lines, per-series colours — and the spec saves with the notebook.

Pipelines you can actually see.

Every workflow is a card with its task graph, trigger and last run. Open one and click a task for its code, params and the selected run's result; open a run for a Gantt timeline and task rows that expand into tables, charts and logs.

Five products. One process.

The orchestrator, the serverless runtime, the analytics engine, the notebook, and the agent interface usually arrive as five vendors and a Kubernetes cluster. Loom ships them as a single binary with SQLite inside.

Benchmarks

Every number below was measured on a modest shared dev container — release build, real CPython 3.11 / Node 22 workers, real HTTP round-trips. Reproduce them from the repo.

Define in your language. Run on Rust.

from loom_sdk import LoomClient, Flow, task

@task
def extract(params, inputs):
    return {"values": list(range(params["n"]))}

@task(depends_on=[extract], retries=2)
def total(params, inputs):
    return sum(inputs["extract"]["values"])

client = LoomClient("http://localhost:7420")
wf = client.deploy(Flow("sum", params={"n": 100},
                        tasks=[extract, total]))
run = client.trigger(wf["id"], wait=True)
# run["state"] == "completed" · 7 ms later

import loom   # injected into every worker

def handler(params, inputs):
    rows = loom.query("""
      SELECT zone, AVG(value) AS avg_v
      FROM telemetry GROUP BY zone
    """)  # 1.8M rows, ~250ms, in Rust
    loom.ingest("zone-aggregates", rows)
    return {"zones": len(rows)}

# agents drive the same surface over MCP (15 tools):
$ claude mcp add --transport http loom http://localhost:7420/mcp \
    --header "Authorization: Bearer $LOOM_PASSWORD"
> "Build a lab that teaches gradient descent: data,
>  three learning rates, loss curves, explain the math."
# → workflow + run + datasets + a published notebook