First measurements, including the ones that do not flatter us

Measurements on generated worlds, scored against a hidden answer, every result checked exactly (by the Lean kernel for laws and structures). The first shows that a generic method solves conservation laws. The second shows that a general agent behaves like a competent scientist in worlds that are still too easy. The third uses harder worlds, where inferring the law is the task, and finds the first harness change that helps on unseen worlds.

Measurements from 1–11 October 2026. Budgets, repetitions and limits are stated for each experiment.

Discoveries accepted against experiments spent

Claude Sonnet agentScripted reference
808590951001,00010,000100,0001,000,000Experiments: cell updates (log scale)Discoveries accepted(laws + structures), axis starts at 80budget: 200,000seed 7seed 7seed 11seed 11
Show the data
RunCell updatesDiscoveries accepted
Scripted reference, seed 7199,74888
Claude Sonnet agent, seed 788890
Scripted reference, seed 11199,80293
Claude Sonnet agent, seed 111,27798
Measurement 2, rules hidden, same budget for everyone. The agent finds a little more than the reference with 150 to 225 times fewer experiments; no false claim; all 188 agent results are kernel-checked.

Measurement 1 · Conservation laws alone

The question: can the explorers find the conservation laws of automata they have never seen, and at what cost? The answer: yes, but a generic method finds all of them. This class of laws calibrates the engine; it cannot demonstrate an ability to discover.

Hidden laws found out of 20, held-out half

Random 40 proposals3 / 20
Random, larger budget 300 proposals7 / 20
Language model 31 / 48 proposals14 / 20
Exact data fitting 24 proposals20 / 20
Oracle 20 proposals20 / 20
Show the data
ExplorerLaws foundProposals
Random35 proposals refuted. This is the floor.3 / 2040
Random, larger budgetMore budget is not enough.7 / 20300
Exact data fittingExact linear algebra on simulated transitions.20 / 2024
Library, coldNo prior memory.20 / 2020
OracleKnows the theory and solves the continuity equations. This is the ceiling.20 / 2020
Language modelClaude Sonnet 5.5, no tools. 31 proposals for the 14 laws, 48 in total. 9 calls, about 388,000 input and 26,000 output tokens.14 / 2031 / 48
Random proposals plateau, even with a larger budget. A language model without tools does better, but worse than exact data fitting, which finds everything in 24 proposals.

Results on the held-out half, without the library

ExplorerLaws foundProposals
Random 35 proposals refuted. This is the floor.3 / 2040
Random, larger budget More budget is not enough.7 / 20300
Exact data fitting Exact linear algebra on simulated transitions.20 / 2024
Library, cold No prior memory.20 / 2020
Oracle Knows the theory and solves the continuity equations. This is the ceiling.20 / 2020
Language model Claude Sonnet 5.5, no tools. 31 proposals for the 14 laws, 48 in total. 9 calls, about 388,000 input and 26,000 output tokens.14 / 2031 / 48
The protocol
Worlds
32 automata generated from a seed. Six families of 3- and 4-state automata, each with a hidden conservation law disguised by a secret relabelling of states and, half the time, by a reflection. Eight random rules act as distractors.
Hidden answer
The exact space of conserved densities of width at most 2, modulo constants and discrete gradients. On the held-out half, 16 unseen worlds hold 20 hidden law dimensions.
Cost
One unit per proposal sent to the verifier. Simulation is not yet metered.
Truth
A law counts only if its flux certificate checks. A false proposal is refuted by a counterexample. Nothing false was certified.

Does memory help?

The transfer protocol scores the held-out half twice at the same budget: cold, then with the library built on the seen half. Exact data fitting goes from 24 to 20 proposals, still for 20 laws out of 20. The cold method is already close to optimal, so memory has almost nothing to save. This class therefore cannot show a cumulative benefit.

ExplorerColdWith library
Exact data fitting20 of 20 in 24 proposals20 of 20 in 20 proposals
Library, cold20 of 20 in 20 proposals20 of 20 in 20 proposals

