Machinidae working draft · era 2 · 16 of 16 runs in
Era 2 · results, built from the record

The model's lineage beat blind rules. The same model, asked alone, did better.

Eras 0 and 1 asked whether a model's lineage does better than blind rules, and both times it did not. Their founders had one knob, and a near-miss was lethal, so every gain in every arm was the knob turned finer. Era 2 starts from PM-1, a founder written by hand with no knob, where a layout that fails costs nothing. Five arms share one physics and one training set in every run. The lineage has Qwen3.6 rewrite functions under selection. Blind rules and blind tree edits make the same rewrites with no model. The 7B's lineage uses the small model of eras 0 and 1. The AI alone is Qwen3.6 asked for whole programs, as many as the lineage's written tokens buy. The line to cross is 0.20516 on the panel, the ceiling of the founder's grid.

Under the same selection and births, the model's lineage beat blind rules by 0.0103, higher in sixteen of sixteen runs (p = 1/65536): by more than the 0.003 margin in eight, and in six by less than 10⁻⁹, both champions still on the founder's grid. In ten of sixteen runs its champion left the founder's design, certified exactly; the rules' did in none. The same model asked alone for whole programs, at the lineage's written tokens, did better still, by 0.0136, and crossed in fourteen.

16/16confirmatory runs in, named before the first began; none is replaced or dropped
10 of 16runs whose lineage champion left the founder's design; blind rules', none
1/65536H2's exact p, over all 65,536 ways to flip the signs
H2 · the lineage against blind rules
the lineage's champion higherthe blind rules' champion highermean of the runs in, +0.01033
era-2-1
era-2-2
era-2-3
era-2-4
era-2-5
era-2-6
era-2-7
era-2-8
era-2-9
era-2-10
era-2-11
era-2-12
era-2-13
era-2-14
era-2-15
era-2-16
−0.10−0.050+0.05+0.10
← the blind rules' champion higherthe lineage's champion higher →
S1 · the lineage against the same model asked alone
the lineage's champion higherthe AI alone's champion highermean of the runs in, −0.01357
era-2-1
era-2-2
era-2-3
era-2-4
era-2-5
era-2-6
era-2-7
era-2-8
era-2-9
era-2-10
era-2-11
era-2-12
era-2-13
era-2-14
era-2-15
era-2-16
−0.04−0.020+0.02+0.04
← the AI alone's champion higherthe lineage's champion higher →
Plate I. Both comparisons, run by run, in the sixteen runs named in advance. Above, dᵢ is the lineage champion's panel score minus the blind rules', the primary endpoint (median +0.00650); below, minus the AI alone's (median −0.01187). A lane with no mark, hatched and marked ∅, is a run not yet in.
Plate II

Every arm's champion, and the line to cross.

Each run is one lane. An arm's champion is its child with the best certified training score in the run; the panel then scores it once, on eight instances never used for selection. The dotted tick is the founder, designated and not selected; the guide line is 0.20516, the ceiling of the founder's grid.

lineageblind rulesblind tree editsthe 7B's lineagethe AI alonethe founder, designated (chosen)the ceiling (a guide)
era-2-1
era-2-2
era-2-3
era-2-4
era-2-5
era-2-6
era-2-7
era-2-8
era-2-9
era-2-10
era-2-11
era-2-12
era-2-13
era-2-14
era-2-15
era-2-16
era-2-pilotnever tested
0.180.200.220.24
score on the frozen panel (mean sum of radii, normalized), higher is better
Plate II. Each arm's final champion on the frozen panel, per run. The pilot is drawn below the line and is never tested.
The tests, fixed in advance

One primary test, three gated behind it.

H2 is the exact sign-flip test on the sum of the sixteen differences, against all 65,536 ways of flipping their signs. Its verdict is read from the exact 90% interval for the mean shift, with an equivalence margin of 0.003. S1 to S3 were tested only because H2 was supported, under Holm's correction. E is an existence claim: one champion above the ceiling, certified exactly by both deciders, is proof that a lineage left its founder's design.

