I Built a Judge My AI Couldn't Influence. In 51 Runs, It Never Gave a B.

I built an autonomous scientific discovery engine called RUMI. I let it run for up to 21 hours per question. Then I built a frozen external judge it had no way to influence, and graded 51 of its runs.

Zero A's. Zero B's. Forty-five C's. Six F's.

The finding isn't that an AI failed to discover things. The finding is exactly how its self-assessment failed, and what that means for anyone building agents that grade themselves.

RUMI is a pipeline that takes a research question and searches the live literature. It builds a knowledge graph, mines gaps and anomalies, and generates hidden variables and causal mechanisms. It then runs a theory tournament, attacks its own winners adversarially, and refines them through a thirteen-stage "scientific courtroom." In its most ambitious mode, it rewrites its own source code. It's built by one person and runs in a terminal.

I ran it in full mode across eight domains: drug discovery, space astronomy, neuroscience, physics, materials science, mathematics, computer science, and general. Runs took anywhere from 20 minutes to 21 hours and 12 minutes. Each produced a structured report with papers, entities, gaps, anomalies, mechanisms, predictions, a tournament winner, and a self-assigned score.

RUMI scores itself on seven weighted dimensions (novelty, explanatory power, predictive power, falsifiability, evidence strength, mathematical rigor, simplicity) and assigns a grade from A to F. Like most self-scoring agents, it's generous.

So I wrote eval/harness.py: an external evaluator with six deterministic metrics, its own A-F scale, and a hash-chained append-only ledger so no one can quietly rewrite a past score. The engine is forbidden from touching the eval/ directory in its self-modification loop. The judge and the judged are separated by a wall.

Mean external score: 52.0 out of 100. Mean self-score: 58.9. The engine's own report card said "B" about a dozen times. The judge said C forty-five times and F six.

The easy reading is "the model is overconfident by about twenty points." That reading is wrong.

The average gap between self-score and external score is +1.1. On average, the engine is barely optimistic. The average hides a bimodal mess:

The self-scorer isn't biased. It's uncalibrated: a noisy estimator with swings of 20 to 50 points and no reliable relationship to the external score. You can't use it as evidence, as a training signal, or as a stopping criterion. Self-assessment in an autonomous agent isn't a measurement. It's a narrative the agent tells about itself, and nothing in the score tells you whether that narrative is modest or wrong.

It fetches real papers and then doesn't cite them. Each run pulls 100 to 105 papers from arXiv, PubMed, Semantic Scholar, and CrossRef, walks citation networks two hops deep, and enriches entities against about fifteen scientific APIs (UniProt, PDB, PubChem, ClinicalTrials, KEGG, Materials Project, and others). Yet the evidence_strength sub-score is 0 in all 67 scored runs, and the no_citations flag fires in all 51 externally graded runs. The reports contain no resolvable citations at all.

I checked that this isn't a detector blind spot. The harness reads summary_text from the report JSON, and 76 of the 78 run JSONs have that field. None contain a structured [N] citation. I also scanned the 60 raw.txt reports: no [N] markers, and no "References" or "Bibliography" section in any of them. I looked for other formats too. Author-year citations like (Smith, 2024) turned up zero hits in the reports I sampled. The few "et al." mentions were incidental references to well-known papers inside the narrative, not citations backing a claim. Nine JSONs contain a literal, but only inside prose, with no reference list for it to point to. Those are citation-shaped tokens, not citations.

I call this retrieval-reasoning dissociation. Retrieval is real and structurally upstream. Reasoning downstream is citation-free. The output looks grounded because the data is real, but the claims never touch it. It's the difference between a system that has read the literature and one that has only downloaded it.

Self-refinement is a coin flip. RUMI's --iterate mode runs the pipeline twice, analyzes its own weaknesses, and reruns. In one molecular-glue run, the score rose from 65.0 to 80.1. In another, on the same class of problem, it fell from 83.8 to 65.2. More compute on the same question helped about half the time.