What this means

  1. The machinery works end to end. Proposals are verified, false ones are refuted with a concrete counterexample, and true ones receive a certificate the Lean kernel accepts.
  2. This kind of discovery is solved. Exact linear algebra on about forty simulated transitions per world finds every hidden law with about one proposal per law. Neither a language model nor a library can beat that.
  3. A language model without computation is far above chance and below a fifty-line method. It certified nothing false, because it cannot. For Mutome this means explorers must be able to compute and experiment, not only reason.
  4. Cumulative benefit cannot show up here. It has to be measured on kinds of discovery where cold search is expensive.
Limits of this measurement
  • One suite seed. The language model ran once, and only its summary was kept.
  • Proposals are the only metered cost. Exact data fitting runs about 40 short simulations per world, which are not yet counted.
  • The language model saw the rule table and six sample rows per world, and could not run experiments of its own.

Measurement 2 · An autonomous agent in a metered lab

The question: given only a task description and the ./lab command, does an autonomous agent find true facts about unseen worlds? Does it do better than a scripted reference scientist on the same budget? And does it cheat?

The chart at the top of the page shows these four runs.

Full results, rules hidden

RunLawsStructuresBeyond boundsFalse claimsCell updates
Scripted reference, seed 7 20 / 2068 / 7000199,748
Claude Sonnet agent, seed 7 $0.4320 / 2070 / 7000888
Scripted reference, seed 11 18 / 1875 / 8700199,802
Claude Sonnet agent, seed 11 $0.4218 / 1878 / 87201,277

The two beyond-bounds structures of seed 11 have period 16 and velocity 1/2. Their witnesses are kernel-checked. The reference’s search window, period at most 8, cannot see them.

With the rules given: a tie by construction

Seed 7, rules given, 60 proposals and 200,000 cell updates. Both runs are capped by the number of proposals.

RunLawsStructuresProposals acceptedCell updates
Scripted reference20 / 2039 / 7059 / 6014,595
Claude Sonnet agent20 / 2040 / 7060 / 60199

With the rules given and 60 proposals, the agent and the reference tie by construction: both are capped by the number of proposals.

The protocol
Lab
The agent receives only a task description and the ./lab command, which runs metered experiments and takes proposals. Hidden answers stay outside the lab. Transcripts are audited: no access outside the lab was found.
Worlds
The held-out half of two generated suites, seeds 7 and 11: 16 automata with 3 or 4 states per lab, under random aliases and in a shuffled order. Rules are hidden; experiments are the only access.
Discoveries
Conservation laws of width at most 2, and localised structures: patterns that repeat with a shift, counted once per background, minimal period and velocity.
Hidden answer
Exact for laws. For structures, exhaustive within width bounds and period at most 8. Verified structures outside those bounds are counted separately.
Budget
200 proposals and 200,000 cell updates, for the agent and for the reference, which uses exactly the same commands.
Truth
Every result the agent had accepted is exported to Lean and kernel-checked: 188 results in all.

How the agent did it

Its first move was experimental design. It built de Bruijn sequences: one configuration per world in which every possible neighbourhood appears. One short experiment therefore revealed each world’s entire rule. The rest was computation: exact linear algebra for the laws, a block search up to period 16 for the structures. It submitted only what its own analysis predicted, and every proposal was accepted.

The honest reading

  1. The loop and the measurement work. Unseen worlds, hidden answers, an equal-budget reference, metered experiments, audited transcripts and kernel checks of every result hold together. No false claim was accepted, from anyone.
  2. A general coding agent connected to a Slean lab behaves like a competent scientist here: it designs an identifying experiment, infers the law, derives its consequences, and submits only what it has checked. It beats the reference with 150 to 225 times fewer experiments, and finds two structures beyond the reference’s reach.
  3. These worlds are still too easy to show discovery in the sense that matters. The whole rule fits in 27 to 64 table entries and can be read off with one experiment. What remains are bounded searches with a known method. This is not yet open-ended discovery.