Hypothesisdifferencemeanmedianp, exact90% intervalverdict
H2 The lineage's champion (Qwen3.6) scores higher on the panel than blind rules', run for run.panel(lineage) − panel(rules)+0.01033+0.006501/655360.0000+0.00371 to +0.01830supportedsuperior
S1 The lineage's champion scores higher than the same model's asked alone: evolution adds to the model.panel(lineage) − panel(AI alone)−0.01357−0.0118732767/327681.0000−0.01741 to −0.00972not supportedthe AI alone betterHolm
S2 The lineage's champion scores higher than the 7B's lineage: model strength matters under selection.panel(lineage) − panel(7B)+0.00622+0.005561/10240.0010+0.00338 to +0.00898supportedsuperiorHolm
S3 The lineage's champion scores higher than blind tree edits': the step needs the model.panel(lineage) − panel(tree)+0.00576+0.001883/655360.0000+0.00289 to +0.00859supportedsuperiorHolm
E A lineage champion stands above the ceiling of the founder's design, certified exactly.panel(lineage) > 0.2051610 of 16 runs+0.01111, +0.00143, +0.00187, +0.01111, +0.01111, +0.01111, +0.01111, +0.01111, +0.02027, +0.00187supportedexistence
armchampion above the ceiling, certified by both deciders
lineage10 of 16
rules0 of 16
blind tree edits0 of 16
the 7B's lineage0 of 16
the AI alone14 of 16
What evolution did, in era-2-4

The champion, generation by generation.

The run drawn here is the first, by name, whose lineage champion crossed the ceiling. The lineage's champion, LQ-40-1, is 22 inherited edits from the founder, 8 of them rewrites by the model and the rest by blind rules; every AI-alone child is one answer about the founder.

