In The Geometry of Alpha I wrote that once a validation process is frozen into a discipline, AI agents can enumerate candidates, run screens, write verdicts, and maintain the ledger around the clock — and that this "deserves a piece of its own." In One Person + AI I described the organizational shape that makes that claim intelligible: discipline before automation, three non-transferable human decisions, throughput decoupled from headcount.
This piece is the missing middle. Not "we use AI for research" as a slogan. How agents actually execute a research pipeline — the contracts, the walk-through, the ledger, the fail-closed paths, and the places where a human is still the only legal executor.
The setting is Dnalyaw: a vertically integrated quant system where research and execution share one pipeline. The principles generalize to any research process that can be made explicit. The constraint is real: if a step still needs the executor's intent to decide correctness, it is not ready for agents — it is ready for redesign.
The Wrong Mental Model
The wrong picture looks like this: a researcher types a prompt — "find me a new alpha" — and a language model returns a recipe. That is not a research pipeline. That is a chat.
The right picture looks like this: a pre-registered machine takes a candidate hypothesis, walks it through frozen gates with frozen thresholds, emits a structured verdict, and appends that verdict to an append-only ledger. Agents are the night-shift operators of that machine. They do not invent the gates. They do not negotiate the thresholds. They do not "use judgment" when the numbers look awkward. Their job is to run a contract, not to win an argument.
This is the same test from the org-shape piece, restated as an engineering rule: can this step's correctness be verified without asking the executor's intent? If yes, agents may own the step. If no, either keep it human or redesign until the answer is yes. Handing a discretionary step to an agent does not remove discretion — it scales discretion and dresses it as objectivity.
Contracts, Not Vibes
An agent-executable research step is a contract with four surfaces:
- Inputs — what the step is allowed to read (point-in-time data, candidate definition, gate config frozen before the run).
- Tools — which capabilities it may call (SQL against a research replica, backtest runner, factor library, cost model, portfolio history). Permissions are least-privilege; a screening agent does not get live order-entry.
- Outputs — a structured artifact: pass/fail per gate, residual stats, cost assumptions used, data window hashes, and a one-line human-readable summary. Free prose is optional decoration; the machine-readable fields are the product.
- Failure modes — timeout, missing data, schema drift, non-determinism, tool error. Each maps to a terminal state the orchestrator understands: retry, skip-with-ledger, or wake-human. Silent success on partial data is forbidden.
If any of those four is missing, you do not have an agent step. You have a demo that will lie to you under load.
Orchestration matters here the way a factory floor layout matters. In our stack, multi-step research jobs are delegated through Shannon (and the local runtime patterns described in the harness piece): tool dispatch, budgets, permissions, and observable workflows. The point is not the brand names. The point is that the research pipeline is a workflow with an audit trail, not a long chat that happened to call tools.
One Candidate, End to End
Walk a single candidate through the line. Call it C — a proposed short-horizon residual feature, already expressed as code and a data surface, not as a story.
Step 0 — Intake. An agent materializes C into a job: versioned definition, required data surfaces, and the gate-config hash that will be used for this run. If the config hash is not frozen (still a draft), the job refuses to start. No "just this once" path.
Step 1 — Factor strip. Tools pull the point-in-time panel, strip known factor exposures, and write the residual series. Output: residual IR / significance / exposure table. Gate rule (frozen): residual must clear a pre-registered bar. Fail → ledger NO GO / factor-strip, stop.
Step 2 — Out-of-sample. The evaluation windows were registered before C was seen. The agent runs only those windows. It does not re-pick a prettier split. Fail → ledger NO GO / oos, stop.
Step 3 — Net of cost. The cost model is the live-calibrated one described in the backtest-to-live gap piece — not a round-trip commission fantasy. Gross residual that dies after fees is a fail. Fail → ledger NO GO / cost, stop.
Step 4 — Tail correlation. Against the existing book's worst days, not against full-sample coziness. Fail → ledger NO GO / tail, stop.
Step 5 — Package for human admission. Only if all four gates pass does C enter the human queue: a short packet (what it is, residual evidence, cost assumptions, tail test, what it is orthogonal to) plus links to full artifacts. Passing the factory is not admission. Admission answers a question statistics cannot: is the reason this worked still going to be true going forward — crowding, data sustainability, structural fit to the book.
Most candidates die at step 1 or 2. That is health. A night that produces zero human packets and thirty honest NO GOs is a successful night.
The Ledger Is a First-Class Product
The factory's most valuable output is often not a signal. It is the ledger of what failed, why, under which config hash, on which data vintage.
Without that ledger, overnight agent throughput is a liability: you re-mine the same dead direction every week, burn compute, and slowly convince yourself that volume equals progress. With the ledger, rejection compounds. Agents check "has this family already been falsified under equivalent assumptions?" before spending a full gate run. Humans read clusters of NO GOs as research strategy — which surface is exhausted, which gate is doing the killing, where the feature menu is thin.
Operational rules that make the ledger real:
- Append-only. No editing a past NO GO into a soft maybe. Corrections are new rows that supersede, with reason codes.
- Config-addressable. A verdict is meaningless without the gate config and data vintage it used. Reproducibility is a join key, not a hope.
- Reason codes, not novels. Machines cluster on codes; humans expand prose only when an anomaly needs a story.
- Re-mine policy. Re-running a falsified direction requires an explicit new angle or new data — not a new prompt mood.
This is the same immune-system idea from Geometry of Alpha, made concrete enough for agents to operate.
Division of Labor, Restated as Paths
Map the org-shape decisions onto the pipeline:
| Path | Owner | Why |
|---|---|---|
| Enumerate candidates from allowed surfaces | Agents | High volume, checklistable |
| Run four gates + write structured verdict | Agents | No discretion if frozen |
| Maintain ledger / block re-mines | Agents + deterministic services | Integrity is mechanical |
| Daily research ops (data QA, drift flags, job health) | Agents | Alert-on-anomaly |
| Admit to live book | Human | Forward reason, crowding, fiduciary fit |
| Risk posture / kill parameters | Human | Utility, not statistics — see sizing vs safety |
| Open a new research surface or kill a line | Human | Months-long feedback, no clean training signal |
| Place or risk-check live orders | Never the research agent | Separate process, absolute veto |
The research agent that can also trade is a category error. Even a "helpfully" over-privileged tool surface will eventually be used. Least privilege is not paranoia; it is how you keep the factory from becoming a shadow execution path.
Fail Closed
Agent pipelines fail in boring ways that destroy trust if you fail open:
Missing data. If a required series is late or incomplete, the gate does not run on a subset and whisper a pass. It emits blocked / data and stops. A partial panel is not "mostly fine" — it is a different experiment.
Config drift. If the running gate hash does not match the frozen registry, refuse. An agent that "updates thresholds to get a cleaner screen" is reintroducing researcher bias at machine speed.
Non-determinism. Where possible, pin seeds and artifact hashes so a re-run is comparable. Where the stack cannot be fully deterministic, record the variance band and treat out-of-band swings as anomalies, not as free options to pick the nicer draw.
Tool / budget exhaustion. Budget caps (tokens, wall clock, query cost) are hard stops with ledger rows — not silent truncation of the candidate set that makes the night look more selective than it was.
Wake-human criteria. Agents escalate on infrastructure failure, contradictory artifacts, or policy violations. They do not escalate on "I feel this residual is interesting." Interesting is not a terminal state.
These rules are siblings of production agent invariants elsewhere on this site — byte-stability for caches, mid-turn checkpointing, flatten verification. Different domain, same posture: explicit state beats hope.
What the Human Morning Looks Like
If the night went well, the human does not replay the factory. They open a short queue:
- Packets that cleared all gates (often zero to few).
- Anomaly list (data blocks, budget kills, hash mismatches).
- Ledger digest (which gates killed how many, any re-mine attempts).
Admission is slow on purpose. The factory's job is to make rejection cheap and automatic; the human's job is to make acceptance rare and expensive. That asymmetry is the product. Flipping it — cheap acceptance, expensive rejection — is how you recreate a headcount fund's incentive bug with better GPUs.
What This Is Not
It is not autonomous science. Agents do not invent the ontology of features, the definition of a factor library, or the capital owner's risk utility.
It is not a substitute for vertical integration. Without point-in-time data, live-calibrated costs, portfolio history for tails, and an independent risk path for anything that reaches capital, the factory is theater — agents will diligently emit wrong verdicts at high throughput.
It is not a claim that every quant process can be agentized. High-frequency microstructure intuition, relationship-driven OTC flow, and any edge that cannot be written as an explicit rule sit outside this shape. As before: an edge you cannot write down is, in all likelihood, not an edge you can compound.
Closing
The industry will keep shipping demos where a chat window "does research." That pattern optimizes for screenshots. A research pipeline optimizes for repeatable honesty: most candidates die, death is recorded, survivors still face a human door, and nothing on the research path can spend live risk without crossing into a different system with a different veto.
Geometry of Alpha said the moat is the factory. One Person + AI said the org chart collapses once discipline is executable. This piece is the wiring diagram between those two claims: agents run the frozen line; humans keep admission, posture, and direction; the ledger makes rejection compound.
Recipes decay. Factories compound. Agents only help if the factory was real before they arrived.
This is the sixth piece in the Dnalyaw quant series. Earlier: One Person + AI, The Geometry of Alpha, Two Languages of Risk Control, Dnalyaw: Engineering an AI Quant Trading System From Scratch, The Backtest-to-Live Gap.