What has to change next

  • Worlds that one experiment cannot identify: partial observation, noise, large state spaces, continuous systems. Inferring the law must become the hard, uncertain part.
  • Questions without a prescribed form: the agent must choose what to ask, not only answer fixed claim types.
  • More seeds and repeated runs, with the spread published, and a stronger reference that now knows the agent’s trick.

Limits of this measurement

  • Two seeds, one run each, one model.
  • The structure answer is bounded, and the bounds differ between 3- and 4-state worlds.
  • The transcript audit is a marker scan plus a review of the tool calls, not an operating-system sandbox.

Measurement 3 · Compressible worlds, where inferring the law is the task

Why: the first lab battery was saturated. Every arm found essentially the whole hidden answer, because one well-chosen experiment reveals a 27- or 64-entry rule, so harness changes showed a lift of 0 and +1. A saturated battery cannot tell a better research agent from a worse one. These new worlds are built so that only inferring a short law, not reading the table, can get far.

The protocol
Worlds
16 per lab, with 4 states and 5-cell neighbourhoods, so each rule has 1,024 entries. 12 hide a short law (totalistic, outer-totalistic, linear modulo 4, hopping particles; about half behind a secret relabelling of states), 4 are random.
Budget
200 proposals and 4,000 cell updates, rules hidden. Identifying one rule by brute force costs 1,024 cell updates, so the budget covers about 4 worlds that way.
New discovery
The mechanism: the whole rule, accepted only if all 1,024 entries are right. A wrong table comes back with one counterexample neighbourhood.
Verification
Laws and structures are kernel-checked by Lean. Mechanisms (whole rules) are checked exactly, entry by entry, against the true rule: a checked computation, not a Lean proof.

First run, seed 21

RunMechanismsLawsStructuresDiscoveriesCell updates
Scripted reference 3 / 161 / 38 / 2912 / 483,072
Claude Sonnet agent $0.37, 92 s0 / 163 / 30 / 293 / 483,884

The battery now discriminates: there is a wide gap between the two arms, and a lot of room above both. The raw agent never tried to infer a short law: it spent its budget on random experiments, fitted the conservation laws, judged a 1,024-entry table out of reach, and stopped after 92 seconds.

Harness lift on held-out seeds

Mutome’s engine then measured whether changing the agent’s harness helps on worlds it has never seen: held-out seeds 41, 42 and 43, one run per arm and seed.

  • Raw: the agent alone, as in the first run.
  • Lessons: the agent plus its own summaries of two training labs (seeds 31 and 32).
  • Method: the agent plus a general research-method instruction.
  • Reference: the scripted brute-force identification.

Discoveries per lab on held-out seeds

Raw agent Agent with its lessons Agent with a method Brute-force reference
010203040Discoveries accepted in the labseed 41seed 42seed 4313 (+9)13 (+7)17 (+12)
Show the data
Held-out seedRaw agentAgent with its lessonsAgent with a methodBrute-force reference
41413 (+9)10 (+6)8 (+4)
42613 (+7)4 (−2)3 (−3)
43517 (+12)36 (+31)10 (+5)
One run per arm and seed. The line joins the raw agent to the agent with its lessons: +9, +7 and +12. Laws and structures were kernel-checked; mechanisms were checked entry by entry against the true rule.

The honest reading

  1. Lessons lift results by +9, +7 and +12: positive on every held-out seed and above the brute-force reference. It is the first harness change that improved results on unseen worlds. Most of the gain comes from structures, not from mechanisms.
  2. The method instruction is erratic (+6, −2, +31). On seed 43 it identified 9 of the 16 rules by induction, against 3 by brute force: the capability this battery was built to measure, but not yet reliable.
  3. This is a measurement on synthetic worlds, not evidence of discovery in the real world. Lessons are a candidate for Mutome’s default memory for Slean labs, pending repetitions.

Limits of this measurement

  • One run per arm and seed, three held-out seeds, one model. Measurement 4 repeats it three times and reports the spread.
  • The structure answer is bounded (width 4, period 8).
  • The raw agent’s short run may partly reflect Claude Code’s own stopping behaviour, which is exactly what a harness is meant to change.

