A data workbench where the graph is the interface

exuvia turns an analysis into a graph of plain Python and SQL files. Schedule any node on its own, keep every output it produces, and work with an AI agent that reads, writes, runs and debugs the graph alongside you.

Get started
pip install exuvia
Woodcut print of a lobster seen from above, claws forward.
exuvia, noun. The shell a lobster leaves behind when it molts. Every run of a node leaves one too: an output you can go back to.
markets demo

Loading the graph.

A sketch of the example project that ships with exuvia, running in your browser. Select a node to save an edit to its file, then run what went stale. A solid bar is fresh, a hatched bar is stale.

From a list of cells to a graph of files

A lobster grows by leaving its old shell behind. Data tools have grown the same way: each generation kept what worked and shed what hurt. Here is one five-step analysis in all three.

  1. A Jupyter notebook: five cells in one file, with execution counters out of order and their state held in a separate kernel. analysis.ipynb[7]universe = …[2]prices = …[3]returns = …[9]rolling_vol = …[4]summary = …kernel

    Jupyter

    Code, output and prose in one document.

    You can try an idea in seconds. But cells run in whatever order you run them, and the kernel remembers every result, so the file on disk and the state in memory drift apart.

  2. A marimo notebook: the same five cells in one Python file, joined by arrows that show which cell depends on which. analysis.pyuniverse = …prices = …returns = …rolling_vol = …summary = …

    marimo

    The notebook becomes a reactive graph.

    marimo reads which cells depend on which, re-runs the dependents when something changes, and saves the notebook as a plain Python file. The hidden state is gone, and the notebook fits in git.

  3. An exuvia project: five node files laid out as a graph, each keeping its earlier outputs, one with its own schedule, and an agent working on one of them. five files in nodes/universe.pyprices.pyreturns.pyrolling_vol.pysummary.sqlagent

    exuvia

    The graph becomes the interface.

    Each node is its own file with its own schedule, and every run leaves a stored output behind. An AI agent reads, writes, runs and debugs nodes on the same canvas you work on.

A node is a function in a file

There is no project format to learn and no graph to declare. You write ordinary Python and SQL, and exuvia reads the rest from it.

nodes/rolling_vol.py
"""20-day annualized realized volatility per ticker."""
import exuvia

@exuvia.node(
    schedule="0 18 * * 1-5",
    cascade=True,
)
def rolling_vol(returns):
    out = returns.sort_values("date").copy()
    out["vol_20d"] = out.groupby("ticker")["ret"].transform(
        lambda s: s.rolling(20).std() * 252**0.5
    )
    return out.dropna()
nodes/sector_summary.sql
-- Latest vol by sector.
-- schedule: */30 9-16 * * 1-5
select u.sector, avg(v.vol_20d) as avg_vol
from universe u join rolling_vol v using (ticker)
group by 1
  1. The file is the node

    One file in nodes/, named after the node. It diffs, reviews and merges like the rest of your code.

  2. A schedule of its own

    A cron on this node, not on the whole graph. You can pause it from the UI without touching the file.

  3. Cascade, until nothing changes

    When an upstream output changes, this node re-runs. When its own output comes out identical, the cascade stops here.

  4. A parameter is an edge

    returns is the node upstream. exuvia reads the graph from the source without running it, so a broken node still appears, with its error.

  5. The return value is kept

    It is stored as Parquet under a hash of its content. Same code and same inputs is a cache hit, and earlier outputs stay readable.

  6. In SQL, upstream nodes are tables

    A SQL node runs in DuckDB and names its upstream nodes in from and join. Schedules and charts go in header comments.

One command opens the workbench

exuvia serve starts the UI, the API and the scheduler on your machine. These are screenshots of it running the example project.

The exuvia workbench. On the left a graph of five nodes, all fresh. On the right the selected node, rolling_vol, with its chart of 20-day volatility for eight tickers.
The canvas is the project. Select a node to see its code, its data, its chart and every run it has had.

The interface is front-end code, not Python

In a notebook the UI is assembled from Python: widget calls, or HTML and JavaScript held in strings. In exuvia, Python and SQL compute, and the interface is a view: TypeScript, React and CSS in files of their own. This is the view in the screenshot above.

views/vol_board/view.json
{
  "title": "Volatility board",
  "runtime": "react",
  "entry": "App.tsx",
  "reads": ["sector_summary", "rolling_vol", "universe"]
}
views/vol_board/App.tsx (shortened)
import { useState } from "react";
import { rows, useQuery, useTable } from "exuvia";
import { VolChart } from "./VolChart";
import "./styles.css";

