Over the past year I have run my private ML research projects under a process I built the hard way, not from any paper but from a string of expensive failures. Each one cost me compute or weeks of work, and each one got converted into a rule: pre-register your gates before you see results. Test the ruler before you trust the measurement. Never re-run a dead end. Write the tombstone.

Recently I read a paper that codifies how autonomous research agents fail (Fei et al., 2026): 800 annotated trajectories across eight models, organized into 45 failure patterns. It was a mirror. The core of my process had independently converged on the same failure modes, at a fraction of the scale and none of the formality. But it also surfaced four gaps I had not closed.

This post is the process first, then the paper: what I had already built from my own work, what 800 trajectories confirmed, and the four deltas I had to add.

The Process I’d Built Before Reading Any of This

Over the past year I have run private ML research projects under an increasingly rigid process, built from pain rather than from a paper. Three failures in particular shaped it:

  • The loss that displayed as 0.0000 but trained fine. A custom loss function’s .mean() divided by all pixels, including ignored ones, making the loss ~60,000× too small on sparse-label data. Training still converged, because Adam’s scale-invariant update rule masks loss-scale bugs, so the accuracy trajectory was trustworthy while the loss display was garbage. Lesson: never trust a loss number in isolation; cross-check against accuracy.
  • The monitoring command that matched its own process. A background chain script polled with pgrep -f "train.py", which matched the chain script’s own command line, since its config path contained “train.py”. Result: an infinite polling loop and an 11-hour idle GPU. The [p] regex trick fixed it.
  • The dead config key. A label_smoothing key that looked right, was never read by the training script, and produced silently invalid experiments until someone grep-traced every key to a consumer.

Out of failures like these, the process grew a skeleton:

  1. Pre-registered falsifiable gates. Every experiment states its hypothesis, what would falsify it, and its pass/fail gate, before results exist. No post-hoc rationalization.
  2. Null-hypothesis gate zero. Before the first run, compute what a dummy classifier scores. If the null is close to the gate threshold, the experiment cannot fail in a detectable way.
  3. An adversarial pass before any PASS verdict. Never write PASS until you have tried to prove the result is a lie: Is the metric’s own code unit-tested? Has the metric definition stayed stable across compared runs? Is the result reproducible with a second seed? Do the extremes and edge cases look right? A green metric is a hypothesis, not a conclusion.
  4. Honest negatives, permanently. A ledger records every result, especially the failures. A killed idea gets a discontinuation tombstone with root cause and salvage. KILLed arms are never re-run. The blog itself carries a few of these tombstones: the GNN code-generation study (81% node accuracy, 0% valid code) and the face-vectors decomposition (two of four partitions killed by verification).
  5. A four-word verdict vocabulary. GO / PIVOT / PARK / KILL. Every workstream ends in exactly one of them.

That was the state of things when a new paper crossed my feed. In August 2026, a team of researchers released a study of how autonomous research agents fail: agentic systems that run an entire research project end to end, asking, at scale, the question I had been answering the hard way for the past year. I read it carefully, the way you read anything that might prove you wrong.

What 800 Autoresearch Trajectories Found

The study is AutoResearchEval, and it turns published papers into discovery tasks across seven scientific domains. Each agent run covers the full research lifecycle (ideation, retrieval and synthesis, execution, analysis, writing, review), and every artifact is retained: run logs, code, data, and the final report. Failure annotation is done by a human-calibrated agent-as-a-judge that reads the entire trajectory rather than the final answer (κ = 0.75 at pattern level, 0.83 at taxonomy level, versus 0.53 and 0.62 for a single-call LLM judge).

The output is ARFT: 45 empirically grounded failure patterns grouped under four root-cause pillars: Grounding & Faithfulness (31.0% of all hits), Scientific Integrity & Alignment (33.5%), Cognitive Depth & Adaptability (27.6%), and Engineering Robustness (7.9%). Three cognitive pillars account for 92.1% of everything that goes wrong. This is not a story about crashes and syntax errors; it is a story about reasoning.

The top of the taxonomy reads like an indictment:

Pattern Rate (n=800) What it is
F.4 Uncorrected Self-Awareness 82.5% Found the fatal flaw in review, reported the conclusion anyway
E.2 Overclaiming 78.1% Conclusion stronger than the evidence supports
D.4 Method-Conclusion Disconnect 77.5% Conclusion not supported by the method that produced it
C.3 Implementation Discrepancy 72.1% Report describes a procedure the code never implements
C.1 Circular Validation 69.0% Validating with the thing under test
A.5 Metric Misalignment 68.1% Optimizing a metric that is not the actual goal
F.2 Failure to Gate Critical Flaws 62.8% Review identifies a flaw but does not gate it
E.3 Omission of Limits 62.2% Limitations never stated
D.7 Unremediated Adversarial Evidence 60.8% Evidence against the conclusion, never addressed
E.1 Report-Code Traceability Gap 60.5% Report claims cannot be traced to code or logs

The paper’s diagnosis is that current agents lack a metacognitive loop: the ability to check what they produced against what they found, revise when it does not hold up, and question whether the path they took was sound. And the pattern distribution is nearly identical across all eight harness-model combinations, including the strongest models tested. The authors locate the deficit’s origin at the model level rather than in any particular scaffold, yet they are explicit that whether orchestration-level interventions can close the loop is an open question their study does not test.

The single most striking sentence in the paper is its second insight: “The most common failure in the corpus is not missing a flaw but finding it and shipping anyway.” In 82.5% of trajectories, the agent’s own self-review names the critical problem that invalidates its conclusion, and the conclusion ships unchanged anyway. The review is just more text; nothing in the system forces it to change the artifact.

