Reactive notebook

A reactive notebook is a document where cells re-run automatically when their dependencies change. Change an input, and every downstream chart, table, and model updates without manual clicks. The idea is simple, but the execution is hard: you need a clean dependency graph, fast incremental execution, and a runtime that stays responsive while data grows.

Why reactive notebooks matter

Traditional notebooks are linear. You run cells top to bottom, and if you edit a cell in the middle, you have to remember to re-run everything below it. That manual bookkeeping is where silent bugs hide: stale charts, mismatched parameters, notebooks that reproduce on one machine and fail on another.

Reactive notebooks remove that burden. They treat the notebook as a directed acyclic graph. Each cell declares its inputs and outputs. When an input changes, the runtime walks the graph and re-executes only the affected cells. The result is faster iteration, fewer mistakes, and documents that stay trustworthy as they evolve.

SpurLab's take on reactive notebooks

SpurLab is an Agent Notebook for personal data analysis and exploration. The notebook is not a separate silo; it is a first-class surface that agents can read, write, and refactor.

Because SpurLab is local-first, the notebook runs on your machine. Your data never leaves your disk unless you choose to connect an external API. The reactive engine is DAG-aware by default, so dependencies between cells, queries, and connected data sources are tracked automatically. You can import a CSV, point a DuckDB cell at it, and watch every chart and downstream SQL cell update in place.

When you need to go further, you can delegate to an ACP agent. Say you want to turn a static chart into an interactive parametric view. You mention the worker, the agent opens the notebook in its own context, edits the relevant cells, and returns a diff you can review before accepting. The reactive engine re-runs the changed cells and their dependents, so you see the impact immediately.

Use cases

Reactive notebooks shine whenever data, code, and narrative live together. Data scientists use them to keep exploratory analyses consistent. Product managers use them to model forecasts that update when assumptions change. Engineers use them to monitor live API data and trigger alerts when metrics cross thresholds. In SpurLab, the same notebook can be a personal dashboard, an agent canvas, and a shared report, depending on the mode you are in.

FAQ

Do I need to know the agent protocol to use a reactive notebook?

No. SpurLab's reactive notebook works like a normal notebook. Agents are optional: you invoke them with the @worker mention when you want help, and you review every change before it lands.

Can I import existing Jupyter notebooks?

SpurLab can read standard notebook formats and convert them into reactive cells. The conversion preserves outputs and markdown, then rebuilds the dependency graph from code analysis.

What data sources connect to a reactive notebook?

Local files, DuckDB, connected APIs, and any SQL database you add to your workspace. Each connection becomes a reactive node in the notebook graph.

Is the notebook state saved locally?

Yes. Everything is stored in your local workspace. You can export the notebook as a static file or publish it through a connected app when you are ready.