The workbench
The lifecycle verbs are how Loom does data science. The workbench is everything around them — web lookup, document parsing, inline charts, write-ups, diagrams, session recall, and durable memory — so a data scientist never has to drop out of Loom into a generic coding agent mid-analysis. These tools complement the verbs; they don't replace them, and your bulk data never enters the chat.
Why a workbench
A real analysis isn't only flows and metrics. You stop to look up a library's API, read a dataset's data dictionary, sketch the pipeline you're about to build, glance at a distribution, or recall what you decided in last week's run. Without those at hand you'd alt-tab into a separate coding tool — and lose the lifecycle context that makes Loom safe (the tiers, the lineage, the gates). So Loom ships a general DS toolkit built in: the agent can do all of the above without leaving the conversation.
The dividing line is durability. The workbench is for looking, thinking, and exploring.
The moment something becomes a durable artifact or dataset, it flows through a
verb — viz/report for the shareable @card,
ingest for data. The workbench never produces the versioned deliverable; a verb does.
The toolkit
Beyond the verbs, the agent can reach for each of these in plain English — Loom picks the tool
the same way it picks a verb. They all ship preinstalled; loom update
keeps them current.
| Capability | Use it to… | Backed by |
|---|---|---|
| Web search & URL fetch | look up a library API, an error message, a dataset's docs, or a method; fetch a page or clone a GitHub repo | pi-web-access |
| PDF extraction | pull the text/tables out of a paper or vendor spec you found on the web | pi-web-access |
| Parse documents (local) | read a data dictionary, spec, or paper PDF sitting on disk — no upload, no round-trip | pi-docparser |
| Inline charts | throw a quick Vega-Lite distribution or correlation on screen while exploring | @walterra/pi-charts |
| Render write-ups | preview a markdown + LaTeX note (an explanation, a derivation, a hand-off) | pi-markdown-preview |
| Diagrams | sketch a pipeline or a DAG to reason about structure before you build it | pi-mermaid |
| Search past sessions | recall a prior run, a parameter, or a decision from an earlier conversation | pi-session-search |
| Persistent memory | carry your stable preferences and corrections across sessions | pi-memory |
Web research & documents
The agent can search the web, fetch URLs, clone a GitHub repo, and extract PDFs — then act on what it learns. It can also parse documents locally: hand it a data dictionary, a column spec, or a paper PDF on disk and it reads it in place to inform the framing. That covers the moments where you'd otherwise reach for a browser or a second tool: "what's the signature of this estimator?", "what does this error mean?", "what columns does this dataset's docs describe?".
# plain English — the agent searches, reads, and folds the answer into its plan
loom "read ./docs/data_dictionary.pdf and tell me which columns are post-outcome"
loom "look up the scoring convention for this Kaggle metric and pin our --metric to match"Research is for understanding, not for moving data. If fetched or parsed material is
actually data to model, it comes in through loom ingest as a Metaflow
data object — never streamed through chat. Don't paste bulk fetched content into context; reference
it. Web search may need an API key — a missing one surfaces an actionable line, not a guess.
Inline charts, write-ups & diagrams
While you explore, the agent can put a quick Vega-Lite chart on screen — a distribution, a correlation — without standing up a flow. It can render a write-up (markdown + LaTeX) to explain a derivation or draft a hand-off, and draw a diagram (Mermaid) to sketch a pipeline or DAG before you build it. These are thinking aids: fast, throwaway, in-conversation.
That makes the relationship to viz sharp. An inline chart is a glance; the durable,
lineage-grounded plot is a read-only viz run that emits an
@card you can share and version.
| Inline chart (workbench) | viz verb |
|
|---|---|---|
| Purpose | a quick look while exploring | the shareable, versioned deliverable |
| Output | an ephemeral Vega-Lite render in the terminal | a Metaflow run + an @card image, with lineage |
| Input | small derived numbers already in context | a --dataset pathspec or a --run |
| When | "is this column skewed?" | "attach the distribution to the report" |
Inline charts and the markdown preview render best in an image-capable macOS terminal. In a plain terminal the agent still produces the chart spec and the rendered text; the visual just won't inline.
Session search & persistent memory
Two distinct kinds of recall, often confused — keep them apart.
Search past sessions
Session search looks back across your earlier conversations to recall a prior run, a parameter you chose, or a decision you made — "what threshold did we settle on for the fraud model last week?". It's retrieval over history, on demand.
Persistent memory
Persistent memory carries your stable preferences and corrections forward automatically, so you don't restate them every session — for example "the metric is ROC-AUC", "data lives in GCS", or "always validate on a sealed holdout".
loom "remember that we always validate on a sealed holdout, never plain CV"
loom "what did we decide about the leakage columns in the churn dataset?"This is agent-UX memory — your preferences for how the agent works with you. It is separate from Loom's learnings/telemetry moat, which captures verb outcomes for distillation. Don't conflate the two, and never store bulk data or secrets in memory.
Discipline: the workbench complements the verbs
The workbench is deliberately scoped so it can't quietly become a back door around the lifecycle's safety. Three rules hold everywhere:
- Durable things go through a verb. A plot you keep is a
viz@card; a write-up that matters is areport; data isingest. The workbench produces nothing versioned on its own. - Bulk data never enters the chat. Datasets stay as Metaflow data objects in your perimeter; the agent sees only small derived context (schema, preview, metrics). Workbench tools obey the same prompt-hygiene line as everything else.
- Data crosses in at exactly one boundary. If a fetched paper, a parsed spec, or
anything else turns out to be data you want to model, it enters via
loom ingest— the single door — and you work the pathspec, never the raw content.
Read the related pieces next: Data access (MCP) for how outside
stores are located and fetched before ingest, and Lifecycle &
verbs for the durable side the workbench feeds into.