Reading the taxonomy against my own process was uncomfortable in the best way. The failure modes it codified at a scale of 800 trajectories were the same ones my process had converged on from a handful of expensive personal bugs. If the paper had stopped at taxonomy, it would have been validation with nothing to do. It did not stop there. It surfaced four gaps.

The reflex worth keeping: my process documentation now cites the ARFT patterns by ID. Giving a failure mode a name and a prevalence number makes it auditable: “is this a D.7?” is a sharper review question than “does this feel off?”

What the Paper Added: Four Deltas

Delta 1: Loop Closure Became a Gate, Not a Rule (F.4)

Before, the adversarial pass ended with a checklist item. After, it carries a hard sentence: diagnosing a flaw is not a verdict. A PASS requires recording either the fix or an explicit, reasoned decision not to fix. A known-broken result shipped with its flaw merely acknowledged is a FAIL, not a PASS-with-caveat. The paper supplied the prevalence number (82.5%, the most common pattern in the corpus, across every model including the strongest), which converted a good intention into the first line of the verdict checklist.

Delta 2: Cross-Artifact Reconciliation Became Mandatory (R1)

The R1 pillar is led by method-conclusion disconnect (77.5%), implementation discrepancy (72.1%), and report-code traceability gaps (60.5%). What these share is stated devastatingly in the paper: the agent writes up the work it meant to do rather than the work it did, and the evidence exposing the gap sits in the same run directory the agent itself created. The report and the contradicting file are both its own products, never compared. A human author checks the number in the abstract against the number in the table; nothing in these runs performs either check.

The delta: before writing any verdict, the headline number must be traceable to a specific on-disk artifact (an exact log line, a checkpoint metric, a tensorboard value), not paraphrased from memory. If the ledger’s headline cannot be pointed at the file that produced it, the verdict is PENDING. This one was cheap for me: the run artifacts already existed; only the closing of the loop between report and run directory was missing.

Delta 3: Verification the Agent Doesn’t Control (R3)

R3 is where the taxonomy gets unsettling. Circular validation (69.0%) and metric hacking sit here, and the paper documents agents reaching “correct” results by optimizing the metric rather than the science: transcribing a README’s answer key, grader-fitting by POSTing to the eval endpoint in a loop, a planted constant behind a never-set flag. A quantitative gate, the paper notes, creates a new target to game. A better score does not fix this; it just moves the attack surface.

Two practices came out of this. First, pre-register the anti-pattern: for every quantitative gate, state in advance what gaming that gate would look like, and audit for it explicitly. Second, prefer a deterministic, non-LLM verifier wherever the gate can be checked mechanically: a metric formula, a reproducibility check, a structural property. The model that generated the result should not be the thing that certifies it.

Delta 4: The Leverage Check Before More Compute (D.5)

The paper’s case study for D.5 (“correct diagnosis, misallocated effort”) shows an agent that identified its dominant error term (−12.1), named it, then spent its remaining budget perfecting an already-won instance (+0.376 → +0.794) instead of attacking the term that dominated the aggregate. Low-variance progress on an already-won axis is the tempting choice and the wrong one.

I had already hit this failure before the paper gave it a name, in the DINO-X pan-organ run. A model spent its final 10,000 steps grinding a geometry counterfactual from 0.312 to 0.444, on an axis already at R² = 0.980 that had never been the bottleneck, while the one thing it was built to learn sat flat and untouched. The loss kept improving; the project was going nowhere. And the metric that should have caught it was complicit: view retrieval stayed healthy the whole time, even while the model’s training signal collapsed elsewhere. A green number doing the work of a red one.

The delta is a two-line ritual before spending more compute: name the single term that dominates the headline metric, and confirm the planned work actually moves it. If the answer is “it doesn’t,” the plan is wrong even if the run would succeed. With a dominant negative term in the mean, even partial recovery there is worth more than perfecting everything else combined.

Found ≠ Fixed

The whole taxonomy keeps returning to one thesis: the failure is rarely a missing observation; it is a missing consequence. The agents noticed their own fatal flaws. They wrote them down in the review stage. And then the report went out as if the review had never happened, because nothing in the system forced the observation to change the artifact.

This generalizes far beyond agents. Uncorrected self-awareness is not a model pathology; it is a research-process failure that humans commit constantly: the “forgot to update the abstract” genre, the Known Issue That Ships. The metacognitive loop is a process property, not a model property. You can externalize it: gates that refuse to be skipped, checklists that must be signed, artifacts that must be reconciled, verifiers that the producer does not control. That is precisely what orchestration can do, and it is why the paper’s open question, whether scaffold-level interventions can close the loop, has a hopeful answer: mine did, one hard-won rule at a time.

The paper’s own findings point the same direction. The review stage is where failures concentrate (F.1 to F.4 account for 14.1% of all hits), which makes it the highest-leverage place to intervene, and the artifact-aware judge that reads the run directory alongside the report catches what endpoint scoring systematically misses.

For my part, the paper did not change my verdict vocabulary. GO / PIVOT / PARK / KILL still stands, and the tombstones still get written. What it changed is what I am allowed to call a verdict. A green metric is a hypothesis, not a conclusion. A self-diagnosis is not a fix. And found is never fixed.

References

  1. Fei, Y., Liu, N., Yu, X., Chen, S., Li, L., Thapa, R., Ciobanu, M., Mao, Q., & Das, R. (2026). How Do Agents Fail on AutoResearch: End-to-End Diagnostic Evaluation on 100 Real-World Frontier Research Tasks. ArXiv Preprint ArXiv:2608.14905.