When Agents Run the Experiment, the Record Becomes the Deliverable
Agent-run experiments shift reproducibility from human notes to execution traces. Why capture at execution time belongs in every agent-ification project's acceptance criteria.
A bench scientist finishes a run, opens the notebook, and writes four lines: what was made, at what temperature, for how long, and whether it worked. Anyone who has done the work reads those four lines and nods. The record is complete.
Now consider what the machine actually did. It moved a sample between positions, waited for a heater to reach a setpoint, retried a failed pipetting step, re-read a sensor after a timeout, and accepted a batch of reagent with a particular lot number. Thousands of state changes, none of them written down, because none of them seemed worth writing down.
That gap is tolerable when the person who wrote the four lines is also the person who will run the experiment next time. It stops being tolerable when the executor is a group of AI agents. The record is no longer a narrative someone composes afterward; it is a byproduct of execution, and the byproduct becomes the deliverable. For data platform and research informatics leads, this is the point where an automation project quietly turns into a data infrastructure project.
One boundary up front. The evidence here comes from a single paper by a single team in a single domain, and that paper does not describe how metadata and provenance are governed. The argument that the record becomes the deliverable is my inference from the structure of the problem, not a conclusion the authors draw.
Retrospective records assume common sense that agents do not have
A human lab record is written after the fact, by someone who shares context with the person who will read it. That shared context is why omission is rational rather than lazy. You do not write "pre-heat the block first" because everyone in the room knows you pre-heat the block first. The record compresses; the tacit knowledge fills the gaps.
The scale of what changed is visible in Nature's news coverage of AutoDNA, published November 4, 2026 and reported by Heidi Ledford. A team at Shanghai Jiao Tong University built a system in which a group of AI agents designs and executes an experiment from start to finish following a single human prompt. Samples move by robotic arm, the lab operates more than 20 types of instrument, and a single project can complete thousands of operations. Human hands are needed afterward only to refresh reagents and service hardware.
Co-author Chen Haibo, a computer scientist at the university, described the prior state of the art plainly: "In many existing systems, human experts are still required to configure the instruments," he said. "AI is mostly added to handle just one part of the process."
That is the shift. The agent is no longer assisting one step; it is the executor of the whole chain. And an agent inherits none of the tacit context that made the four-line record sufficient. It does not know which omissions are common sense because it has no common sense to draw on. What a human would have silently supplied is simply absent, and absent in an agent-run experiment is not a gap someone fills in later. There is no later. The run is over, the agent has moved on, and the knowledge that would have prompted a note was never in the system to begin with.
The failure mode is precise: the record is complete by human standards and incomplete by execution standards. Those two standards have diverged, and nothing in the workflow announces it.
Variance between runs lives in the fields nobody logs
Run the same instrument twice with the same one-line prompt and you will not get the same execution. You will get the same intent, executed along a different path. The divergence is not in the protocol document, which is identical both times. It lives in parameters, in the order operations were dispatched, in failed retries that were silently recovered, in the state the instrument was in when it was called, and in which sample batch was loaded.
The surface area for that variance is large. The Nature report describes a robotic arm moving samples, more than 20 instrument types under orchestration, and thousands of operations in a single project. No human is positioned to observe that volume of events, let alone transcribe it.
With a human operator, some of the variance is absorbed by judgment in the moment. The operator notices the block is cold and waits; the operator sees the pipette misfire and repeats the step; the operator knows this lot of reagent behaves differently and adjusts. The written record can stay coarse because the operator's judgment acted as a buffer between what happened and what mattered. With an agent, there is no buffer. The judgment is a model decision, and a model decision is an event like any other. If it is not captured, it is gone.
That leaves the execution trace as the only place the difference between two runs can be found. Not the protocol, not the summary, not the notebook entry. The trace: what parameters were submitted, in what sequence, which retries fired, what state the instrument reported, which batch the sample came from.
A caveat worth stating. The AutoDNA paper does not disclose how metadata and provenance are handled, so this section argues from the structure of the problem, not from the team's implementation. I am not claiming they log these fields or fail to log them. I am claiming that any system at this level of autonomy generates variance in exactly these categories, and that the categories are the ones human record-keeping has always treated as noise.
The bottleneck moves from execution to explanation
Once execution is no longer the constraint, the constraint moves. The lab stops asking "can we do it" and starts asking "can we say how it was done." Those are different questions with different owners.
The execution capability is already demonstrated. According to the Nature report, the system has been used to detect a cancer-associated mutation in a sample and to encode a sentence into the four bases of DNA. Whatever else is true, the doing part is no longer the frontier.
Milad Abolhasani, a chemical engineer at North Carolina State University, framed the direction in the same article: "The future of science is going to involve a lot of autonomous labs." That is a prediction about the field, not a finding about this system, and it should be read at that scope. But it points at the general case, and the general case has a general problem.
Explaining how a run happened is not an experimental method problem. A better protocol does not solve it. A more careful scientist does not solve it, because the scientist is no longer in the loop. What is missing is the capability to capture execution events, store them, link them to the samples and results they produced, and query across them. That is a data infrastructure problem, and it belongs to the people who own storage, lineage, and access control.
This is where the opposing habit does its damage. "If the electronic lab notebook is filled in, we are covered" feels like a control. It is not. An ELN records the fields a human considered important at the moment the template was designed. An agent's variance lands in the fields a human considered unimportant. The notebook can be fully populated and still describe a run that cannot be reconstructed, because the fields that would have carried the difference were never on the form.
Autonomy raises the cost of every missing field
In a manual lab, a missing field is cheap. The person who ran the experiment is standing there. They will be there at the next run. The gap gets closed verbally, in passing, at near-zero cost, and the correction propagates through the same person's hands.
Autonomy removes that mechanism. The person who could have filled the gap has been designed out of the loop, which is the entire point of the system. So the missing field does not get corrected at the next run. It gets inherited by every future run that passes through the same orchestration path. One unlogged parameter becomes a systematic blind spot across a project, then across a program.
The consequences compound in two directions.
Audit first. An incomplete trace is not a documentation inconvenience; it is an inability to demonstrate what happened. In a regulated environment, the difference between "we did it correctly" and "we can show we did it correctly" is the whole game. A record that omits the retries, the instrument state, and the sample batch cannot carry that demonstration, no matter how many fields the notebook template contains.
Scale second. Extending an agent-run workflow to a second site should be a matter of replicating a system. If the record cannot carry the process, it becomes a matter of someone explaining the process out loud again, at the new site, to people who were not there. Every expansion restarts from a conversation instead of a query. That is the hidden tax on autonomy: the more you automate, the more each new deployment depends on a human narrator who may not be available.
None of this is a claim about what the AutoDNA team found. It is what follows from removing the person who used to absorb the gaps.
The cost of capture is real, and it falls in specific places
The objection deserves a fair hearing, because parts of it are correct.
Instrument vendors already log a great deal. Modern instruments emit telemetry, error codes, and run files, and some of that is genuinely detailed. Electronic lab notebooks are mandated in regulated environments and satisfy those mandates; a filled ELN is not nothing. And capturing everything at execution time is expensive, in storage and in engineering. Trace volume grows quickly, and someone has to build and maintain the pipeline that ingests it.
All true. The cost of the recommendation falls in specific places, and it is worth naming them honestly.
Instrument APIs are heterogeneous and often closed. Getting consistent event streams out of a mixed fleet is integration work with no standard shape, and some vendors will not make it easy. Trace volume grows faster than most teams expect, and not all of it is worth keeping; a system that captures everything indiscriminately will drown its own users. And the people who best understand which fields matter are the same people the automation is designed to remove from the loop. The expertise needed to design the capture is the expertise being retired.
So where does the objection fall short? Vendor logs are per-instrument. They tell you what one device did. They do not, by themselves, reconstruct the cross-instrument sequence, the retries that spanned two devices, or the lineage from sample batch to final result. An ELN's completeness is defined against human-selected fields, so it cannot certify completeness against execution events it was never designed to hold. Neither substitutes for capture at the orchestration layer, where the sequence actually lives.
That is a statement about where the gaps are likely, not a verified finding about any named vendor. The honest position is that capture is not free, not all traces are worth keeping, and the engineering is real. The question is not whether to pay for it but whether the alternative, an unexplainable run, is cheaper.
Conclusion: write capture into the acceptance criteria
For data platform leads and research informatics leads in R&D-heavy organizations, the recommendation is narrow and testable: write "capture at execution time" into the acceptance criteria of any agent-ification project, instead of backfilling metadata after the experiment ends. Backfill assumes someone knows what is missing. In an agent-run workflow, no one does.
A two-week action makes this concrete. Take one existing automated workflow. List the fields a stranger would need to reproduce it tomorrow, with no access to the people who built it. Then diff that list against the fields the system actually persists. Sort the gap into two buckets: what is recoverable from instrument logs, and what is only fixable by changing the process. The first bucket is an integration task. The second is a design decision, and it is the one that will not get easier later.
This is also where infrastructure choices start to matter. When traces, samples, and results are stored from the same source, "how did this batch of results come about" becomes a query rather than an interview. When permissions and lineage sit together, reuse across labs does not require a migration first. That is the shape of the problem Singdata addresses, and it is worth evaluating against your own gap list rather than against a vendor's.
The landing is simple. An agent will not write down your common sense for you. Provenance has to be collected during execution, because there is no later moment at which someone will remember what mattered. Without it, the more automated the lab becomes the less reproducible it is. It will fail audit. And every second site will restart with someone explaining it out loud again.
FAQ
Why doesn't an electronic lab notebook solve this?
Because the ELN's field set is defined by humans in advance, and an agent's variance lands outside that set. A fully populated notebook can describe a run accurately at the level the template asks about while omitting the parameters, retries, and instrument state that made this run different from the last one. The notebook answers the questions someone thought to ask.
Which fields actually need to be captured?
As a starting list rather than a standard: submitted parameters, dispatch sequence, failed and retried operations, instrument state at call time, and sample batch identity. These are the categories where run-to-run divergence concentrates. The right list for a given workflow comes from the diff exercise above, not from a generic template.
Does this only matter for fully autonomous labs?
No, though the evidence here covers one fully agent-driven system, so extending the argument to partial automation is reasoning rather than a measured result. Partial automation moves the same problem earlier: as soon as a step is executed by software rather than a person, the person's judgment stops absorbing the variance, and the trace becomes the only record of what actually happened.
Previous posts
1. Medallion Architecture: What Changes Between Bronze, Silver, and Gold? — https://singdata.com/trending/medallion-bronze-silver-gold
2. How Much Data Preparation Is Hidden in Your BI Reports? — https://singdata.com/trending/hidden-data-prep-in-bi-reports
3. How to Migrate from ETL to ELT Without Breaking Reporting or Agentic AI Freshness — https://singdata.com/trending/2026-11-04-elt-file-first-ingestion