How the GeneLoop agent could accelerate construct design and verification

The agent designs constructs

Designing a plasmid that expresses a protein is not, for most people who do it, a hard intellectual problem. It is an accounting problem carried out across a dozen tools: find the right sequence, confirm it is the right one, pick a backbone whose promoter and selection marker suit the host, choose enzymes that cut where you need and nowhere else, keep the reading frame from the ribosome binding site through the junction, and check afterwards that the file you built is the construct you described. Each step is tractable. Doing all of them, in order, without an error that only surfaces three weeks later at the bench, is what takes the time.

GeneLoop is built for the part of that work where a plausible answer is worth nothing. The agent grounds a brief in sourced parts and the host's actual capabilities, writes a plan the scientist reads and approves before anything is written, composes the construct by reference to explicit workspace paths, and then verifies the persisted file rather than its own account of what it did. Raw bases never enter its context at any point; it reads the molecule through analyses it authors and the server runs.

The first campaign tests that loop end to end on the nine briefs above. It measures the artifact — whether a construct exists, whether it is bound to a revision and a hash, whether an independent reading of the same file agrees with the agent's conclusions. It measures nothing about whether the construct works at the bench, because nothing has been to the bench.

How the agent performs on the briefs

Three of the nine briefs are clean: a competent scientist would produce a working construct, and so should the agent. The interesting four carry a seeded defect, and the last two are holdouts written after the agent's prompt and tool surface were frozen. What follows is what each group is for.

A passing agent run is not a biological result, and the report will not present it as one. The campaign records failures, partial verifications and unresolved claims as themselves. An evaluation that converts its own uncertainty into a success rate is measuring its authors rather than the system.

The agent runs the verification workflow

The second evaluation concerns reading rather than building. Given a persisted construct, GeneLoop's verifier translates coding regions, reconciles each annotation against what the bytes actually encode, checks copy number, tests whether a promoter is positioned to drive the transgene it is supposed to drive, and reports what it found. The question is whether that reading agrees with an independent one of the same file.

Agreement has to be measured in both directions, which is why the fixture set contains clean controls as well as known defects. A verifier that catches every seeded fault and also rejects correct constructs has not solved the problem; it has moved it. In practice the second failure is the more expensive one, because a scientist whose correct design is refused has no way to proceed and no way to tell a real objection from a detector that simply does not cover their construct.

How the verifier reaches a verdict

Most of the false blocks we have seen came from the same shape of mistake: a two-valued output over a three-valued reality. A detector that can only say pass or fail has to say fail when it cannot tell, and “I could not establish this” then reaches the scientist as “this is wrong.” Every finding therefore carries an evidence class, and its severity is derived from that class rather than set by hand.

Contradicted

The bytes positively disprove the claim — a premature stop inside the coding sequence, a frame that does not close, an element present twice where the design allows one.

Blocks. The construct is not deliverable as designed.

Unproven

The detector could not reach a verdict. A promoter recogniser that knows only curated motifs has nothing to say about a synthetic response element, and its silence is not evidence of absence.

Ships with the uncertainty stated. The construct is never described as verified.

Inherited

The finding is equally true of the molecule the build started from, so it describes the backbone rather than the work.

Recorded, never blocking.

A construct with unproven findings is still delivered, with the uncertainty stated in the report and attached to the claim it qualifies. It is never described as verified. That distinction is the thing the second evaluation is really testing: not whether the verifier is strict, but whether it is honest about the limits of what it checked.

The complete test protocol

The protocol is published here in full because a pre-registration that can be revised after the fact is not one. The order is load-bearing: the truth records and the metric definitions are written before the agent sees a brief, and the panels above are replaced only after the record behind them is public.

1. 01

   Pre-registration

   • Freeze the nine briefs, their hosts, their expected parts, and the track each belongs to.
   • Write the independent truth record for every brief — the construct a competent scientist would accept — before the agent sees the brief.
   • State each metric as a countable definition, including what counts as a failure and what is excluded.
   • Hash the frozen set and publish the hash. Anything added afterwards is reported as a separate campaign.
2. 02

   Session execution

   • One chat per brief, run end to end: ground, plan, approval, build, verify.
   • No seeded plan state and no pre-approved plans — the approval is a real one, given in the session.
   • No operator intervention once the brief is sent. A stalled session is recorded as stalled.
   • The model, its prompt, and the tool surface are pinned for the whole campaign and named in the report.
3. 03

   Artifact capture

   • Retain the authored workspace path, the revision, the sequence hash and the contract hash for every construct.
   • Retain the full transcript, the tool-call ledger, and every diagnostic the verifier emitted.
   • Record attempts that produced no artifact as attempts. A session that called a build tool and failed is not a session that made no attempt.
4. 04

   Independent adjudication

   • Run a BioPython analysis against the same persisted revision, blind to the agent's conclusions.
   • Have a second reviewer assess the construct against the brief, blind to both.
   • Resolve disagreements with a third reviewer, and publish the disagreement rate alongside the result.
5. 05

   Measurement

   • Score plan completion, persisted-and-verified completion, independent concordance, false blocks, false passes, and recovery after a seeded fault.
   • Count false blocks and false passes per claim, not per construct — one construct can carry several of each.
   • Report the clean, seeded-defect and holdout tracks separately. A pooled number hides which of the three the agent is good at.
6. 06

   Wet-lab escalation

   • Nothing is claimed about assembly, expression or activity without sequencing of the built construct.
   • Phenotypic claims require bench validation, reported with the number of replicates and the negative controls.
   • Until then, results describe the artifact and the workflow, and say so in those words.
7. 07

   Publication

   • Methods, artifacts and caveats are published beside the number, not after it.
   • A pending panel on this page is replaced only when its underlying record is public and re-checkable.
   • Failures, partial verifications and unresolved claims are reported as themselves rather than converted into a success rate.

What stays out of the model’s context

GeneLoop does not show raw DNA to the chat model, and that constraint shapes what an evaluation of it can publish. A nucleotide string is not tokenised in any biologically meaningful way for a language model: it cannot reliably count within one, locate a position, or hold a reading frame, and when it tries it produces confident, specific, wrong answers. The agent works from derived facts instead — coordinates, feature names, codon and residue identities, the deterministic consequence class of an edit, hashes — all computed server-side from the real sequence.

The evaluation records preserve that boundary. What we publish for each session is the brief, the plan, the tool-call ledger, the diagnostics, the sequence hash and the independent reading, which is everything needed to check the claimed result. What we do not publish is the constructs themselves as sequence, and no design in this campaign is selected for a property that would make its publication a problem. Briefs are screened before they enter the frozen set, and a brief that does not pass screening is removed rather than run and withheld.

Conclusion

If these panels fill in well, what they will show is narrow and worth having: that an agent can take a construct brief to a persisted artifact that an independent reading agrees with, and can tell the difference between a molecule it has disproved and one it merely could not check. That is a claim about a workflow. It is not a claim that the construct expresses, folds, or does anything at all in a cell, and no amount of agreement between two analyses of the same file will make it one.

The part we expect to be hardest is not design. It is the long tail of constructs a fixed set of detectors was never written for, where the honest verdict is that the evidence does not reach — and where saying so, clearly, beats guessing in either direction. We will publish what happens, including the runs that do not work.