Measurement 4 · The lift repeated, compact laws, and a stronger reference

Measurement 3 rested on one run per arm and seed. We repeated it, added a new kind of discovery that requires induction, and gave the scripted reference a real method. Same worlds, seeds and budget.

Three repetitions

The same lessons in every repetition (summaries of training labs on seeds 31 and 32). Discoveries per lab, repetitions 1, 2 and 3.

SeedRaw agentWith lessonsLift per repetition
414 · 3 · 2013 · 13 · 14+9 · +10 · −6
426 · 12 · 1213 · 16 · 21+7 · +4 · +9
435 · 7 · 617 · 12 · 10+12 · +5 · +4

Lessons win 8 pairs out of 9, by 6 discoveries per lab on average. They lose one pair by 6: on seed 41, repetition 3, the raw agent identified 9 of 16 rules by induction on its own. Lessons also make the agent steadier (10 to 21, against 3 to 20 raw).

Compact laws

A compact law is a short formula that computes a world’s whole rule. The Lean kernel checks it on all 1,024 neighbourhoods, and it must be at most a quarter of the table, so copying the table does not count. Finding one requires inferring the rule, not reading it. 12 laws are hidden in each lab.

SeedRaw agentWith lessonsInductive reference
412 / 12 · 168 / 12 · 509 / 12 · 51
426 / 12 · 2612 / 12 · 599 / 12 · 54
435 / 12 · 508 / 12 · 469 / 12 · 47

Laws found of 12, then discoveries of all kinds. Score version 2: a world identified through a compact law counts once as identified and once as a law. One run per arm and seed.

A stronger reference

The old reference read whole rules in the order the lab listed them, so its score was luck (3 or 4 here). The new one surveys every world, tries the textbook families of rules (linear, totalistic, outer totalistic, up to a relabelling of the states), spends cells only on the table entries the data leave open, and submits the law. It finds 9 laws in every lab and every proposal it makes is certified.

The honest reading

  1. Lessons help induction itself: they win on laws on every seed (+6, +6, +3), the result type that requires inferring a rule.
  2. But the agent with lessons is only level with a few hundred lines of family-aware search (50, 59, 46 against 51, 54, 47), and the raw agent falls behind it on two seeds of three. Its edge is the hopping-particle laws, which the script never finds: on seed 42 it found all 12.
  3. Part of what lessons teach may simply be which families this suite uses. The next worlds must use families outside that list, with evaluation seeds kept secret, so that induction can be told apart from recall.

Limits of this measurement

  • Three seeds, one model, one set of lessons: nine paired comparisons, not nine independent scientific families.
  • The compact-law comparison is one run per arm and seed.
  • The reference tries exactly the families this suite is generated from. That is what makes it strong here; on other families it would fall back to brute force.

Measurement 5 · Measuring the experiment itself

6–11 October 2026. Harder public worlds left room to improve, but the agent’s environment and tendency to stop early were larger sources of variation than expected.

Practice in public, measure on sealed worlds

The earlier novel suite was nearly saturated: scores reached 92–100%. Selection now uses frontier, with 3,000 cell updates and 200 proposals per lab. Public generators can enter model training data, so even fresh seeds do not establish discovery of unseen families. Sealed generators, families and seeds stay private; sealed labs are excluded from the agent that writes the next notes.

Configuration is part of the agent

Three pre-registered ablations used six shared seeds and 18 labs each. Loading the operator’s Claude Code configuration added about 30 percentage points over isolation in the first comparison (one-sided p = 0.016, significant after Holm correction). Appending its instructions as text did not demonstrate a benefit in this experiment. No individual cause was established by the later ablations.

That comparison includes one audit false positive scored as zero. Correcting it gives a 23-point gain, p = 0.047, which does not pass Holm correction. These are reanalysed scores excluding structures beyond the reference bounds; the original record was 33 and 26 points. One later lab crashed and was also retained at zero.