export default function App() {
  const sectors = useTable("sector_summary");
  const latest = useQuery(`
    select v.ticker, u.sector, v.vol_20d
    from rolling_vol v join universe u using (ticker)
    qualify row_number() over (
      partition by v.ticker order by v.date desc) = 1`);
  const [picked, setPicked] = useState<string | null>(null);
  const bySector = rows<Sector>(sectors.data);
  const sector = picked ?? bySector[0]?.sector ?? null;
  // …
  return (
    <main className="board">
      {bySector.map((s) => (
        <tr key={s.sector} onClick={() => setPicked(s.sector)}>
          {/* … */}
        </tr>
      ))}
      {sector && <VolChart sector={sector} />}
    </main>
  );
}
  1. A folder of front-end files

    A view lives in views/, beside nodes/: a manifest, an entry component, and whatever else it needs. Every file is versioned like a node file, and diffs like one.

  2. The reads list is all it can see

    The view gets the outputs of the nodes it names and nothing else. The same list draws its edges on the graph and tells you when it is ready, stale, or missing an output.

  3. Data arrives typed

    useTable returns a node's output as an Arrow table, with real column types. Nothing is rendered to HTML in Python and passed along as text.

  4. SQL over what it reads

    useQuery runs DuckDB SQL over the nodes the view reads. When a run replaces one of those outputs, the hooks reload by themselves. A view never starts a run.

  5. Components, state and CSS as usual

    Split the view into files, keep state in React, style it with a stylesheet. React, Vega-Lite and Arrow ship with exuvia, and the files compile in the browser, so there is no build step and no install.

  6. Sandboxed by default

    A view runs in a frame with no network, no cookies and no API token. Its only way to data is asking the page, which answers for the nodes in reads.

Ask the agent for one. It writes views with the same kind of tools it has for nodes, and what it writes runs in the same sandbox.

Not a React app? Outside the workbench the same outputs are plain HTTP: Arrow streams and Parquet files, for an app in any language.

An agent with tools over the graph

The agent is not a chat box beside your work. It has the same handles you do: it lists and reads nodes, writes them, runs them, and queries their outputs with DuckDB.

  • It looks at the real column names before it writes a line.
  • It runs what it writes, and reads the traceback when a run fails.
  • Every tool call shows in the conversation, and the nodes it touches flash on the canvas.
  • What it leaves behind are ordinary files, with every earlier version kept and restorable.

Bring your own model

ModelSet
ClaudeANTHROPIC_API_KEY
Any model on OpenRouterOPENROUTER_API_KEY
A local or self-hosted modelEXUVIA_BASE_URL and EXUVIA_MODEL

The model needs to support function calling. Providers, project notes and sessions

An agent conversation. The request: add a drawdown node per ticker with a chart. Its steps: looked at the graph, read prices, wrote drawdown in 20 lines, ran drawdown for 2,080 rows. Then a summary of the new node.
A real turn on the example project, with DeepSeek through OpenRouter.

Between a notebook and an orchestrator

Notebooks are quick to work in and awkward to run every day. Orchestrators run every day and are slow to work in. exuvia keeps the notebook's loop and gives each node the orchestrator's schedule.

NotebooksOrchestratorsexuvia
Unit of workA cellA task or an assetA node file
DependenciesHidden state, or reactive cellsDeclared in codeFunction parameters and SQL table names
SchedulingNoneThe whole DAG, or asset jobsPer node, by cron, cascading downstream
Iteration loopFastSlow: deploy firstFast: edit, run, see the data
Custom UIWidgets and HTML built from PythonNone: you build a separate appViews: TypeScript, React and CSS in files of their own
On diskNotebook JSONA Python packageOne plain file per node

When the project outgrows your laptop

Run parameters and replays
Run the graph for a date and keep one output per date. Replay a range, and query every run of a node as one table.
Many projects, one process
Serve every project under one directory from a single process.
Remote executors
Keep the control plane on your laptop and run nodes in a container on Cloud Run, Fly, Kubernetes or Cloudflare.
Your storage
Outputs go to disk or any S3-compatible bucket. Run history goes to SQLite or Postgres.
Headless runs
exuvia run brings a project up to date and exits non-zero when a node fails, so it fits CI and cron.
An HTTP API
Everything the UI does is a plain HTTP call, with Arrow streams and Parquet files when you want the data itself.

Running in four steps

From an empty folder to a graph with an agent on it.

  1. Install it

    exuvia is one Python package with the web UI inside. It needs Python 3.11 or newer.

    pip install exuvia
  2. Create a project and open it

    A project is a folder. This makes one with a first node, then serves the workbench at 127.0.0.1:7420.

    exuvia init my-research
    exuvia serve my-research
  3. Add a node

    Save a file in nodes/. The parameter name is the dependency. The canvas picks the file up by itself.

    nodes/squares.py
    import exuvia
    
    
    @exuvia.node()
    def squares(hello):
        return hello[hello["y"] > 1]
  4. Turn on the agent

    Put a model key in the project's .env and restart. Then ask for a node, a fix or a chart.

    echo "ANTHROPIC_API_KEY=sk-ant-..." >> my-research/.env