lineageblind rulesblind tree editsthe 7B's lineagethe AI alonethe founder, designated (chosen)
0.2100.2150.2200.2250.230
the AI alone 0.22628lineage 0.21983the 7B's lineage 0.21320rules 0.21320blind tree edits 0.21320
0255075100
Plate III. Each arm's champion after every generation, by training score. A step is a new champion.
The lineage's champion, edit by edit
  1. gen 0
    PM-1PM-1, written by hand
    training 0.21320
  2. gen 2
    LQ-2-8insertion, line 76 of main.py
    + X, Y = [round(x * D) for x, _, _ in p], [round(y * D) for _, y, _ in p]
    training 0.21320
  3. gen 5
    LQ-5-13rewrite of a function, line 60 of main.py
    + R = [math.floor(lam * r * D) for _, _, r in p] + if feasible(X, Y, R, h): + return [X, Y, R]
    training 0.21320
  4. gen 12
    LQ-12-12duplication, main.py
    + modules/sense.py: a byte-for-byte copy of sense()
    training 0.21320
  5. gen 13
    LQ-13-4rewrite of a function, line 118 of main.py
    - 'forecast': [float(best) * (1 - 1e-6), float(best) * (1 + 1e-6)]}) + 'forecast': [float(best) * (1 - 1e-4), float(best) * (1 + 1e-4)]})
    training 0.21320
  6. gen 14
    LQ-14-9duplication, main.py
    + modules/decimal.py: a byte-for-byte copy of decimal()
    training 0.21320
  7. gen 15
    LQ-15-11rewrite of a function, line 41 of main.py
    - """a spare copy of the square grid: free to change, judged as a candidate of its own""" - return [[side * (k % cols + 0.5), side * (k // cols + 0.5), side / 2] for k in range(n)] + """a spiral-like layout: centers on a hexagonal grid, shifted to fill the box""" + hex_h = side * math.sqrt(3) / 2 + centers = [] + for r in range(rows): … 8 more lines
    training 0.21983
  8. gen 16
    LQ-16-0point mutation, line 84 of main.py
    - p = [(s * x + dx, s * y + dy, s * r) for x, y, r in c] + p = [(s * x + dx, s * y + dy, s / r) for x, y, r in c]
    training 0.21983
  9. gen 17
    LQ-17-6rewrite of a function, line 1 of modules/sense.py
    - with open('/in/niche.json') as f: - return json.load(f) + with open('/in/niche.json', 'rb') as f: + return json.loads(f.read())
    training 0.21983
  10. gen 19
    LQ-19-8insertion, line 7 of main.py
    + y0, y1 = min(y - r for _, y, r in c), max(y + r for _, y, r in c)
    training 0.21983
  11. gen 23
    LQ-23-15point mutation, line 9 of main.py
    - multiples of 10^-12, and checks every inequality exactly, in integers, before it lets a candidate out. It forecasts + multiples of 20^-12, and checks every inequality exactly, in integers, before it lets a candidate out. It forecasts
    training 0.21983
  12. gen 24
    LQ-24-0deletion, line 1 of modules/sense.py
    - def sense(): - with open('/in/niche.json', 'rb') as f: - return json.loads(f.read())
    training 0.21983
  13. gen 25
    LQ-25-6rewrite of a function, line 1 of modules/decimal.py
    - return f'{v // D}.{v % D:012d}' + sign = '-' if v < 0 else '' + v = abs(v) + integer_part = v // D + fractional_part = v % D … 1 more lines
    training 0.21983
  14. gen 27
    LQ-27-3duplication, main.py
    + modules/fit.py: a byte-for-byte copy of fit()
    training 0.21983
  15. gen 29
    LQ-29-8insertion, line 102 of main.py
    + break
    training 0.21983
  16. gen 31
    LQ-31-11deletion, line 27 of modules/fit.py
    - if feasible(X, Y, R, h): - return [X, Y, R]
    training 0.21983
  17. gen 33
    LQ-33-5point mutation, line 26 of modules/fit.py
    - R = [math.floor(lam * r * D) for _, _, r in p] + R = [math.floor(lam * r / D) for _, _, r in p]
    training 0.21983
  18. gen 34
    LQ-34-5point mutation, line 150 of main.py
    - 'forecast': [float(best) * (1 - 1e-4), float(best) * (1 + 1e-4)]}) + 'forecast': [float(best) / (1 - 1e-4), float(best) * (1 + 1e-4)]})
    training 0.21983
  19. gen 35
    LQ-35-3rewrite of a function, line 36 of main.py
    - """n equal circles, one in each cell of the grid""" - return [[side * (k % cols + 0.5), side * (k // cols + 0.5), side / 2] for k in range(n)] + """n equal circles, one in each cell of the grid, shifted by a small random offset to break symmetry""" + import random + # Use a deterministic seed based on n and h to ensure reproducibility across runs + seed_val = n * 1000 + int(h * 100) … 4 more lines
    training 0.21983
  20. gen 37
    LQ-37-13rewrite of a function, line 77 of main.py
    - p = [(s * x + dx, s * y + dy, s / r) for x, y, r in c] - for i in range(n): - X, Y = [round(x * D) for x, _, _ in p], [round(y * D) for _, y, _ in p] + if x1 == x0 or y1 == y0: + return None + p = [(s * x + dx, s * y + dy, s * r) for x, y, r in c]
    training 0.21983
  21. gen 38
    LQ-38-0deletion, line 110 of main.py
    - """the layout genes: this file's, then each layout* function in modules/, file by file"""
    training 0.21983
  22. gen 39
    LQ-39-0duplication, main.py
    + modules/feasible.py: a byte-for-byte copy of feasible()
    training 0.21983
  23. gen 40
    LQ-40-1rewrite of a function, line 36 of main.py
    - dx = rng.uniform(-side * 0.1, side * 0.1) - dy = rng.uniform(-side * 0.1, side * 0.1) + dx = rng.uniform(-side * 0.05, side * 0.05) + dy = rng.uniform(-side * 0.05, side * 0.05)
    training 0.21983
Plate IV · descriptive

The founder and the champions, inside and out.

Above, each form: its genome laid out by one page of rules, ringed in blue where it changed since the founder and filled blue where it grew something new. Below, its packing of (26, 1), scored exactly. The founder's grid stops at 0.20516.

Open the Museum

keptchanged since the foundernew: not in the founderlost: a ghost
decideda champion's frame: in the record, judged exactlychosenthe founder's frame: designated, not selected
the founderPM-1score 0.18056
the blind rules' championR-63-12score 0.18056
the 7B's lineage's championL7-9-11score 0.18056
lineage's championLQ-40-1score 0.21488
the AI alone's championDQ-6score 0.21488
Plate IV. From era-2-4.
Plate V

How far the births got.

Counted over the sixteen confirmatory runs in. Every rewrite by the rules or by the tree also had to compile and be one function of the same name; a child whose program was already judged in the run carried that decision instead of living again.

liveddiedstillborn
lineage
52.7% lived · 10.2% died · 37.1% stillborn
rules
44.5% lived · 14.9% died · 40.6% stillborn
blind tree edits
44.4% lived · 20.5% died · 35.1% stillborn
the 7B's lineage
45.5% lived · 11.6% died · 43.0% stillborn
the AI alone
58.4% lived · 13.9% died · 27.7% stillborn
Plate V. The share of each arm's births that lived, died or were stillborn. The AI alone's births are as many as the lineage's written tokens bought.
armbirthsliveddiedstillborncarriedmodel tokensfuel
lineage25,60013,4802,6219,49913523,613,1722.81 × 10¹³
rules25,60011,3913,82110,3877102.71 × 10¹³
blind tree edits25,60011,3775,2428,9818103.08 × 10¹³
the 7B's lineage25,60011,6422,95711,00111722,058,3142.67 × 10¹³
the AI alone231135326401,694,8473.24 × 10¹²
Protocol §12 · exploratory, labelled so

Where the steps were, and what carried them.

Three readings of the record that the protocol names and does not test: the landscape of tree-edit distance against fitness, knockouts on the champions that crossed, and a flag for layouts that are a literal table of coordinates. Nothing here was pre-registered; nothing here is a test.

lineageblind rulesblind tree editsthe 7B's lineagethe AI alone
−0.04−0.020+0.02+0.04
01000200030004000
tree edit distance from PM-1 (single-node edits) →↑ training gain over the founder
Plate VI. Each arm's sixteen parents after generation 100, in every confirmatory run: how far their trees stand from PM-1 (the fewest single-node relabellings, deletions and insertions that turn one tree into the other, exact) against their training gain over the founder. The AI alone's answers are whole programs, drawn at their distance; an answer more than 0.02 under the founder sits at the lower edge, hollow. A point can hold several parents; its tooltip counts them. The parents of earlier generations were not measured: at 10 to 70 seconds a pair they are days of one machine.
Each child against its parent
armoperatorlivedmedian distancemaxbetter than the parentthe sameworse
lineagepoint mutation2,405110.7%74.7%24.5%
lineageinsertion2,8286720.0%94.3%5.7%
lineagedeletion1,77191400.5%91.5%8.0%
lineageduplication2,708984620.0%100.0%0.0%
lineagerewrite of a function4,597121771.2%88.5%10.4%
blind rulespoint mutation2,442111.5%82.8%15.7%
blind rulesinsertion2,7085580.0%99.3%0.7%
blind rulesdeletion1,64991660.6%99.0%0.4%
blind rulesduplication2,664674510.0%100.0%0.0%
blind rulesrewrite of a function2,65292230.2%94.8%5.1%
blind tree editspoint mutation2,532111.0%83.3%15.7%
blind tree editsinsertion2,6595580.0%99.8%0.2%
blind tree editsdeletion1,66691790.7%99.1%0.2%
blind tree editsduplication2,539705710.0%100.0%0.0%
blind tree editsrewrite of a function2,706112400.0%97.7%2.3%
the 7B's lineagepoint mutation2,377110.4%82.3%17.3%
the 7B's lineageinsertion2,6935640.0%99.4%0.5%
the 7B's lineagedeletion1,73991960.5%99.0%0.5%
the 7B's lineageduplication2,634704590.0%99.9%0.1%
the 7B's lineagerewrite of a function2,914191501.1%87.9%11.0%
The steps: a new champion by training score
armstepsruns with onemedian jump from the parentmaxmedian distance from PM-1final champion's median distance
lineage5617 of 1712123227830
blind rules3917 of 171523101113
blind tree edits3014 of 17164276633
the 7B's lineage2717 of 171266104104

The AI alone: 143 answers lived, median 707 edits from PM-1 (max 1680). Distances and fitness are in strata/era-2.landscape-2026-10-26.json; a distance of 1 is one node changed.

Knockouts

In 22 of 25 champions, one unit carries the crossing.

Each champion that crossed the ceiling was taken apart one unit at a time: a function of main.py that PM-1 also has was swapped for PM-1's, a function PM-1 does not have had its body replaced by a raise, and a file in modules/ was removed. Each knockout lived once on the panel, under era 2's budget and the run's seed, judged by decision/2, on one machine. Every champion lived there first as the control: 25 of 25 scored the record's panel score to the last digit on the same fuel. A unit "carries the crossing" when the champion falls to or under the ceiling without it; "contributes" when it scores less but stays above; "held it back" when the champion scores more with PM-1's version.

The recall flag: 243 layout genes read across the 25 champions, none with a literal table of coordinates (the rule: a list or tuple display of at least 12 numbers, or at least 4 nested rows of 2 or 3). None of the champions is a table; each computes its layout.

runarmchampionpanelcarries the crossingcontributesheld it backno effectdies without
era-2-1the AI aloneDQ-20.22702hex_grid(), layouts()fit()—2—
era-2-3the AI aloneDQ-20.22431hex_layout()—fit()4score_candidate(), main()
era-2-4the AI aloneDQ-60.22702hexagonal(), main()——1—
era-2-4lineageLQ-40-10.21627layout()fit()—7—
era-2-5lineageLQ-82-40.20659layout()fit()layouts()11—
era-2-6the AI aloneDQ-20.22950hex_lattice(), main()——1—
era-2-6lineageLQ-34-10.20703layout()—fit()8—
era-2-7the AI aloneDQ-60.22702hexagonal(), layouts()——4—
era-2-7lineageLQ-35-30.21627layout()fit()—5—
era-2-8the AI aloneDQ-40.22926hex_layout(), main()——1—
era-2-8lineageLQ-50-130.21627layout()fit()—9—
era-2-9the AI aloneDQ-30.22431hexagonal_layout(), main()fit()—1—
era-2-9lineageLQ-74-80.21627—layout(), fit()—14—
era-2-10the AI aloneDQ-40.22702hex_layout(), main()——1—
era-2-10lineageLQ-80-00.21627modules/layout.pyfit()—14—
era-2-11the AI aloneDQ-90.23247—hex_layout(), fit()—2optimize_layout(), layouts()
era-2-12the AI aloneDQ-30.22702hexagonal(), main()fit()—1—
era-2-13the AI aloneDQ-80.22317local_search(), main()perturbed_grid(), random_restart_local_search()—0—
era-2-13lineageLQ-59-30.21627layout()fit()—12—
era-2-14the AI aloneDQ-20.22702hexagonal(), main()——2—
era-2-15the AI aloneDQ-00.22926hex_grid(), main()fit()—2—
era-2-15lineageLQ-95-10.22543—layout(), fit()—18—
era-2-16the AI aloneDQ-60.22702hex_grid(), main()fit()—2—
era-2-16lineageLQ-74-50.20703modules/layout_2.py—fit()17—
era-2-pilot (pilot)lineageLQ-46-120.21627modules/layout.pyfit()—9—

From strata/era-2.knockouts-2026-10-26.json.

After era 2

What era 3 should ask.

Era 2 found structure that blind rules and blind tree search did not, and found it only where the stronger model wrote the rewrites. It also found that the same model, asked alone for whole programs, did better than its own lineage. These are proposals; nothing below is fixed until its protocol is written, hashed and timestamped before generation one.

  • Selection over whole programs. The AI alone wins with a dozen answers a run. A lineage whose rewrite is the whole program, under the same selection, would ask whether heredity adds anything to what the model already writes in one answer.
  • Steps after the first. Six of the ten lineage champions that crossed score the same on the panel to nine digits, 0.216272380, and only one went further. The landscapes above (Plate VI and the steps table) say what came after: the crossing step was one rewrite 50 to 123 edits from its parent, a layout written whole in one answer, and every later step of the lineage gained at most +0.0023 in training score. A second large step was never drawn in 1,600 births a run.
  • Units and habilis. Modules as content-addressed units, so a layout gene found once can be reused by name.
  • The island file system. Lives that make millions of file calls sit near the host's wall-clock guard, because each call is answered in Python. A faster island, at an era boundary, takes them away from it.
The runs

Every run is reported. None is replaced or dropped.

A run's name is its seed. Each run's head is timestamped on Bitcoin through OpenTimestamps when it comes in. The sign-blind rule, which sees the sizes of the differences and never their signs, kept the era at sixteen runs.

Every run was replayed on the pod that wrote it, one model answer in ten asked again: thirteen of sixteen reproduce every line. In the other three, one life each differs, every one a life of millions of file calls near the host's 300-second wall-clock guard, which is not part of the physics: two met it in the replay and reproduce when relived alone, and one, the era's only quarantine, met it in the run itself and meets it again alone. No line that selection, a champion or the summary depends on differs. Away from home, era-2-1 replays every line from a fresh copy on a machine that did not write it. strata/era-2.replay-2026-10-26.json

runstaterecordsheadhead timestamp
era-2-1complete14,678b4f8d42dae2ec221…timestamped
era-2-2complete14,756267ddead681bf7d8…timestamped
era-2-3complete14,703dbfdd01317571e14…timestamped
era-2-4complete14,477ce1ea4e4f0c3269f…timestamped
era-2-5complete14,6210293faeff1fb5b04…timestamped
era-2-6complete14,572ab87852a373a85ad…timestamped
era-2-7complete14,734aa1c59ebe0647c27…timestamped
era-2-8complete14,649d693d205a95437e5…timestamped
era-2-9complete14,54425e741909314d1d1…timestamped
era-2-10complete14,681c0871b7eecfbad13…timestamped
era-2-11complete14,734427382f177eeca9e…timestamped
era-2-12complete14,510d3be7570aa0623f2…timestamped
era-2-13complete14,985cc99cea3d82fd634…timestamped
era-2-14complete14,71917c935b3aef7d622…timestamped
era-2-15complete14,771d77867d5172484fe…timestamped
era-2-16complete14,609fcac56c50bb074f4…timestamped
era-2-pilotcomplete14,595953f227ec6c1ef1e…timestamped