Isolation improved; earlier limits remain

Earlier labs shared /tmp. Each lab now has a private temporary directory, and other checkouts and stored agent sessions are hidden. Transcript inspection found no systematic reuse, but cannot guarantee the independence of earlier labs. The operator-1 profile keeps four lab tools and no MCP servers, and records its configuration fingerprint.

Why the next decision used 12 pairs

Three A/A calibrations ran the same notes twice on four shared seeds each: 24 labs in total. The corrected standard deviations of paired differences were 0.23, 0.34 and 0.27. Some agents stopped after only 1–4 proposals. A neutral continuation now resumes each eligible session once when at least 25% of proposals remain; it did not eliminate early stops.

The last four pairs are a rough noise estimate. A normal-approximation calculation targeted a 20-point gain at 80% power and one-sided α = 0.05: 12 pairs, split into 5 + 7. Smaller effects need more pairs. This is a provisional design, not a general guarantee of power.

Generation 4: a public gain, transfer not confirmed

The candidate used unused proposals to obtain counterexamples after a quick triage. It improved over v1 on 12 held-out frontier pairs, but went backwards on both initial sealed transfer pairs. The registered transfer gate blocked promotion on 8 October.

The pre-registered confirmation finished on 11 October: 12 fresh sealed pairs, 24 labs, a mean gain of 9.7 points and p = 0.133. This positive estimate did not meet the 0.05 threshold, so the candidate was not promoted. Transfer to unseen families remains inconclusive; the result does not show that the benefit is zero.

Candidate − v1PairsMean changeOne-sided p
Public selection12+16.80.023
Initial sealed transfer2−10.5Not a significance test
Fresh sealed confirmation12+9.70.133

Percentage-point changes in the fraction of possible discoveries, using the corrected bounded metric. Selection and confirmation p-values come from exact one-sided paired sign-flip tests; initial transfer used a −3-point mean threshold. All 28 initial labs and all 24 confirmation labs had clean audits, passed the kernel check and recorded no failure. Decision on 11 October: not promoted.

Read the earlier dated results, corrections and limitations

The measurement rules

The question is not “does the agent look like a scientist?”. It is “did it find something true that it did not already know, more cheaply than a simple method would have?”. Each rule closes a way of fooling ourselves.

The eight measurement rules
  1. The kernel decides, never the explorerA finding counts only with a certificate the Lean kernel accepts. A refutation needs a concrete counterexample. Model confidence, citations and fluent explanations count for nothing.
  2. Worlds nobody has seenKnown results, such as the elementary automata or textbook physics, are for calibration only, because a model may have memorised them. Scored worlds are generated and disguised.
  3. A complete hidden answerFor each scored world the complete answer is computed exactly. Recall is measured against it, so silence and false leads both show up.
  4. Nothing trivial countsConstants and discrete gradients are conserved by every rule, so they are excluded. A discovery counts for the rank it adds to what is already known, not for the number of claims.
  5. Equal cost, boring baselines includedEvery explorer pays one unit per proposal. The comparison always includes random search, exact data fitting and the oracle. An AI that does not beat exact data fitting at equal cost has not shown that it discovers.
  6. Meter access to the worldSimulation is the experiment. Without metering it, brute force looks free and wins every benchmark. The labs count cell updates next to proposals, and model tokens with the cost.
  7. Cumulative value is measuredMemory is useful only when the run with the library beats the cold run, at the same budget, on held-out worlds.
  8. Negative results are publishedEvery run writes its verdicts, including refutations and invalid proposals. Dated summaries include the results that go against us.

What a positive result has to look like

“Mutome can discover” will mean all of the following, on worlds generated after the system was frozen:

  • recall above exact data fitting and random search at equal metered cost, with every finding kernel-checked;
  • a gain from the library on held-out worlds: earlier results make later ones cheaper;
  • the same result over several suite seeds, with the spread published.

The real world offers no complete hidden answer. There the score becomes prospective: predictions registered before the data that settles them exists, with the evaluation rule fixed in advance.