Subagents

Hand a focused slice of the lifecycle to a child agent and bring the result back. Loom ships three data-science personas — each runs only its own tier-safe verb set, so a delegate can survey, prep, or scrutinize your data, but the expensive and irreversible calls (spend and promotion) always stay with you in the parent.

Why delegate

The main loom agent is a generalist over the whole lifecycle — it profiles, builds features, runs the search, validates, and proposes deploys. For work that is naturally separable — a fresh dataset to survey, a feature pipeline to stand up, a finished run to scrutinize before promotion — you can spin off a child agent scoped to exactly that slice, with a tighter prompt and a narrower toolset. The child does its job in its own context and returns a tight report; the parent keeps the conversation, the gates, and the decisions.

The point isn't just parallelism. Each persona is scoped to a subset of Loom's verbs chosen so it physically cannot reach for an expensive or irreversible action — a scout can profile but never optimize; a builder can engineer features but never launch a search. Delegation narrows what an agent can do, not just what it's asked to do.

A subagent drives the same verbs you can run directly, each through the same approval tiers. Delegation changes who holds the slice of work, never what a verb is allowed to do — the tier gate is enforced beneath every agent, parent or child.

Delegate in plain language

You don't configure a subagent — you ask for one. Name the persona and the slice in plain English and the parent agent spins up the child, hands it the relevant pathspecs, and folds its report back into the conversation:

loom
loom> "use data-scout to survey IngestDataset/123 and recommend a framing"
loom> "have pipeline-builder ingest ./churn and engineer leakage-aware features"
loom> "run a result-reviewer on ValidateFlow/41 before we deploy"

What crosses between parent and child is always a reference — a dataset or run pathspec, a card_path — never bulk data. The child works on the pathspec, sees only the small derived context (schema, preview, metrics) every Loom agent sees, and returns a lineage-grounded summary you can act on.

The three DS personas

Each persona maps to one phase of the lifecycle, and its allowed verbs are picked from a single tier so the delegate stays safe by construction:

Persona	What it does	Allowed verbs (tier-safe)
`data-scout`	Read-only recon — surveys what data exists and profiles its shape, quality, leakage risk, and target balance, then proposes a problem framing and the metric to make the spec.	doctor datasets eda viz
`pipeline-builder`	Gets data model-ready — ingests sources and engineers leakage-aware features into a new data object, then proposes the optimize step (the exact verb, metric, and budget) for you to run.	datasets eda features ingest
`result-reviewer`	Adversarial GO / NO-GO on a run — scrutinizes the headline metric, validation rigor, leakage, calibration, and overfitting, and defaults to skepticism.	datasets report viz validate

The tier pills mirror the approval matrix: read-only verbs never prompt; workspace-write verbs write only into the Metaflow workspace, never the source. No persona's verb list contains an expensive / irreversible verb at all.

How a hand-off chains

The three personas are deliberately a relay for the lifecycle's safe half: scout to understand, builder to prepare, reviewer to scrutinize — each one ending at the gate the parent owns.

data-scout confirms the datastore, lists datasets, profiles the candidate with eda, spot-checks distributions with viz, and returns the pathspec(s), schema highlights, leakage risks, and a recommended framing.
pipeline-builder takes that framing, ingests the source, reads the prior eda result's summary.leakage_flags and drops the flagged columns (passing the eda run via --from), engineers a new feature data object, and hands back the feature pathspec plus the exact next command — the optimize to run, the metric, the budget.
result-reviewer pulls the run's report, asserts the validate VERDICT (running a fresh validation if none is referenced), sanity-checks the metric against a trivial baseline, probes for leakage and calibration problems, and returns an explicit GO / NO-GO with the conditions that would flip it.

Tier-safe by construction

This is the load-bearing guarantee. Notice what is absent from every persona's verb list: run/optimize (the expensive AIDE search), train (the GPU model-builder), deploy (promotion to the registry), and collab --send (off-box sharing). A subagent is wired with a fixed toolset, so it cannot fire any of them — there is nothing for it to call.

Tier	Example verbs	Available to a subagent?
read-only	`doctor`, `datasets`, `eda`, `viz`, `report`	Yes — never prompts.
workspace-write	`ingest`, `features`, `validate`	Yes — writes only into Metaflow, never the source data.
expensive / irreversible	`run`/`optimize`, `train`, `deploy`, `collab --send`	No — not in any persona's toolset; stays with you.

⚠

A delegate never spends money and never promotes a model. The expensive / irreversible verbs are reached only by you, in the parent, via the interactive gate — the model proposes, only you can fire. A pipeline-builder will tell you the exact optimize to run; a result-reviewer will say GO; neither runs the next gated step itself.

The personas also keep the same discipline the parent does: data stays in Metaflow (they thread pathspecs, never raw rows), they gate-assert on each verb's structured VERDICT before composing, and a failed or sub-threshold step stops them — they surface it rather than work around it.

Generic agents for code work

Alongside the DS personas, the delegation layer ships a set of generic agents — a reviewer, a scout, and an oracle (for a second opinion) — for ordinary code and repository work: reading a library's source, reviewing a diff, investigating an error. They're the right tool when the slice is about code rather than a dataset or a run.

Reach for a DS persona when the slice touches your data or a run — surveying a dataset, building features, reviewing a result — because those carry the tier-safe Loom verbs and the lineage discipline. Reach for a generic agent for code-shaped work that doesn't run a verb. When in doubt, the parent picks the right one from your plain-language ask.

Either way, a good habit is a reviewer pass before any promotion: have a result-reviewer return its GO / NO-GO on a run, read it, and only then — in the parent, at the gate — decide whether to deploy.