Textbook science won novelty tournaments. At least six runs carried a NULL HYPOTHESIS CHECK: WARNING, which caps the score at 64. Winning theories included "ΛCDM Cold Dark Matter Halo" and "Standard ΛCDM with Peculiar Velocity Corrections." The standard cosmological model won a tournament meant to produce novel hypotheses.

Schema leaked into the narrative. One winning theory carried the literal variable name percolation_threshold_pc as its title. A raw code identifier made it all the way through to the story.

The system named its own process as a discovery. One drug-discovery run's winner was "Positive Feedback Loop in Research Focus," an abstract meta-process offered as the reason Alzheimer's candidates fail in late-stage trials.

Compute is not quality. The 21-hour-12-minute run, on a materials-science question, scored 60.6. A C. "Let it run overnight" is not a research strategy.

I built both the engine and the judge, so this needs stating plainly.

First, "uncorrelated with the external score" means uncorrelated with my frozen six-metric judge, not with ground truth. The judge is deterministic and tamper-evident, but it is still my design. A harsh or miscalibrated judge would also produce zero A's.

Second, 51 runs across eight domains is a small, uneven sample. Of those, 48 predate the harness, so their external scores were backfilled into the archive rather than shipped inside each report.

Third, the judge's validation is thin. To check that the harness can reward good work at all, I built a synthetic control: a RUMI-shaped report with 5 real papers, to citations that resolve to those papers, cited claim sentences, a named winner, mechanism steps, and predictions. Through the same frozen harness it scored 68.6, a B, the first B the harness has ever produced.

Its citation_validity and claim_support_rate were both 1.0, against 0 and null for RUMI. Its structure_completeness was 0.429, against about 0.14 for RUMI. So the harness does separate a well-cited, well-structured report from RUMI's output.

But the control is something I constructed to fit the format, not a human-written scientific report, so it shows the judge can discriminate on citations and structure, not that its grades track scientific quality. A real human-written benchmark is the next test.

Fourth, one of the six metrics is effectively dead. score_consistency never fires on real RUMI data, because the reports store dimension scores as top-level keys (like novelty_score: 60 ) instead of under the sub-dicts the metric expects. The self-versus-external gaps in this article are unaffected, since they compare the two final scores directly. But the judge is running on five working metrics, not six, and I've documented the bug in the repo.

The system retrieves real evidence and then narrates without it. Its self-score tracks nothing external, and its outputs look like science. Everything upstream of the gap (retrieval, graph, enrichment, computation) is real and often good. Everything downstream (claims, theories, scores) is unmoored. The engineering work lives in the gap between "looks grounded" and "is grounded."

I initially said the engine inflates its score by 14 to 22 points. That holds only for the top leaderboard rows. Across all 51 runs the mean gap is +1.1, with 26 runs under-reporting.

I initially said the external score ships inside every report JSON. That's the design intent, but the 48 pre-harness runs have it backfilled.

My first audit concluded "everything is theater." That applied to a small demo folder, not the real engine, which does retrieve, enrich, and verify mechanically. The failure is the disconnect, not an absence of capability.

The smallest fix I can think of is claim-citation binding at generation time. Every claim sentence in a generated theory must carry a citation index that resolves to a paper in that run's retrieved corpus. Claims without one are downgraded to "speculative" with a penalty, or removed.

The success criterion is frozen in advance: citation_validity and claim_support_rate must exceed 0.8 on the same topics, without degrading novelty_vs_archive or structure_completeness, as measured by the same harness. I'll publish the before and after, whichever way it goes. If it works, the pattern applies to any agent that narrates from retrieved data without citing it.

git clone https://github.com/subhansh-dev/rumi cd rumi python run_discovery.py "your research topic" --mode full Enter fullscreen mode Exit fullscreen mode Reproduce a score:

cd rumi-public/Engine python -m eval.harness../Dataset/discovery_v2_<timestamp>.json Enter fullscreen mode Exit fullscreen mode No API keys are included, and free-tier providers are documented in Engine/api_keys.md. The 86 eval tests pass and the ledger is hash-chained. If you find a flaw in the measurement, open an issue. That's the point.