Cadence Lab Atlas · reflections EXP-01 to EXP-62c

Small brains, learning to teach each other

We grow small Cadence brains and ask whether one can measurably teach another, and whether the worth of that teaching can be priced from outcomes instead of from what the brain looks like inside. The goal is a market that pays for teaching ability passed down generations, where credit follows the lineage of what was learned. This atlas collects every reflection so far, the wins and, just as proudly, the nulls, voids and our own retracted mistakes.

experiments logged

CROSSED: claim met

NULL: no visible effect

VOID or RETRACTED

experiments where we caught our own bug

28 SUPPORTIVE, 5 SUPERSEDED, 10 BOUNDARY make up the rest. Verdicts are the current ones after reruns; several experiments changed verdict when we found bugs, and those stories are kept below.

Storyline

Every experiment in run order (left to right, by first run date: 2026-10-07 to 2026-10-17; several were rerun later), one row per research track. Hover a dot for its headline, click or press Enter to pin the details. The program moved from can we price a witness (attribution) through a long XOR dead end, into the teaching game, generations, networks and finally attacks on the market.

CROSSED milestone claim met on corrected numbers
SUPPORTIVE points the right way, not a milestone
BOUNDARY a limit, stated with a number
NULL no effect, or the effect could not be seen
SUPERSEDED replaced by a later, better experiment
VOID never produced usable data
RETRACTED the original claim was our bug

In the storyline and verdict chips, filled dot: a result that currently stands. Hollow ring: no standing positive result (null, void, retracted, or replaced by a later run).

Scroll the chart sideways to see all 63 experiments.

Click a dot to see its headline here.

What we know

The 4 CROSSED findings: claims that met their milestone on corrected numbers. Each carries its scope note; none of them is a proof, and most were run on small bandits with a handful of seeds. Blue bars are positive, red negative; whiskers are one standard error where we have it.

EXP-08CROSSEDattribution (M1-M5)

Transfer separates genuine from fake witness

Where interior scoring saw 0.0% difference, transfer split them cleanly: the genuine witness gained +0.422 on the held-out task while the surface-matched random fake scored -0.109.

Transfer to held-out task T by witness type (iter8, 16 seeds) · accuracy change on T

Scope: Program milestone M1, on the corrected-eval iter8 numbers; iter1/iter2 numbers are superseded but the verdict held and got stronger. Scope: surface-matched fake only, small bandit, exogenous T. Effect is at ceiling; the informative contrast is fake_random.

EXP-10CROSSEDattribution (M1-M5)

Per-mind worth attribution in mixed collaboration

Inside a single collaboration, transfer credited genuine minds +0.375 on average and docked fakes -0.479, a +0.854 attribution gap.

Per-mind transfer within one collaboration (iter8, 12 seeds) · transfer on own block

Scope: M2 additive half, on corrected iter8 numbers; iter5 superseded (verdict held and strengthened). Additive per-node attribution only; linearity largely by construction; XOR-style synergy still open.

EXP-33CROSSEDteacher networks

Fixing forgetting lifts the network ceiling

The plateau was stale teaching, not brain size: notes plus drift-check lifted network knowledge from 0.790 to 0.991, while doubling the brain only reached 0.816.

Final network knowledge by fix (6 seeds) · final knowledge

Scope: Prediction confirmed and exceeded: both reached 0.991, not just 0.95; big brain alone barely moved. Still current; became the base world for EXP-34 FIX, EXP-35, EXP-35b, EXP-36.

EXP-37CROSSEDattribution (M1-M5)

Weight change cannot price a lesson

A lesson teaching the opposite rule moved weights almost as much as a genuine one (2.443 vs 2.585) while worth differed by 1.0; correlation of weight change with worth was -0.02.

Weight change (L2 norm) by lesson type (16 seeds) · dW (L2 norm)

Scope: CROSSED for the worth-blind claim; the pre-filter part only SUPPORTIVE (noise moves weights less on average, not reliably: seed 14). Still current.

Also standing, at lower confidence: EXP-11, EXP-13, EXP-15, EXP-16, EXP-17, EXP-18, EXP-19, EXP-20b, EXP-21, EXP-22, EXP-26, EXP-27, EXP-28, EXP-29, EXP-30, EXP-34, EXP-35b, EXP-36, EXP-38, EXP-39, EXP-42, EXP-43, EXP-45, EXP-46, EXP-47, EXP-48, EXP-49, EXP-52, EXP-57, EXP-55, EXP-60, EXP-58, EXP-59, EXP-61, EXP-63, EXP-65, EXP-62, EXP-62c. Open them in the index below.

Hall of nulls and mistakes

Every reflection tags what went wrong in the process. These tags are how the lab learns: most recurring failures became a line of the RUN GATE we now check before any experiment (in VS-TRANSFER-PROGRAM.md); the Status column says which are still only lessons. Counts are experiments carrying the tag; one experiment can carry several. EXP-37 and EXP-39 and EXP-42 and EXP-45 and EXP-46 and EXP-47 and EXP-48 and EXP-52 and EXP-53 and EXP-54 and EXP-57 and EXP-55 and EXP-60 and EXP-58 and EXP-59 and EXP-61 came back with no tag at all.

Process issues across 63 experiments · experiments with this tag

The honest pile

Nulls, voids and retractions. Each one narrowed the search.

EXP-01	RETRACTED	Arousal gene sweep on reward flip
EXP-12	NULL	Synergy-harness smoke: copy tasks and XOR
EXP-12b	NULL	XOR ceiling search over depth and width
EXP-12d	VOID	Settle-budget sweep for credit starvation
EXP-12e	NULL	Is deep-XOR zero an inverted readout
EXP-14	NULL	Supervised XOR on the equilibrium substrate
EXP-14b	NULL	Deep XOR supervised with ample settling
EXP-20	VOID	Teacher brains learning from Shapley credit
EXP-23	NULL	Selecting parents by teaching vs doing
EXP-24	NULL	Calibrating key-door grading strategies
EXP-25	NULL	The memory door
EXP-31	NULL	Peer gossip vs one-way ring
EXP-44	NULL	Graded text: the readout's operating point or the brain's size?
EXP-53	NULL	Does the content of a teacher's labels matter?
EXP-54	NULL	Does teaching only where the answer differs let a label's content through?
EXP-56	NULL	On an ambiguous chain, do misses wash the memory that matters out of Cadence's context?

From mistake to rule

Issue	Count	What we do now	Status	Learned in
under-powered	29	Power the run for the pilot's effect size; one run per arm shows direction, not rank.	lesson (EXP-27), part of RUN GATE line 2 (seeds are a window knob)	EXP-27
at ceiling	17	Pilot finds the effect window: sweep the key knob under the exact run conditions; the chosen value must sit away from 0% and 100%.	RUN GATE line 2: WINDOW	EXP-24
bug in script	11	When a result looks better (or worse) than expected, audit the eval and accounting path first; dump raw actions before theorising.	lesson (EXP-01, EXP-12e, EXP-36)	EXP-36
metric gameable	7	The score must not be passable by a degenerate policy (do-nothing twin, None scored as wrong, identities by construction).	RUN GATE line 4: METRIC	EXP-19
stale records	6	Every experiment gets a reflection: experiments/EXP-XX.md with Summary + Reflection, nulls, voids and reruns included; check.py must pass.	rule, Will 2026-10-10	EXP-20
pilot != run conditions	6	A smoke test (does it run) is not the pilot. Name the chain knob -> signal -> estimate -> choice -> outcome and print every link per arm.	RUN GATE line 5: CHAIN	EXP-35
nothing varied	5	Confirm the thing being selected or compared actually varies before running.	RUN GATE line 3: VARIANCE	EXP-23
version drift	4	Keep each run's output instead of overwriting it, and stamp the library version.	lesson (EXP-09, EXP-36), not yet a gate line	EXP-09
effect window too small	4	Size the sweep to the time available; order cells so a timeout still leaves the decisive number.	RUN GATE line 2: WINDOW	EXP-12d
pilot mechanism (the calm trap) written into the revision before a healthy control; it did not hold up	1
a collapsed seed was stopped after pass 4; 6-pass baselines computed separately with the same code	1
live arms launched beside the full run oversubscribed the CPU	1
crash mid-run (unsettled brain); amended and resumed on a pinned version	1
genuine teacher skill did not vary as designed (training budget loosely sets skill)	1
one reading (retry repeats the miss) added after the pilot and declared; full run reran all seeds	1
one unpredicted cell (visible chain, corrective, stage-1 first try -.11, 3 SEM) not seen on EXP-60's 48 seeds for the identical rule; recorded, not claimed	1
first check failed one item scoped too wide (the library resets the context at done); rescoped and reported before the pilot	1
comparator arms are EXP-63 rows on the same seeds (recomputed identically), not fresh lives	1
the registered window rule picked lesson 40 over the predicted 80 (ceiling guard judged on 3 pilot students); 80 ran as a declared exploratory arm	1
the counterfactual flipped vs prediction (random-label null above untaught); the fixed pooled rule handled it	1
the label-information correlation and the anti-echo re-pricing are post hoc and labelled exploratory	1
the decision rule (every fake mean <= 0 against a single noisy fake) is a max-of-noisy-estimates test that fails by chance when fakes are equal in truth; recorded as a design flaw, verdict unchanged	1
the paired and pooled-zero reads are post hoc and exploratory	1

The single most common failure (about a third of failed runs, per the program log) was an effect outside the visible window: too small to see over noise, or so easy every arm hit 100%. Hence the rule: the pilot finds the effect window.

Verdicts by track

How each line of work has fared. The XOR track is mostly nulls and dead ends: from EXP-12 to EXP-14b the substrate never got off chance on XOR on any wiring tried, a clear negative for this substrate, not for XOR learning in general. Synergy was later shown by a different route (EXP-18, EXP-19, both SUPPORTIVE). Bar length is the number of experiments; hover a segment for the ones in it, or open the table view.

CROSSED milestone claim met on corrected numbers
SUPPORTIVE points the right way, not a milestone
BOUNDARY a limit, stated with a number
NULL no effect, or the effect could not be seen
SUPERSEDED replaced by a later, better experiment
VOID never produced usable data
RETRACTED the original claim was our bug

In the storyline and verdict chips, filled dot: a result that currently stands. Hollow ring: no standing positive result (null, void, retracted, or replaced by a later run).

Table view

Track	CROSSED	SUPPORTIVE	BOUNDARY	NULL	SUPERSEDED	VOID	RETRACTED	Total
library & tooling		1					1	2
attribution (M1-M5)	3	2	1		1			7
synergy / XOR		3		5	2	1		11
teaching game		12	2	4		1		19
generations & inheritance		2		1				3
teacher networks	1	1		1				3
market & attacks		2	4		1			7
pedigree share		1			1			2
language			2	1				3
memory		4	1	1				6

Surprises

The lines from the reflections that changed how we think, one per track to start. Many are about our own instruments rather than about Cadence.

The 'sub-1.0 post-flip cap' was not a property of Cadence's arousal dynamics; it was produced by our probe.EXP-01 · Arousal gene sweep on reward flip · library & tooling

Learning the wrong task perfectly (fake_wrong reaches 1.000 on its own rule) registers as negative worth (-0.578) on the task that matters.EXP-08 · Transfer separates genuine from fake witness · attribution (M1-M5)

The whole training effect was a single context flipping: the bandit started at 0.75 by chance.EXP-11 · Reinforcement substrate smoke test · synergy / XOR

The design needed 4 freshly trained students per round for 40 rounds, at roughly 870 to 1180 s per student, so it was too expensive to ever run as written.EXP-20 · Teacher brains learning from Shapley credit · teaching game

Label-taught children gave the parent's right answers when quizzed cold but kept pressing lamp and levers in a live trip: knowledge transferred, habit did not.EXP-22 · Generations: does skill pass brain-to-brain · generations & inheritance

The exponential-gossip intuition failed because knowledge was being lost about as fast as it spread.EXP-31 · Peer gossip vs one-way ring · teacher networks

Paid equalled measured gain exactly (13.031 / 13.031), but that was an accounting identity of the code, not a finding.EXP-32 · Minimal teaching market with learned choice · market & attacks

Royalty pay was credited to whatever move a brain made that round, so it mostly inflated the Teach estimate instead of rewarding discovery.EXP-35 · Pedigree share as a control dial · pedigree share

Asked to continue 'alice was ', the best graded brain said 'w w w w': in three passes it learned what a lookup table learns from the same grades, that space is common.EXP-42 · Learning text one character at a time from grades alone · language

The gain from keeping misses out showed up at the first try, not where I predicted it, after the misses.EXP-56 · On an ambiguous chain, do misses wash the memory that matters out of Cadence's context? · memory

50 more surprises

Transfer is not a threshold that zeroes out moderately-correlated fakes; it pays out in proportion to the real information a prior carries.EXP-09 · Transfer vs coordinated-but-wrong prior · attribution (M1-M5)

The proportional curve rises about one block per genuine mind, so its slope measures block size more than learning.EXP-10 · Per-mind worth attribution in mixed collaboration · attribution (M1-M5)

A below-chance 0.00 produced a plausible but wrong mechanism story because 'no answer' was scored as 'wrong answer'.EXP-12c · Does depth let the creature learn XOR · synergy / XOR

The printed 'flipped accuracy' of 1.00 looked like perfect inverted learning but was an artifact of a creature that never acted.EXP-12e · Is deep-XOR zero an inverted readout · synergy / XOR

Removing the blocker did not unlock learning: with ample settling the creature collapsed to always answering 0, an outcome neither pre-written branch anticipated.EXP-12f · More settling budget for deep XOR · synergy / XOR

Going from 64 to 32 sweeps barely changed time (18.8 vs 17.9 ms), suggesting the budget above that was simply unused.EXP-13 · Profiling the settle bottleneck · library & tooling

Width barely mattered: the same seed gave nearly identical predictions at 4, 6 and 12 patches.EXP-14 · Supervised XOR on the equilibrium substrate · synergy / XOR

Seed 11's predictions (0.08/0.40/0.55/0.85) are almost exactly additive: 0.08 + 0.32 + 0.47 = 0.87 versus 0.85 observed, where XOR wants 0/1/1/0.EXP-14b · Deep XOR supervised with ample settling · synergy / XOR

Transfer's immunity to ring capture is fully by construction here: the transfer arm never reads c.EXP-15 · Peer prediction vs transfer, same ring · attribution (M1-M5)

The variation under relabeling came from the instrument's own prior, not from the measure reading labels, and a paired reference cancels it.EXP-16 · Isomorphism invariance of transfer · attribution (M1-M5)

Transfer does not escape the exogenous-anchor problem; it just moves the anchor from peers to tasks.EXP-17 · Task-pool capture boundary · attribution (M1-M5)

The fake key alone (+0.115) scored higher than the genuine key alone (+0.062), a visible noise floor.EXP-18 · Key/lock secret-share synergy · synergy / XOR

In the first run, a do-nothing null twin passed on 4 of 12 seeds and the fake key alone scored 1.00 on 3, because the metric rewarded interacting with everything.EXP-19 · Teamwork credit on key-door world · synergy / XOR

The 'converged 12/12' headline hid that the greedy end policy was key/door in only 10/12 runs, and Shapley's 'fastest' median (39 vs 47 vs 54) sits inside a 0-to-120-round spread.EXP-20b · Learning teachers play the lesson game · teaching game

Key plus null trips solved the task for 2/12 students, while key plus key, twice the key practice, solved it for none.EXP-21 · Measured lesson payoff table · teaching game

The child failures that looked like bad teaching turned out to be bad student seeds, the same slots failing in both arms under different parents.EXP-23 · Selecting parents by teaching vs doing · generations & inheritance

Harsh, soft, floorless or drill-heavy grading made no difference at all; only reward strength mattered, and only when weak.EXP-24 · Calibrating key-door grading strategies · teaching game

More training made it worse: 1000 trips gave a 0.33 mean, 3000 trips gave 0.00 for every founder.EXP-25 · The memory door · teaching game

At high focus every student landed exactly on 0.6875 with zero spread, the teacher's own accuracy: students cannot out-learn the teacher they are graded against.EXP-26 · Tutor focus on the student's mistakes · teaching game

Doing selects teaching: a child's own score already carries its parent's teaching, so selecting on doing beat selecting on teaching directly.EXP-27 · Evolving tutors: doing vs teaching selection · generations & inheritance

Over-teaching hurt: taught students fell from 8/8 to 5/8 at 600 trips, later confirmed by EXP-30.EXP-28 · Teacher vs world on key-door · teaching game

Knowing the limits of your own knowledge is a teaching skill worth about 0.2 accuracy: overconfident teachers cancel each other out and the student lands near what one teacher alone gives.EXP-29 · Two partial teachers, one student · teaching game

Past a point, more teaching destroys learning: the pass count dropped monotonically 8, 5, 2, 1 out of 8 as the teaching budget grew.EXP-30 · Over-teaching: more grading hurts students · teaching game

The provenance record that pedigree pay needs is the same record that stops knowledge rotting.EXP-33 · Fixing forgetting lifts the network ceiling · teacher networks

Even with the need signal handed to it as input, the learned chooser picked the neediest peer only 0.25 of the time, no better than random at 0.27.EXP-34 · Can brains learn whom to teach? · teacher networks

It took three runs to get one valid answer: the first credited the wrong move, the second starved Discover of its own pay.EXP-35b · Pedigree share drives discovery (item credit) · pedigree share

A double-run lesson block made the original defence look better than it was: the claimed '.052 ledger cap' was a bug, the fixed rerun showed 0.151.EXP-36 · Colluders and fake need attack the market · market & attacks

In one seed a purely random lesson moved weights 3.89, more than any genuine lesson did.EXP-37 · Weight change cannot price a lesson · attribution (M1-M5)

The adaptive attacker blinded the detector completely and gained nothing: the rule, not the alarm, does the work.EXP-38 · Never re-teach a passed item · market & attacks

Starting the lessons next to the fire taught the brains to warm up and nothing else: the reverse curriculum caused the exact collapse it was meant to cure.EXP-39 · Teaching a 4-step prerequisite chain · teaching game

Graded right or wrong on every guess, all nine brains learned to say space. A teacher's judgement kept them off it, and a lookup table given that judgement beat a model that was told every answer.EXP-43 · Grades that judge the guess: learning text from a teacher's grades · language

Erase the brain's carried context before each decision and V5's best arm falls from .227 to .098: it was steering within an attempt, not following a learned chain.EXP-45 · Stone Age chain: is it the grade or the brain? (V5 replica) · teaching game

Without the memory the default brain's best full-chain numbers were search; with it, they are a chain.EXP-46 · 0.83's episodic memory on the Stone Age chain, read state by state · teaching game

Full-chain success said nothing changed after the caregiver left; the per-state reading showed a third of the perfect students had quietly lost a stage.EXP-47 · After the caregiver leaves: live vs step · teaching game

Twice the brain answered the same character in 88% of positions: more capacity, more collapse.EXP-44 · Graded text: the readout's operating point or the brain's size? · language

Records keyed by the whole situation, and still the chain held in weather the brain had never seen.EXP-48 · Does the episodic memory generalize the chain, or record it? · teaching game

A teacher who labeled at random earned two thirds of a genuine teacher's pay: it wasn't teaching the chain, it was knocking a stuck student loose.EXP-49 · Noesis-lite v1: a teacher market paid by measured transfer · market & attacks

A teacher who knew the whole chain was worth exactly as much as one who answered at random: the student was learning from the interruption, not the answer.EXP-52 · Noesis-lite v1.1: priced against a null of the same form · market & attacks

The student was learning from the interruption, not the answer, at every lesson length we tried.EXP-53 · Does the content of a teacher's labels matter? · teaching game

After a mistake the brain's own answer is usually the mistake, so a rule that skips lessons it already knows found almost nothing to skip.EXP-54 · Does teaching only where the answer differs let a label's content through? · teaching game

The memory that mattered was the decision that changed something; letting the misses in buried it under every way of failing.EXP-57 · Keep misses out of the temporal context: confirmed on fresh seeds · memory

Telling a student the right answer every time it already knew it made it worse than telling it nonsense.EXP-55 · Demonstrations at every decision, with and without upstream's surprise rule · teaching game

When the brain can see how far it has got, it does not need to remember, and the rule has nothing to fix.EXP-60 · The hold rule on the normal chain, where the inventory is visible · memory

Four nulls said labels carry no content; the fifth brain said they carry almost all of it.EXP-58 · A teacher's content finally gets through: the delayed-credit brain · teaching game

The rule could not tell a miss from a success it could not see.EXP-59 · Where the hold rule breaks: a correct action that changes nothing visible · memory

Change the path and nothing moves; change the brain and the teacher is heard.EXP-61 · It was the brain: the default memory brain blocks a teacher's content · teaching game

The idea held; the proxy broke.EXP-63 · Key the hold on the outcome: the gain stays, the invisible-action break goes · memory

The label is never wrong and rarely there; the forecast is always there and cannot see the difference.EXP-65 · The outcome gate on signals Cadence receives: the label is safe but sparse, the forecast error is blind · memory

The ladder held; the small story about the one miss did not.EXP-62 · Noesis-lite v2: transfer prices skill on a content-taking brain; the zero point is the best fake, not noise · market & attacks

The skill price replicated; the zero point turned out to be a band, not a line.EXP-62c · Fresh students, zero declared in advance: the skill price replicates; the zero point is a noise band · market & attacks

Every experiment

Expand any row for the question, verdict note, lesson, chart and a link to the full reflection file.

Verdict:

Track:

EXP-01Arousal gene sweep on reward flipRETRACTEDlibrary & toolingA 'Cadence can't hold a reversal' finding turned out to be our own probe bug: once probes reset properly, all 8 gene configs held at 1.000 instead of topping out at 0.719.

Question: Does any single arousal gene setting make a small Cadence brain recover and hold near 1.0 accuracy after the reward rule inverts mid-stream?
Dates: 2026-10-07 (first run), 2026-10-08 (corrected rerun) (none (pre-dates the V(S) program))
Verdict note: The first-logged 'REFUTED (coarse): no gene region stabilizes the reward-flip' was a measurement bug (GitHub #164, eval-protocol mismatch: no reset between probes). With the corrected eval all 8 configs hold at 1.000. Scope: this bandit only.
What it means: the "sub-1.0 post-flip cap" was not a property of Cadence's arousal dynamics; it was produced by our probe. On this 4-context bandit the default brain already re-learns the flipped rule to ceiling. We still do not know anything about which gene matters, because after the fix every config sits at 1.000 and the sweep cannot rank them.
Lesson: When a learner fails under a protocol, check that the eval episode structure matches the training episode structure (reset semantics) before blaming the mechanism, and audit the eval before sending a negative result to the library author.
Process tags: bug in script, at ceiling, under-powered, stale records
Evidence: Script: exp/EXP-01_arousal_gene_sweep.py (current, with #164 reset fix) and exp/EXP-01_arousal_gene_sweep.py.bak (original eval) | Evidence: exp/EXP-01.out (v0.75, original eval), exp/EXP-01-v078.out (v0.78 per its filename only, the file itself prints no version; timestamped 2026-10-08 13:39, before the script was patched at 21:47, so it is an original-eval run); the corrected 1.000 rerun has no saved output file, its numbers are recorded only in EXPERIMENT-RESULTS.md
Reflection: EXP-01.md

Post-flip hold: original eval (v0.75) vs corrected eval · mean greedy accuracy (6 seeds)

EXP-08Transfer separates genuine from fake witnessCROSSEDattribution (M1-M5)Where interior scoring saw 0.0% difference, transfer split them cleanly: the genuine witness gained +0.422 on the held-out task while the surface-matched random fake scored -0.109.

Question: Does measured transfer to an exogenous held-out task T separate a genuine witness from a surface-matched fake, where interior scoring gave 0.0% separation?
Dates: 2026-10-07 (iter1, iter2), 2026-10-08 (iter8 fixed rerun), reproduced 2026-10-09 and 2026-10-10 (iter1, iter2, iter5, iter8)
Verdict note: Program milestone M1, on the corrected-eval iter8 numbers; iter1/iter2 numbers are superseded but the verdict held and got stronger. Scope: surface-matched fake only, small bandit, exogenous T. Effect is at ceiling; the informative contrast is fake_random.
What it means: on this bandit, ingesting a witness that teaches the held-out task moves the twin toward T, and fakes with matched surface statistics do not (or move it away). Learning the wrong task fully (fake_wrong reaches 1.000 on T') registers as negative worth on T, so worth measured this way is task-specific. It does not show anything about interior-feature-matched fakes (M2), about where T comes from (M5), or about tasks that are not saturated.
Lesson: Once a measure saturates, separation numbers measure the baseline, not the mechanism; report which contrast still carries information. A 'probe is pure' check must match training episode semantics.
Process tags: bug in script, at ceiling, stale records
Evidence: Script: exp/EXP-08_vs_transfer_separation.py (current, #164 reset fix) and .py.bak (pre-fix eval) | Evidence: exp/EXP-08-iter1.out (K=4, pre-fix), exp/EXP-08.out (iter2, pre-fix), exp/EXP-08-fixed.out (iter8, current), exp/EXP-08-v080.out, exp/EXP-08-v080-19bee92.out (v0.80 reproductions)
Reflection: EXP-08.md

Transfer to held-out task T by witness type (iter8, 16 seeds) · accuracy change on T

EXP-09Transfer vs coordinated-but-wrong priorSUPERSEDEDattribution (M1-M5)The 'fakes earn nothing until 87.5% agreement' threshold was a bug; fixed, credit scales with real information, so a 62.5%-agreeing prior earns +0.125, about 27% of genuine credit.

Question: Does transfer still refuse credit to a fake whose prior agrees with T on a fraction gamma of contexts, past the peer-prediction crossover of about 0.70?
Dates: 2026-10-07 (iter3, iter4a, iter4b), 2026-10-08 (iter8 fixed rerun) (iter3, iter4, iter8 (superseded by iter9 / EXP-15))
Verdict note: Pre-fix claim 'coordinated fakes price to about zero below gamma 0.875' RETRACTED at iter8: credit rises roughly in proportion to agreement. M4 comparison replaced by EXP-15 (iter9), which found the gamma-vs-0.70 comparison was never like-for-like. Low-gamma half (0.0-0.5) still only pre-fix.
What it means: transfer credit tracks how much real T-information a prior carries, roughly proportionally; it is not a threshold that zeroes out moderately-correlated fakes. That is arguably the correct behavior (a 5/8-right prior carries real information), but it removes the "faking collapses into contributing only at about 90% agreement" story. What this experiment cannot say is how transfer compares to peer prediction; that needed a matched baseline (EXP-15).
Lesson: Compare two mechanisms only on the same adversary and the same axis; a borrowed number from a different mechanism is not a baseline. Keep each run's output instead of overwriting it.
Process tags: bug in script, version drift, stale records, under-powered
Evidence: Script: exp/EXP-09_vs_gamma_coordinated_prior.py (current: crossover band, 12 seeds, #164 reset fix) and .py.bak (pre-fix eval) | Evidence: exp/EXP-09.out (iter4a low-gamma half, 20 seeds, pre-fix), exp/EXP-09-crossover.out (iter4b, 12 seeds, pre-fix), exp/EXP-09-fixed.out (iter8, 12 seeds, current). The iter3 8-seed full sweep has no surviving output file (EXP-09.out was overwritten by iter4a); its numbers exist only in the program log.
Reflection: EXP-09.md

Transfer vs prior agreement gamma (iter8 fixed eval, 12 seeds) · transfer to T

EXP-10Per-mind worth attribution in mixed collaborationCROSSEDattribution (M1-M5)Inside a single collaboration, transfer credited genuine minds +0.375 on average and docked fakes -0.479, a +0.854 attribution gap.

Question: In one collaboration with genuine and fake minds of identical interior structure, does transfer localize worth to the specific genuine minds, and does aggregate transfer scale with the genuine fraction?
Dates: 2026-10-08 (iter5 run, iter8 fixed rerun) (iter5, iter8)
Verdict note: M2 additive half, on corrected iter8 numbers; iter5 superseded (verdict held and strengthened). Additive per-node attribution only; linearity largely by construction; XOR-style synergy still open.
What it means: within a single collaboration, transfer assigns positive credit to the minds whose blocks carry real T-information and negative credit to the ones that teach the opposite, and aggregate credit is linear in the number of genuine minds. That is the per-contributor property a Shapley-style split needs, shown in the simplest additive case.
Lesson: An additive task can only demonstrate additive attribution; collaborative-worth claims need a task where worth exists only in the combination, and fakes should include a zero-information arm, not just an opposite-teaching one.
Process tags: bug in script, at ceiling, stale records, metric gameable
Evidence: Script: exp/EXP-10_vs_multimind_attribution.py (current, #164 reset fix) and .py.bak (pre-fix eval) | Evidence: exp/EXP-10.out (iter5, pre-fix), exp/EXP-10-fixed.out (iter8, current)
Reflection: EXP-10.md

Per-mind transfer within one collaboration (iter8, 12 seeds) · transfer on own block

EXP-11Reinforcement substrate smoke testSUPPORTIVEsynergy / XORThe richer creature learned a toy bandit (0.75 to 1.00) and forked into a byte-exact twin, clearing the way for twin-ablation work.

Question: Can the equilibrium Reinforcement creature learn a trivial 4-context bandit on Cadence 0.78 and fork into a twin that acts identically?
Dates: 2026-10-08 (iter6)
Verdict note: Foundation validated (bandit learned, twin exact, snapshot 19,337 bytes). Still current, but the synergy work moved off this creature: iter7 found it does not learn XOR.
What it means: the equilibrium Reinforcement creature can learn a lookup-style bandit and can be forked into a byte-identical twin, which is the precondition for twin-ablation attribution. It says nothing about whether the creature can learn a non-additive task; that was the open question it set up.
Lesson: Smoke-test the substrate and the fork before building a multi-condition harness, and save the smoke output to a file so numbers can be checked against evidence.
Process tags: under-powered, at ceiling
Evidence: Script: exp/EXP-11_smoke_reinforcement.py | Evidence: no .out file saved; numbers are from EXPERIMENT-RESULTS.md (EXP-11 entry) and VS-TRANSFER-PROGRAM.md iter6
Reflection: EXP-11.md

Bandit accuracy before and after 400 steps (1 seed) · greedy accuracy

EXP-12Synergy-harness smoke: copy tasks and XORNULLsynergy / XORSingle-bit copy tasks were trivial (1.00 at every size), but XOR, the one task the synergy design needed, never got off chance (best 0.75 on one seed).

Question: Does a factored-input creature learn copy-b1, copy-b2 and held-out XOR from scratch, with an exact twin fork?
Dates: 2026-10-08 (iter7)
Verdict note: NULL on the XOR prerequisite (XOR not learned at any P); SUPPORTIVE on the copy tasks and twin. Later widened by EXP-12b-12f and EXP-14/14b; XOR-style synergy still open.
What it means: single-bit tasks are easy for this creature; XOR, the irreducible combination task the synergy design needed, was not learned. The 0.75 at P=6 is one context above chance on one seed and is not evidence of partial learning.
Lesson: Check that the held-out task is learnable at all (the ceiling) before designing an attribution probe around it.
Process tags: under-powered
Evidence: Script: exp/EXP-12_smoke_synergy.py | Evidence: exp/EXP-12-smoke.out
Reflection: EXP-12.md

XOR from scratch by perception patches (1 seed; copy tasks 1.00 at all P) · greedy accuracy

EXP-12bXOR ceiling search over depth and widthNULLsynergy / XOROnly 1 of 5 planned configs finished, and it sat at coin-flip: shallow XOR averaged 0.50 even with 2000 steps.

Question: Is there an architecture and budget where the Reinforcement creature learns XOR from scratch to about 1.0?
Dates: 2026-10-08 (iter7)
Verdict note: Only shallow P6 completed, at chance (mean 0.50, 3 seeds). The other four configs never printed; superseded by EXP-12c and the iter7 verdict (XOR not learned on any architecture tried).
What it means: going from 800 to 2000 steps and adding seeds did not move shallow XOR off chance. It answered nothing about depth or width because those rows never ran.
Lesson: Size a sweep to the time actually available, print each row as it lands, and record when and why a run was cut short.
Process tags: effect window too small, under-powered
Evidence: Script: exp/EXP-12b_xor_ceiling.py | Evidence: exp/EXP-12b-ceiling.out (incomplete: only the first of five configs printed)
Reflection: EXP-12b.md

Shallow P6 XOR accuracy per seed (2000 steps) · greedy accuracy

EXP-12cDoes depth let the creature learn XORSUPERSEDEDsynergy / XORGoing deep scored a striking 0.00 on XOR, which looked like systematic anti-learning but most likely meant the creature never chose an action at all (inferred from EXP-12e/12f, not dumped here).

Question: Does adding a hidden column let the creature learn XOR?
Dates: 2026-10-08 (iter7)
Verdict note: Numbers stand, but the 'front layers never learn' reading was wrong: EXP-12e/12f showed the 0.00 came from the creature returning no action (None) at settle_budget 48, not from a learned wrong mapping. Depth did not unlock XOR.
What it means: going deep at settle_budget 48 looked worse than shallow, but for a mechanical reason (no settled action), not a learned wrong mapping. Depth did not unlock XOR.
Lesson: When accuracy is below chance, dump the raw actions before building a theory, and count None separately from wrong.
Process tags: metric gameable, nothing varied, under-powered
Evidence: Script: exp/EXP-12c_xor_deep.py | Evidence: exp/EXP-12c-deep.out
Reflection: EXP-12c.md

Deep XOR accuracy, mean over 3 seeds (settle_budget 48) · greedy accuracy (None counted wrong)

EXP-12dSettle-budget sweep for credit starvationVOIDsynergy / XORAn expensive sweep built on a misread number timed out after one row, leaving only another 0.00 and no answer.

Question: Is the deep-XOR 0.00 caused by too little settling (credit starvation) or is it fundamental?
Dates: 2026-10-08 (iter7)
Verdict note: Timed out after the settle_budget 48 row; budgets 120/240 and the action dump never ran. Superseded by EXP-12e and EXP-12f; the premise (0.00 = front column never learning) was wrong, and Dongyang's speedup is not the lever.
What it means: on its own, nothing beyond confirming that settle_budget 48 gives 0.00 at 3000 steps. Its question was answered by the smaller follow-ups.
Lesson: Run the cheap diagnostic first (dump actions, measure None-rate) and the expensive sweep after; order cells so a timeout still leaves the decisive number.
Process tags: bug in script, effect window too small
Evidence: Script: exp/EXP-12d_xor_credit_discriminator.py | Evidence: exp/EXP-12d-discriminator.out (incomplete: only the settle_budget 48 row printed; the program log records "exp/EXP-12d (timeout)")
Reflection: EXP-12d.md

Deep P6-H6 XOR at settle_budget 48, 3000 steps · greedy accuracy

EXP-12eIs deep-XOR zero an inverted readoutNULLsynergy / XORThe action dump cracked it: the deep creature answered None on every XOR context, so its 0.00 was silence, not secret XNOR, while the same stack learned copy-b1 to 1.00.

Question: Does deep XOR accuracy 0.00 mean a learned XNOR (inverted readout), or no learning at all?
Dates: 2026-10-08 (iter7)
Verdict note: NULL for the XNOR hypothesis: the creature returned None on every context, so it never trained. Resolved by EXP-12f (settling artifact) and superseded by EXP-14/14b (substrate does not fit XOR on wirings tried).
What it means: at P6-H6, sb=48, the deep creature's acc 0.00 was not "systematically wrong" and not evidence that credit fails to reach the front column; it was the creature returning None (no qualified action) on every context, so it never got feedback and never trained on XOR. Caveat: this is an inference about EXP-12c, not a re-dump of it. EXP-12c ran 2000 steps over P6-H6, P8-H8 and P12-H12 (P12-H12 seed 1 scored 0.50, not 0.00); EXP-12e reran only P6-H6 at 1500 steps. The deep stack itself is not broken: it learns copy-b1 to 1.00 at the same budget.
Lesson: Dump the raw actions before interpreting an accuracy; a scorer that silently maps no answer to wrong answer can make non-learning look like systematic anti-learning.
Process tags: metric gameable, under-powered, pilot != run conditions
Evidence: Script: exp/EXP-12e_xor_polarity.py | Evidence: exp/EXP-12e-polarity.out
Reflection: EXP-12e.md

Deep P6-H6 creature: XOR vs copy-b1 control · greedy accuracy

EXP-12fMore settling budget for deep XORSUPERSEDEDsynergy / XORMore settling made the None answers vanish (0%), but the creature just answered 0 every time and scored exactly chance, 0.50.

Question: If the deep creature gets more settling budget, does it stop returning None on XOR and learn XOR, making Dongyang's cheap deep settling our lever?
Dates: 2026-10-08 (iter7)
Verdict note: SUPPORTIVE (1 seed) of 'settling was not the wall'; neither pre-written branch occurred. Its RL-only caveat was then closed and the conclusion SUPERSEDED by EXP-14/14b, which form the iter7 final verdict.
What it means: the None in EXP-12e was a settling-budget artifact of sb=48. With adequate settling the creature trains, but under this RL reward it settles on always answering 0, which scores exactly chance on XOR. So faster settling would not help: Dongyang's speedup is not our lever for synergy.
Lesson: Write all plausible outcomes into the decision rule, including 'the blocker disappears but nothing improves'; a removed blocker is not the same as a working mechanism.
Process tags: under-powered, bug in script
Evidence: Script: exp/EXP-12f_xor_budget_unlock.py | Evidence: exp/EXP-12f-unlock.out
Reflection: EXP-12f.md

XOR accuracy vs settle_budget (1 seed) · accuracy

EXP-13Profiling the settle bottleneckSUPPORTIVElibrary & toolingDropping settle_budget from 64 to 16 was a free 1.36x speedup, but below 16 sweeps accuracy fell off a cliff (1.00 to 0.50 at sb8, 0.25 at sb2).

Question: On shallow creatures, how much per-step time does settling cost, and does the existing settle_budget knob already buy most of the speedup without hurting learning?
Dates: 2026-10-08 (iter7)
Verdict note: SUPPORTIVE (1 seed): at shallow depth the existing knob gives about 1.36x at no accuracy cost; Dongyang's method not needed for shallow creatures. Not retracted. Whether sb16 was adopted as default is not recorded.
What it means: settling is not a large lever at 2 columns. Going from 64 to 32 sweeps barely changes time (18.8 vs 17.9 ms), which suggests the solve usually hits tolerance well before 64 sweeps, so the budget above that is unused. Below 16 sweeps the creature stops working.
Lesson: Profile the actual bottleneck before porting someone else's speedup; on this substrate the free knob covered the shallow case.
Process tags: under-powered, at ceiling
Evidence: Script: exp/EXP-13_settle_profile.py | Evidence: exp/EXP-13-profile.out
Reflection: EXP-13.md

ms per training step by settle_budget (copy-b1, 1 seed) · ms/step

EXP-14Supervised XOR on the equilibrium substrateNULLsynergy / XOREven with supervised labels and a passing control (copy-b1 acc 1.00), the shallow creature scored 0.50 on XOR in all 6 runs; the deep arm crashed and never produced data.

Question: Is the XOR failure under RL a representation wall of the substrate, or just RL reward failing to teach it?
Dates: 2026-10-08 (iter7)
Verdict note: Shallow half NULL (supervised training does not fit XOR on shallow wiring; stands). Deep half VOID (crash, no data), SUPERSEDED by EXP-14b.
What it means: the shallow XOR failure is not an RL artifact; supervised training with a passing control also fails. The shallow creature outputs a near-constant or weakly linear response, which is what a model without a two-bit interaction produces on XOR.
Lesson: Wrap every call that can raise in a sweep, not just the training call, or one failure silently truncates the experiment.
Process tags: bug in script, under-powered
Evidence: Script: exp/EXP-14_xor_supervised.py | Evidence: exp/EXP-14-supervised.out
Reflection: EXP-14.md

Supervised accuracy: control vs shallow XOR · accuracy

EXP-14bDeep XOR supervised with ample settlingNULLsynergy / XORAll 8 deep runs failed at 0.50 accuracy even at 512 sweeps; the predictions were nearly additive in the two bits, the signature of a model with no interaction term.

Question: With enough settling, does the deep stack fit XOR, meaning it was only settling-limited?
Dates: 2026-10-08 (iter7)
Verdict note: NULL: deep supervised does not fit XOR even with converged settling (second pre-written branch). Not retracted. Closed the iter7 RL caveat; XOR-style representational synergy still open.
What it means: on the wirings tried (widths 6 and 12, one hidden column, fan_in 9), the equilibrium creature does not form the two-bit interaction XOR needs, under RL or supervised, shallow or deep. Faster settling cannot fix this, so Dongyang's method is not the lever. The preds are close to additive in the two bits (seed 11: 0.08 + 0.32 + 0.47 = 0.87 versus 0.85 observed; seed 7 is similarly additive), which is the signature of a model with no interaction term.
Lesson: When a run fails 'just short' of a threshold, test the generous version before building a theory on it; the near-miss crash suggested a settling limit that did not exist.
Process tags: under-powered
Evidence: Script: exp/EXP-14b_xor_supervised_deep.py | Evidence: exp/EXP-14b-supervised-deep.out
Reflection: EXP-14b.md

Deep XOR predictions vs target (P6-H6, seed 11) · prediction

EXP-15Peer prediction vs transfer, same ringSUPPORTIVEattribution (M1-M5)Peer prediction flips to favoring the ring once about half its reference pool is ring (c* = 0.5, or 0.6 at a_R 0.75), while transfer keeps the genuine contributor ahead by +0.500 / +0.375 / +0.250.

Question: When one ring adversary is scored by both peer prediction and twin-brain transfer, where does each stop ranking the genuine contributor above the ring?
Dates: 2026-10-08 (iter9)
Verdict note: SUPPORTIVE as logged ('M4 CROSSED on the matched comparison', iter9), not retracted. Fair only given an exogenous T; that cost moved to M5 (EXP-17). Supersedes the EXP-09 gamma* = 0.70 comparison.
What it means: on one matched adversary, peer prediction flips once about half its reference pool is ring, and transfer keeps ranking the genuine contributor first, giving the ring credit roughly in line with how right its rule is. It also found that the old "beat PP gamma* = 0.70" target compared two different axes and was never like-for-like.
Lesson: Before comparing against a published crossover number, check that it lives on the same axis. A robustness advantage from consuming an extra input (exogenous T) is a moved assumption, not a free win.
Process tags: at ceiling, nothing varied
Evidence: Script: exp/EXP-15_matched_pp_vs_transfer.py | Evidence: exp/EXP-15.out; also cited in M5-EXOGENOUS-ANCHOR.md
Reflection: EXP-15.md

Transfer credit: genuine vs ring by ring agreement a_R · twin delta accuracy

EXP-16Isomorphism invariance of transferSUPPORTIVEattribution (M1-M5)A single instrument's score moved by up to 0.500 under relabeling, but the paired form (genuine minus fake on the same instrument) read +0.500 in 95 of 96 cells.

Question: Is v(S) = v(phi(S)) when phi relabels contexts and/or actions consistently, with the measuring brain not relabeled?
Dates: 2026-10-08 (iter10)
Verdict note: Logged as 'M3 CROSSED EMPIRICALLY for the paired measure, on this bandit; NOT a proof' (iter10). Not retracted. Raw measure invariant only in expectation.
What it means: the label-reading risk did not show up. The variation under phi comes from the instrument's prior (acc_base mirrors to 1 - base under action swap), not from v reading labels. Defining transfer relative to a reference witness on the same twin cancels that prior.
Lesson: Measure worth relative to a reference on the same instrument, not against the instrument's own baseline. A single untouched twin is a biased zero point.
Process tags: at ceiling, under-powered
Evidence: Script: exp/EXP-16_isomorphism_invariance.py | Evidence: exp/EXP-16-t0.out, exp/EXP-16-t1.out, exp/EXP-16-t2.out
Reflection: EXP-16.md

Task 0: max relabeling gap vs instrument ensemble size n · max |v_n(phi S) - v_n(S)|

EXP-17Task-pool capture boundaryBOUNDARYattribution (M1-M5)Whoever supplies most of the scoring tasks wins: paired worth falls linearly from +0.490 to -0.490 and crosses zero at exactly q* = 0.500.

Question: If an adversary controls a fraction q of the scoring-task pool, at what q does expected paired worth reach zero?
Dates: 2026-10-08 (iter11)
Verdict note: SUPPORTIVE as logged; M5 'STATED AS A BOUNDARY (with a number)' (iter11), not retracted. Transfer needs an honest majority of tasks; cost-bearing task sources are unbuilt.
What it means: transfer does not escape the exogenous-anchor class. It moves the anchor from peers to tasks. A task can be checked and peer collusion buys nothing, but whoever supplies most of the scoring tasks wins.
Lesson: When a headline number comes from a formula over a few means under a symmetric design, say that the symmetry sets it. A boundary result is still a result, as long as it is labeled as one.
Process tags: at ceiling, nothing varied
Evidence: Script: exp/EXP-17_task_capture.py | Evidence: exp/EXP-17.out; statement in M5-EXOGENOUS-ANCHOR.md
Reflection: EXP-17.md

Four transfer components (12 seeds) · twin delta accuracy

EXP-18Key/lock secret-share synergySUPPORTIVEsynergy / XORLock and key were each worth almost nothing alone but +0.521 together (synergy +0.375, about 4 sigma); Shapley split it about evenly while leave-one-out overpaid 1.7x.

Question: With real learners, does twin-ablation attribution price a purely super-additive pair correctly, and which credit rule splits it fairly?
Dates: 2026-10-08 (iter12)
Verdict note: Logged as 'M2-SYNERGY CROSSED FOR DATA-CHANNEL SYNERGY ONLY' (iter12). Not retracted. Learned-composition half addressed by EXP-19; XOR-style representational synergy still open.
What it means: when the synergy is real but lives in the data, twin-ablation plus coalition Shapley gives an about even split and gives an honest party nothing when it is paired with a fake. Single leave-one-out ablation double-counts. That Shapley sums to v(AB) is algebra, not a finding. The findings are the even split, the LOO overpayment, and the monotone partial-key curve.
Lesson: Price contributions with coalition Shapley over twins, never with single leave-one-out ablation, which overpaid this synergistic pair 1.7x. Average several noise twins for the zero point.
Process tags: under-powered
Evidence: Script: exp/EXP-18_keylock_synergy.py | Evidence: exp/EXP-18.out
Reflection: EXP-18.md

Value of each coalition (12 seeds) · v(S), accuracy over noise twin

EXP-19Teamwork credit on key-door worldSUPPORTIVEsynergy / XORA real Cadence brain fused two lessons each worth about 0 alone into a skill worth +0.58 (synergy +0.72, about 4 sigma), and the fake key earned nothing.

Question: When two teachers each teach only half of a sequential skill, does the student compose them, and does twin-ablation credit price the pair as synergistic while a fake key gets nothing?
Dates: 2026-10-08 to 2026-10-09 (iter13)
Verdict note: Logged as 'M2-SYNERGY CROSSED for LEARNED sequential composition on real Cadence brains' (iter13). Not retracted. Run 1 is VOID (degenerate metric). XOR-style representational synergy still open.
What it means: a real Cadence brain composed two lessons that are each worth about 0 alone into a skill worth +0.58, a fake key earned nothing, and Shapley split the credit nearly evenly. This turned the attribution score into a score on lessons, and that opened the teaching-game thread (EXP-20b, EXP-21).
Lesson: Before a long run, check that the score cannot be passed by a degenerate policy, and keep the old script version when the metric changes. N=100 was too small for the composed skill to appear; 300 worked.
Process tags: metric gameable, under-powered, stale records
Evidence: Script: exp/EXP-19_keydoor_teamwork.py | Evidence: exp/EXP-19-fedonly.out (run 1), exp/EXP-19.out (run 2, N=100 clean), exp/EXP-19-N300-s0.out, exp/EXP-19-N300-s4.out, exp/EXP-19-N300-s8.out (run 3, 3 shards of 4 seeds)
Reflection: EXP-19.md

Run 3 (N=300, clean) coalition values, pooled over 3 shards · v(S), clean-trip score over null twin

EXP-20Teacher brains learning from Shapley creditVOIDteaching gameThe closed live teaching loop was never run: the only output is a 2-round smoke test where both teachers earned 0.00.

Question: If two teacher brains are paid only by the Shapley credit their lesson earns in a freshly taught student, do they learn to give complementary lessons?
Dates: 2026-10-09 (none (script named in iter14 Evidence))
Verdict note: VOID as an experiment (never run at size; only a 2-round smoke run). SUPERSEDED by EXP-21 (measured payoff table) plus EXP-20b (teacher brains playing that table).
What it means: nothing is known from EXP-20 itself. The closed live loop (payoffs re-measured on a new student every round) has still never been run; EXP-20b answers a cheaper lookup version of the question.
Lesson: When every round of a learning loop needs a freshly trained student, measure the payoff table once and let the learners play the table, but report it as a table game, not as the live loop.
Process tags: under-powered, stale records
Evidence: Script: exp/EXP-20_learning_teachers.py | Evidence: exp/EXP-20-run99.json (a 2-round smoke run, RUN=99, N=100). No full-run output exists.
Reflection: EXP-20.md

No chart: this experiment produced no usable numbers.

EXP-20bLearning teachers play the lesson gameSUPPORTIVEteaching gameUnder every credit rule, learning teachers converged on key + door play in 12/12 runs (greedy end policy key/door in 10-11 of 12), but leave-one-out paid out 1.83x the value created.

Question: Do two teacher brains, paid only by a credit rule on their students' measured gains, discover the key + door split and drop lamp/spam, and how do Shapley, leave-one-out and equal split compare?
Dates: 2026-10-09 (iter14)
Verdict note: iter14: 'rung 1 of the teaching game WORKS'. Not retracted. Limited to a lookup table; the credit rules separate only on payout budget.
What it means: on this table, learning teacher brains reliably come to give key and door and stop giving lamp and spam under every rule tested. LOO overpays (1.83x the value created). Shapley and equal split paying exactly 1.00x is true by construction (both rules sum to v(12)), not a measured finding.
Lesson: A credit-rule comparison needs a payoff table where the rules give different incentives (e.g. a free-rider lesson); report the greedy end state alongside any convergence metric.
Process tags: nothing varied, under-powered, metric gameable
Evidence: Script: exp/EXP-20b_teachers_on_table.py | Evidence: exp/EXP-20b.out (table built from exp/EXP-21-s*.json)
Reflection: EXP-20b.md

Payout per unit of value created, by credit rule · payout/value

EXP-21Measured lesson payoff tableSUPPORTIVEteaching gameOnly key + door pays: +0.819 together, key + null scraped +0.147 (2 of 12 students), and every other coalition scores -0.014: nearly a pure-complement game.

Question: What does every coalition of lessons (null, singles, all pairs over key, door, lamp, spam) actually do to a real Cadence key-door student?
Dates: 2026-10-09 (iter14)
Verdict note: Supportive as a measured table (iter14: 'Only key+door pays'). Not retracted; a measurement, not a hypothesis test.
What it means: on this world the lesson game is a pure complement: key and door are near-worthless alone and worth about 0.82 together, and a bad partner lesson (lamp, spam, or a second key) wipes out a good one. That structure is why every credit rule in EXP-20b converges the same way.
Lesson: Measure the payoff table before designing a credit-rule contest on it; this one shows in advance the rules cannot disagree because no free-rider lesson exists.
Process tags: under-powered
Evidence: Script: exp/EXP-21_lesson_payoff_table.py | Evidence: exp/EXP-21-s{0,2,4,6,8,10}.json and .out (2 students each, 12 total)
Reflection: EXP-21.md

Coalition value v (score minus null), 12 students · v

EXP-22Generations: does skill pass brain-to-brainSUPPORTIVEgenerations & inheritanceGrading passes the skill on 94% per generation (83/88), while label teaching produced 0/20 passing children.

Question: Does key-door skill pass down a chain of fresh brains each taught only by its parent, via labels vs grading?
Dates: 2026-10-09 (iter15 (sub-claim retracted iter16))
Verdict note: Inheritance by grading (94% per generation) stands. The sub-claim 'doing != teaching' (5/88 passing parents produced failing children) is RETRACTED in iter16 after EXP-23 showed child failure is set by the child's random init.
What it means: in this one small world, parent-grading is a working inheritance channel and label teaching is not (it shapes the per-state answers but not the reward-trained actor). Without selection a lineage keeps the skill at about 0.94 per generation, so selection or pricing is needed to stop decay. Whether teaching quality varies between parents was not shown here, and the 5 failures turned out to be bad students, not bad teachers.
Lesson: Before attributing a child's failure to the teacher, vary the teacher while holding the student seed fixed (or vice versa).
Process tags: version drift, under-powered
Evidence: Script: exp/EXP-22_generation_chains.py, diagnostic exp/EXP-22-diag.py | Evidence: exp/EXP-22-grade-s{0,2,4,6,8,10}.json/.out (run B), exp/EXP-22-label-s{0,2,4,6,8,10}.json/.out (run A)
Reflection: EXP-22.md

Passing children by parent and method · percent

EXP-23Selecting parents by teaching vs doingNULLgenerations & inheritanceSelecting on teaching and on doing gave identical populations, because the 4 failing children sat in the same seed slots under different parents.

Question: Is teaching ability heritable, and does selecting on it beat selecting on doing?
Dates: 2026-10-09 (iter16)
Verdict note: Identical arms. Triggered the retraction of EXP-22's 'doing != teaching'. Superseded as the teaching-trait test by EXP-24 to EXP-26 pilots and EXP-27.
What it means: in this setup, selecting by teaching is the same as selecting by doing, because among passing parents teaching ability has no variance: grading copies the parent's whole policy, and child failure is set by the child's random init. Teaching ability has to be a real, varying, heritable trait before selecting on it can matter.
Lesson: Before a selection experiment, confirm the trait being selected actually varies and is not dominated by noise on the student side.
Process tags: nothing varied, under-powered
Evidence: Script: exp/EXP-23_selection_by_teaching.py | Evidence: exp/EXP-23.out, exp/EXP-23.json, exp/exp23_brains/ (192 saved brains)
Reflection: EXP-23.md

Population teaching score by generation (both arms identical) · fraction of children passing

EXP-24Calibrating key-door grading strategiesNULLteaching gameAlmost every grading shape taught 12/12 students even at 40 trips (mid 11/12); only a faint 0.2 reward dropped to 6/12.

Question: Do different grading strategies with the same parent skill teach key-door at different rates?
Dates: 2026-10-09 (iter17)
Verdict note: At ceiling. iter17: 'Key-door is too easy to teach: per-step grading + visible key = a lookup.' Not retracted; search moved to EXP-26.
What it means: on key-door with per-step parent grading, the grading SHAPE (harsh vs soft, floor grading, door drilling) makes no visible difference; only reward strength matters, and only when it is weak (0.2 gives 6/12, 0.5 gives 11/12 at 40 trips, 1.0 and above gives 12/12). Per-step grading against a parent who sees the key turns teaching into copying a lookup table, so there is no room for teaching skill to show.
Lesson: Before asking whether strategies differ, check that the task leaves headroom at the chosen budget.
Process tags: at ceiling, under-powered
Evidence: Script: exp/EXP-24_strategy_calibration.py | Evidence: exp/EXP-24-M40.out, exp/EXP-24-M40.json, exp/EXP-24-M100.out, exp/EXP-24-M100.json
Reflection: EXP-24.md

Students passing at M=40 teaching trips, by strategy (of 12) · students

EXP-25The memory doorNULLteaching gameNo founder beat the 0.50 memoryless ceiling, and training 3x longer dropped every founder to 0.00.

Question: Can founder brains learn a blind memory-door task at all, so grading strategies could be compared on it?
Dates: 2026-10-09 (iter17)
Verdict note: Founders never learned the task; teaching step never reached. Framed as a boundary on this setup. Superseded as testbed by EXP-26.
What it means: with plain `step` RL and this reward, our founders do not learn to carry a memory of the chest to the door; at best they pick one memoryless policy (always press or never press). Longer training made it worse (0.00 at 3000 trips; the program log reads this as a collapse to pressing, which the .out files do not show directly). We still do not know whether Cadence can learn this task with another training route; the log notes benchmark memory results use `live` plus arousal, which this script did not use.
Lesson: A 'hard to teach' task must first be learnable by the teacher; confirm with the training route the library's own memory benchmarks use (live plus arousal).
Process tags: under-powered, pilot != run conditions
Evidence: Script: exp/EXP-25_memory_door.py | Evidence: exp/EXP-25-found-F1000.out, exp/EXP-25-found-F3000-d0.out, exp/EXP-25-found-F3000-d2.out
Reflection: EXP-25.md

Founder mean score on the memory door · score

EXP-26Tutor focus on the student's mistakesSUPPORTIVEteaching gameWith a perfect teacher, drilling the student's mistakes lifted child accuracy from 0.818 to 0.964 at 64 steps.

Question: Is there a teaching skill invisible to the teacher's own doing: does drilling the student's currently wrong contexts raise child accuracy?
Dates: 2026-10-09 (iter17 (main), iter18 (re-pilot))
Verdict note: Pilot: focus is a real, graded teaching trait. Not retracted; became the gene evolved in EXP-27. Main M=128 run capped by a 0.69 teacher.
What it means: how a teacher chooses what to drill changes how much the student learns, and this is not visible in the teacher's own score (every teacher answers the same). With a perfect teacher the gap between focus 0 and focus 1 is about 0.11 at M=32 and 0.15 at M=64. The log's "student cannot exceed teacher" is expected from the design rather than discovered: the student is graded against the teacher's answers, not the true rule.
Lesson: Pilot under the exact conditions of the real run, and check the teacher is not itself the ceiling.
Process tags: at ceiling, pilot != run conditions, under-powered
Evidence: Script: exp/EXP-26_tutor_focus.py | Evidence: exp/EXP-26-K32-M128.out/.json, exp/EXP-26-K32-M32-T.out/.json, exp/EXP-26-K32-M64-T.out/.json
Reflection: EXP-26.md

Child accuracy by tutor focus (perfect teacher, M=64, 6 students) · accuracy

EXP-27Evolving tutors: doing vs teaching selectionSUPPORTIVEgenerations & inheritanceSelecting on plain doing evolved the highest focus (0.85) and kept the most knowledge (0.943), beating the predicted winner BOTH.

Question: Does selecting on a parent's teaching score evolve better teachers (higher focus gene) than selecting on own doing, and what does each do to knowledge?
Dates: 2026-10-09 (iter18 (runs 1-2), iter19 (powered))
Verdict note: Run 1 VOID (ceiling), run 2 NULL (underpowered), powered run SUPPORTIVE but unreplicated; the written prediction (BOTH best) was WRONG, DO was best on every measure. Replicate seeds requested in iter19 have no recorded result.
What it means: in this setup focus rises under all three selection rules, and selecting children on their own accuracy (DO) raised focus most while keeping knowledge best, because a child's score already reflects its parent's teaching. Selecting on the parent's teaching score alone (TEACH) lost knowledge in both run 2 and the powered run. The program drew the design rule "doing selects teaching; payment rewards it." Caution: focus being "heritable" is built in (the gene is copied with mutation), not discovered, and the mean teaching score barely moved (DO 0.821 to 0.852), so the evidence that teaching quality improved is the focus gene, not a large rise in child accuracy.
Lesson: Match the pilot to the run's conditions and power the run for the pilot's effect size; one run per arm shows direction but cannot rank arms within generation noise.
Process tags: pilot != run conditions, under-powered, version drift, at ceiling
Evidence: Script: exp/EXP-27_evolving_tutors.py (imports exp/EXP-26_tutor_focus.py) | Evidence: exp/EXP-27-M128-ceiling.out/.json, exp/EXP-27-M32-small.out/.json, exp/EXP-27-powered.out, exp/EXP-27.json (powered run)
Reflection: EXP-27.md

Final focus gene after 20 generations (powered run, one run per arm) · focus

EXP-28Teacher vs world on key-doorSUPPORTIVEteaching gameAt 40 trips a teacher got 8/8 students passing versus 1/8 from the world alone; by 600 trips the world caught up (7/8 vs 5/8).

Question: Do brains learn key-door as well from the world's own reward as from parent grading at matched trip budgets?
Dates: 2026-10-09 (iter18)
Verdict note: Matches the prediction written before running. Not retracted; the M=600 drop was followed up and confirmed (over-teaching) by EXP-30.
What it means: on this task teaching is not redundant: it is a large speed and reliability multiplier at small budgets, and the world catches up by about 600 trips. It does not raise the ceiling (consistent with EXP-26: student at most as good as its teacher). The drop of taught students at 600 (8/8 to 5/8) was the surprise.
Lesson: A redundancy check needs matched budgets, the same students, and a budget sweep so at least one arm moves through the window.
Process tags: at ceiling, under-powered
Evidence: Script: exp/EXP-28_teacher_vs_world.py | Evidence: exp/EXP-28.out, exp/EXP-28.json
Reflection: EXP-28.md

Students passing (of 8): world reward vs teacher grading · students

EXP-29Two partial teachers, one studentSUPPORTIVEteaching gameTeachers who stay inside what they know produce a student at 0.898 accuracy, versus 0.680 when the same teachers also teach their guesses.

Question: Can a student taught by two teachers who each know only half the rule beat either teacher, and does it matter whether teachers stay inside what they know?
Dates: 2026-10-09 (iter19)
Verdict note: (b) confirmed: overconfident teachers cancel out. (a) only partly: specialist student beats teacher B (0.72) and the teacher average (0.81) but only ties A (0.91), never near 1.0. (c) lower than predicted. Not retracted; specialist rule carried into EXP-31 and EXP-32.
What it means: knowing the limits of your own knowledge is a teaching skill worth about 0.2 accuracy here (spec about 0.84 to 0.90 vs over about 0.65 to 0.68). Whether two partial teachers can produce a student who exceeds the best teacher is still not shown, because teacher A turned out much better than designed.
Lesson: When a prediction depends on a teacher being at a given level, measure the teacher first and re-draw it if it lands outside the design; match total budgets across arms.
Process tags: at ceiling, under-powered
Evidence: Script: exp/EXP-29_two_partial_teachers.py | Evidence: exp/EXP-29.out, exp/EXP-29.json
Reflection: EXP-29.md

Student accuracy at M=128 steps per teacher (8 students) · greedy accuracy

EXP-30Over-teaching: more grading hurts studentsSUPPORTIVEteaching gameMore parent grading made students worse: clean passes fell from 8/8 at 300 trips to 1/8 at 1500.

Question: Is the EXP-28 drop of taught students at 600 trips (8/8 to 5/8) real over-drilling that grows with budget, or noise?
Dates: 2026-10-09 (iter19)
Verdict note: Over-drilling is real and monotone in this setup; mechanism unknown. Not retracted. No world-reward control at large budgets.
What it means: more parent grading is not always better; past a point it destroys the clean full-task pass. Design consequence recorded in the program log: cap teaching budgets, or pay on gain at the best stopping point, not on effort.
Lesson: When reusing a script for a follow-up, keep the control arm on, and rename headers and temp paths so outputs cannot be confused.
Process tags: bug in script, under-powered
Evidence: Script: exp/EXP-30_overteaching.py | Evidence: exp/EXP-30.out, exp/EXP-30.json
Reflection: EXP-30.md

Students passing the full task vs teaching budget (of 8) · students passing (count)

EXP-31Peer gossip vs one-way ringNULLteacher networksTwo-way peer gossip did not beat a one-way ring: both stalled near 0.78 (PEER 0.789 vs RING 0.778).

Question: Does random two-way peer teaching spread knowledge through a network faster than one-way teaching around a ring?
Dates: 2026-10-09 (iter20)
Verdict note: Prediction wrong: RING faster early, PEER only slightly higher late, finals indistinguishable. Both plateau near 0.78; plateau later explained by EXP-33 (stale teaching).
What it means: in this world, who teaches whom was not the binding constraint; a shared ceiling near 0.78 was. The "exponential gossip" intuition did not show up because knowledge was being lost about as fast as it spread.
Lesson: Check for a common ceiling before comparing rates; if every arm plateaus at the same level, find the cause of the plateau before testing the mechanism you care about.
Process tags: at ceiling, under-powered
Evidence: Script: exp/EXP-31_peer_exchange.py | Evidence: exp/EXP-31.out, exp/EXP-31-M16.json (the program log cites EXP-31.json; the file on disk is EXP-31-M16.json)
Reflection: EXP-31.md

Final mean accuracy after 12 rounds (6 seeds) · accuracy on true rule

EXP-32Minimal teaching market with learned choiceSUPERSEDEDmarket & attacksLetting brains learn whom to teach from their pay gave a small, non-significant edge (0.842 vs 0.791) and the payout ledger balanced to the cent, by construction.

Question: Does letting each brain learn WHO to teach from the pay it earns spread knowledge faster than random partners, while keeping payments budget-balanced?
Dates: 2026-10-09 (iter20)
Verdict note: NULL on the main claim (CHOOSE edge not significant, choosers barely learned to pick needy peers) and SUPERSEDED by EXP-34, which led to the rule 'teaching is neediest-first, hard-wired, not learned'. Budget balance held exactly but by construction.
What it means: we have a working minimal market loop (pay on measured gain, pedigree split, per-event ledger) that is budget-balanced, but no evidence that pay-driven partner choice helps. The only real difference seen is that CHOOSE was more consistent across seeds (SEM 0.010 vs 0.037).
Lesson: Do not count properties guaranteed by construction as confirmed predictions, and do not build a learned controller on a signal before checking that the signal is less noisy than the effect it should drive.
Process tags: at ceiling, under-powered, metric gameable
Evidence: Script: exp/EXP-32_spawn_market.py | Evidence: exp/EXP-32.out, exp/EXP-32.json (also the data source for ui/spawn-sim.html)
Reflection: EXP-32.md

Final mean accuracy, learned chooser vs random partner (6 seeds) · accuracy on true rule

EXP-33Fixing forgetting lifts the network ceilingCROSSEDteacher networksThe plateau was stale teaching, not brain size: notes plus drift-check lifted network knowledge from 0.790 to 0.991, while doubling the brain only reached 0.816.

Question: Why do EXP-31 peer networks plateau around 0.78-0.84, and is the cause forgetting / stale teaching or brain capacity?
Dates: 2026-10-09 (iter21)
Verdict note: Prediction confirmed and exceeded: both reached 0.991, not just 0.95; big brain alone barely moved. Still current; became the base world for EXP-34 FIX, EXP-35, EXP-35b, EXP-36.
What it means: the plateau was mostly brains teaching items they had already forgotten (stale teaching), not lack of capacity. The single biggest fix is drift-check (0.790 to 0.982). The provenance record that pedigree pay needs is the same record that stops knowledge rotting.
Lesson: Before blaming capacity for a ceiling, check whether the system is propagating stale state; a record of what was learned and its answer at the time is cheap and decisive.
Process tags: under-powered
Evidence: Script: exp/EXP-33_forgetting_fix.py | Evidence: exp/EXP-33.out, exp/EXP-33.json, smoke exp/smoke/EXP-33-smoke.out
Reflection: EXP-33.md

Final network knowledge by fix (6 seeds) · final knowledge

EXP-34Can brains learn whom to teach?SUPPORTIVEteacher networksTeaching the neediest student first reached 0.96 by round 8 versus round 12 for random, but a learned chooser never figured that out (0.982, same as random).

Question: When each brain can see how much of its known set each peer lacks, does a learned chooser pick needy students and does neediest-first teaching beat random partner choice?
Dates: 2026-10-09 (iter21 / iter22)
Verdict note: Run 1 NULL (ceiling-bound), superseded by the FIX rerun. FIX rerun: SUPPORTIVE for neediest-first (faster, small final edge); NULL for the learned chooser, which equals random. Led to the design rule: neediest-first, hard-wired, not learned.
What it means: partner choice was not the bottleneck while the network was capped by stale teaching; once that cap was removed, choosing the neediest student mainly speeds up the start. A chooser learning from per-round pay did not learn to follow a visible need signal: pay per round is too noisy to learn from at this scale.
Lesson: Fix the binding constraint first, then measure the secondary knob; and do not ask a learner to discover a rule from a reward signal noisier than the effect it must learn.
Process tags: at ceiling, pilot != run conditions
Evidence: Script: exp/EXP-34_informed_partner_choice.py (env FIX=1 adds the EXP-33 notes + drift-check + rehearse) | Evidence: exp/EXP-34.out, exp/EXP-34.json, exp/EXP-34-fix.out, exp/EXP-34-fix.json
Reflection: EXP-34.md

Final knowledge on the fixed network (FIX run, 8 seeds) · final knowledge

EXP-35Pedigree share as a control dialSUPERSEDEDpedigree shareEvery pedigree share from 0 to 0.9 ended with the network knowing 100% of contexts, so the test could not tell whether the share drives discovery, and the PI controller drove it to 0.

Question: Does the pedigree share change how much brains discover, and can a PI controller set it as well as the best fixed value?
Dates: 2026-10-09 (iter23)
Verdict note: NULL (logged iter23), and the null is uninformative: world hit a ceiling and the move-credit accounting has the flaw that voided EXP-35b. Superseded by EXP-35b, itself VOID (iter25) then NULL (iter27).
What it means: we learned nothing about whether the share drives discovery. Discovery effort rose only 0.29 to 0.37 across shares and every arm ended with the network knowing 100% of contexts, so the low-share stall the prediction needed never happened. The PI controller drove the share to 0.
Lesson: Before testing a knob, trace the chain knob to signal to estimate to choice to outcome and confirm every link moves (became RUN GATE item 5, CHAIN); and pilot the effect window under run conditions.
Process tags: at ceiling, bug in script, effect window too small
Evidence: Script: exp/EXP-35_pedigree_controller.py | Evidence: exp/EXP-35.out, exp/EXP-35.json
Reflection: EXP-35.md

Final accuracy by pedigree share (K=48, 6 seeds) · final accuracy

EXP-35bPedigree share drives discovery (item credit)SUPPORTIVEpedigree shareWith correct credit, a 0.9 pedigree share doubled what discovering pays and raised late discovery from .51 to .63 (~4 SEM).

Question: If a discovery's origin earns a share of the pay whenever others teach it onward, do brains discover more?
Dates: 2026-10-10 (iter25 (VOID), iter27 (NULL), iter28)
Verdict note: iter28 with correct credit; iter25 VOID (credit bug), iter27 NULL superseded (Discover estimate stuck at its prior)
What it means: the pedigree share CAN steer behaviour toward discovery in this small world, but only if Discover is credited with everything a discovery later earns, including the discoverer's own teaching of it. Royalty from other brains' relays alone is too small to see. The share is a transfer, not free money: Teach pay per move fell (.0091 -> .0079) and relaying fell (.57 -> .49) as discovery rose. Whether that trade raises total knowledge is only weakly supported (accuracy +.021, ~2 SEM).
Lesson: A smoke test is not a pilot: print every link of the mechanism chain before the full run, and credit a move with everything it causes.
Process tags: bug in script, effect window too small, pilot != run conditions
Evidence: Script: exp/EXP-35b_pedigree_controller.py (pilot: exp/EXP-35b_pilot.py) | Evidence: exp/EXP-35b-item-2026-10-10.out, exp/EXP-35b-K96-R30-item.json/.jsonl, exp/EXP-35b-pilot-item-P*.jsonl, exp/EXP-35b-full-2026-10-10.out, exp/EXP-35b-K96-R30-{orig,fixed}.json/.jsonl, exp/EXP-35b-K96-R30-iter25.jsonl
Reflection: EXP-35b.md

Discover share, last 10 rounds (12 seeds) · share of brains

EXP-36Colluders and fake need attack the marketSUPPORTIVEmarket & attacksWith self-reported tests, colluders minted 13.094 in fake pay (about 80x the real gain); a protocol probe plus once-per-item ledger cut it to 0.042.

Question: Can colluders mint fake pay and soak lessons in the teaching market, and which defences (probe on a committed copy, once-per-item ledger, reciprocity) stop them?
Dates: 2026-10-09 / 2026-10-10 (iter23 (smoke), iter24, iter26)
Verdict note: iter24 result SUPERSEDED by the iter26 bug-fixed rerun. Current SUPPORTIVE: self-reported lists catastrophic, probe+ledger nearly stops minting, probe-fooling sandbagger bounded but costs honest knowledge; reciprocity recovers throughput but does not cut fake pay (RECIP <= SMART prediction wrong). Attack not solved.
What it means: pay-on-measured-gain is not enough when the student reports its own tests or need; measurement must be done by the protocol on a committed copy, with each student-item credited once. The remaining hole is a sandbagger that also fools probes: it always looks neediest and soaks most lessons. PROBE+LEDGER's residual 0.042 is, by code reasoning (not separately measured), a gross-vs-net gap: pay counts items newly right while true gain is net accuracy change, so forgetting during a lesson shows up as "fake" pay.
Lesson: When a result looks better than expected for a defence, audit the accounting path for double-counting; and an attack test needs the 'attacker sees through the probe' case, because that is where the real residual lives.
Process tags: bug in script, version drift
Evidence: Script: exp/EXP-36_adversarial_market.py (fixed); buggy original exp/EXP-36_adversarial_market.py.dup-bug.bak | Evidence: exp/EXP-36-fixed.out, exp/EXP-36-fixed.json, exp/EXP-36-fixed.jsonl (current); exp/EXP-36.out, exp/EXP-36.json (superseded)
Reflection: EXP-36.md

Fake pay minted by attackers, by defence mode (fixed rerun) · fake pay minted

EXP-37Weight change cannot price a lessonCROSSEDattribution (M1-M5)A lesson teaching the opposite rule moved weights almost as much as a genuine one (2.443 vs 2.585) while worth differed by 1.0; correlation of weight change with worth was -0.02.

Question: Can a brain's gain be measured from the inside, by how far its weights moved, instead of by an outcome test?
Dates: 2026-10-09 (iter24)
Verdict note: CROSSED for the worth-blind claim; the pre-filter part only SUPPORTIVE (noise moves weights less on average, not reliably: seed 14). Still current.
What it means: how much a brain changed says nothing about whether the change was worth anything; an outcome test (or twin transfer) is required to price a lesson. Weight change can at most flag "nothing was learned" as a cheap first pass.
Lesson: Interior change is not a price signal; use it only as a pre-filter, expect outliers, and never let it veto a lesson on its own.
Process tags: none
Evidence: Script: exp/EXP-37_weight_change_filter.py | Evidence: exp/EXP-37.out, exp/EXP-37.json
Reflection: EXP-37.md

Weight change (L2 norm) by lesson type (16 seeds) · dW (L2 norm)

EXP-38Never re-teach a passed itemSUPPORTIVEmarket & attacksIgnoring need claims on already-passed items cut attacker soak from 69% to 30% of lessons and lifted honest knowledge .927 to .946 (~2.6 SEM).

Question: Does ignoring repeat need on already-passed items stop the probe-fooling sandbagger?
Dates: 2026-10-10 (iter29)
Verdict note: 12 seeds; scripted adversaries; detector blinded by an adaptive attacker yet the rule still holds
What it means: the protocol should never route a second lesson to an item a student already passed in a test it could not fake. That one rule cut attacker soak from 69% to 30% of lessons (the colluder's own lessons set a floor of about 1 in 8) and recovered most of the honest throughput lost to the sandbagger (no-attacker level ~.95). It does not reduce minting: the ledger already caps fake pay, and the defence only changes who collects it. Against an attacker who knows the detector, the detector reads 0, yet the attacker is no better off, and total fake pay is lower (.45), because answering honestly on passed items is the attack giving up. "Detect the cheat" was the wrong frame; "never pay twice for the same passed item" is the mechanism.
Lesson: When a defence makes a number worse, check whether the metric watched only one actor; measure the mechanism, not the alarm.
Process tags: metric gameable
Evidence: Script: exp/EXP-38_repeat_need.py | Evidence: exp/EXP-38-full.out, exp/EXP-38-full.json/.jsonl, pilot exp/EXP-38-pilot.jsonl
Reflection: EXP-38.md

Share of lessons absorbed by attackers (12 seeds) · share of lessons

EXP-39Teaching a 4-step prerequisite chainSUPPORTIVEteaching gameA grading teacher got 12/12 students through wood > stone > fire > warm in 40 episodes; learning alone took about 1500 (11/12), and hiding the inventory made it unlearnable.

Question: Do inventory-in-state, per-move grading and backward teaching fix the 'collapse onto one action' failure on a 4-step chain?
Dates: 2026-10-10 (iter30)
Verdict note: 12 seeds x 4 budgets x 5 arms; pre-registered; toy chain, one brain configuration
What it means: for prerequisite chains the teacher's value is the per-move signal, worth roughly a 37x saving in experience here (12/12 at 40 episodes vs 11/12 at 1500). The observation must carry the chain state (inventory); no amount of grading rescues a blind brain. And a reverse curriculum under sparse reward is a trap: starting next to the fire teaches "warm" first, the brain latches onto the late-chain moves (craft / warm) and never recovers, which is the collapse the developer reported. Plain sparse reward from empty does eventually learn the chain with this brain configuration (key-door protocol-3 operating point), so "Cadence cannot learn prerequisite chains" is not supported; it needs either more experience or a grading teacher.
Lesson: Test advice before giving it: 'teach backwards' worked on a 2-step chain but a reverse curriculum under sparse reward causes the collapse on 4 steps.
Process tags: none
Evidence: Script: exp/EXP-39_prerequisite_chain.py | Evidence: exp/EXP-39-full.out, exp/EXP-39-full-B*.json/.jsonl, pilot exp/EXP-39-pilot-B*.jsonl
Reflection: EXP-39.md

Students solving the chain (of 12) · students

EXP-42Learning text one character at a time from grades aloneBOUNDARYlanguageHearing only right or wrong, a Cadence brain went from always-space (.202) to .225 on held-out Alice; a model told the answer reached .291 with one character of context and .502 with three.

Question: How far does grading alone (say a character, hear +1 or -1, never the answer) take a Cadence brain on real text?
Dates: 2026-10-10 (iter32)
Verdict note: 3 seeds x 3 arms; pre-registered; Alice ch.1 train, ch.2 held out; one brain size, 3 passes
What it means: a grade carries at most one bit per character (right or wrong, and almost always "wrong"), while being told the character carries log2(28), about 4.8 bits. A learner that only hears "wrong" must find each answer by elimination, and the number of contexts grows as 28^n with context length, so longer context makes grading worse for Cadence, not better (w3 under w1). In three passes over one chapter, Cadence learned about what a lookup table learns from the same grades: space is common and a few letters follow a few letters. Its own memory did not carry useful context: the continuing-life arm collapsed onto saying space.
Lesson: A right-or-wrong grade carries at most one bit per character against about 4.8 for the answer, and contexts grow as 28^n, so more context made grading worse, not better.
Process tags: none
Evidence: Script: exp/EXP-42_char_language.py | Evidence: exp/EXP-42-full.json/.jsonl, exp/EXP-42-full.out | Text: exp/data/alice-ch1.txt (train), exp/data/alice-ch2.txt (held out), from Project Gutenberg #11 (public domain)
Reflection: EXP-42.md

Held-out accuracy on Alice chapter 2 · accuracy

EXP-43Grades that judge the guess: learning text from a teacher's gradesBOUNDARYlanguageA teacher who grades how good the guess was, not whether it was right, took a Cadence brain to .254 on held-out Alice with three characters of context (right/wrong: .202), still short of a model told the answer (.292). A lookup table on the same grades beat that model (.346).

Question: Does more experience, or a grade that judges the guess instead of its luck, let a Cadence brain that never hears the answer reach a model told every character?
Dates: 2026-10-10 (iter33)
Verdict note: 3 seeds x 5 arms (always learning, 6 passes) + 3 seeds x 4 arms (live, 3 passes); pre-registered, revised after a pilot; one seed stopped after collapsing
What it means: (1) A brain that learns from every right/wrong grade learns the most common answer. Space is right 20% of the time and is the teacher's own best guess at 48% of positions; every other guess is mostly punished, so the policy walks onto space and stays (9 of 9 runs, both context widths, partial credit included). EXP-42's arousal-gated brain did better on the same grades (.225), learning from fewer, surprising outcomes. (2) A grade that judges the guess avoids that collapse and makes longer context usable: with three characters, .254 against .202, Cadence's best text result so far (EXP-42: .225), still below a model told the answer with one character (.292). (3) The grade is no longer the bottleneck. A lookup table on the same judged grades reached .346, past the told-the-answer bigram, so grades alone can carry enough to beat a model told the answer; a (32, 16) Cadence brain at its default operating point did not take that in. On text, the limit is now the brain. (4) Instability: four runs collapsed onto "a" (action 0, where every brain starts), including the best brain of the experiment mid-run (judged-w1 seed 1, .275 to .070). Cadence documents a saturation latch with this shape (docs/reward.md), but at the precision logged its saturation and trace readings did not separate a collapsed seed from healthy ones, so the mechanism is not pinned down.
Lesson: Learning from every right/wrong outcome teaches the most common answer; a grade that judges the guess carries enough for a lookup table to beat a model told the answer. On text, Cadence's limit is now the brain, not the grade.
Process tags: pilot mechanism (the calm trap) written into the revision before a healthy control; it did not hold up, a collapsed seed was stopped after pass 4; 6-pass baselines computed separately with the same code, live arms launched beside the full run oversubscribed the CPU
Evidence: Script: exp/EXP-43_judged_grades.py | Evidence: always-learning arms exp/EXP-43-full.jsonl/.out + exp/EXP-43-full-baselines.json; live arms exp/EXP-43-live.json/.jsonl/.out; pilots exp/EXP-43-pilot*.out; collapse diagnostics exp/EXP-43_diag_latch.py + exp/EXP-43-diag-{j0,o0,j2}.txt | Text: Alice ch.1 (train), ch.2 (held out), as EXP-42
Reflection: EXP-43.md

Held-out accuracy on Alice chapter 2 (6 passes) · accuracy

EXP-45Stone Age chain: is it the grade or the brain? (V5 replica)SUPPORTIVEteaching gameOn Stone Age V5's own chamber and signals, Cadence's delayed-credit brain learns the 4-step chain from every teacher (V5's diluted grade .96 per-state accuracy, corrective labels .96) while the default brain with arousal learns it from none (.33-.42). V5's full-chain number is mostly search: a no-knowledge never-repeat searcher gets .304.

Question: Our grading solved the Stone Age chain 12/12; Stone Age V5's grade_only got 0.2%. Was it the grade or the brain, and does V5's full-chain success measure a learned chain?
Dates: 2026-10-13 (none)
Verdict note: 12 seeds x 2 brains x 4 signals; pre-registered, pilot read before the full run; replica of Stone Age V5's chamber reproduces V5's published per-seed numbers exactly; the two brains differ on many genes at once
What it means: the disagreement between our EXP-39 and Stone Age V5 was never about grading. On the same chamber, with V5's exact signals, a brain at Cadence's delayed-credit operating point learns the chain from every teacher signal, including V5's diluted grade and V5's corrective labels, while the composed default brain with arousal learns it from none, and mostly collapses onto one action. And V5's headline reading (sampled full-chain success) is the wrong instrument for "learned the chain": in this chamber a policy with no chain knowledge that never repeats a failure gets .304, our world-reward-only brain gets .350 with no brain right in all four states, and V5's best arm gets its .227 mostly from the carried context steering it within an attempt (erase it before each decision: .098). Per-state greedy accuracy separates the arms cleanly; full-chain success does not.
Lesson: Compute chance for the instrument, not just for the actions: in a free-retry chamber a searcher clears 'random' 2.5x over. And to settle a disagreement between labs, rebuild the other lab's setup until it reproduces their numbers seed for seed, then change one factor.
Process tags: none
Evidence: Script: exp/EXP-45_stone_age_2x2.py | Evidence: exp/EXP-45-pilot.json/.jsonl, exp/EXP-45-full.json/.jsonl/.out
Reflection: EXP-45.md

Per-state greedy accuracy after 120 attempts (12 seeds) · accuracy

EXP-460.83's episodic memory on the Stone Age chain, read state by stateSUPPORTIVEteaching gameOn Stone Age V5's chamber, Cadence 0.83's episodic memory turns the default brain from in-attempt search into a learned chain: caregiver-corrected .193 -> .963 full-chain (per-state .58 -> .94), reward alone .092 -> .777 (.29 -> .75), matching upstream's own table on a chamber upstream did not build.

Question: Does 0.83's opt-in episodic memory make the default brain learn the Stone Age chain, read by an instrument search cannot pass?
Dates: 2026-10-13 (none)
Verdict note: 12 seeds x 2 x 3 arms; pre-registered, pilot read before the full run; 4 of 5 predictions held; memory arms near the ceiling at 120 attempts; one chamber (V5 replica, reproduces upstream's 0.82 V5 figure exactly); taught and tested on the same four states, so it shows the memory brain acquires the chain, not that it generalizes (EXP-48 tests that)
What it means: the strongest outside confirmation of a Cadence release claim we have produced. Upstream's own table (38.1 -> 98.7 corrected, 9.1 -> 73.2 from reward alone, 9.0 -> 97.8 after the caregiver leaves) lands on a chamber upstream did not build, read by an instrument (per-state greedy accuracy) that search cannot pass: .193 -> .963, .092 -> .777, .276 -> .955 sampled, and per-state .58 -> .94, .29 -> .75. Before the memory, the default brain's best full-chain numbers were search; with it, they are a chain. One thing upstream's table does not show and this does: after the caregiver leaves, the corrected chain's stage answers drift through `live` too (all four right fell 9 -> 5 of 12) while full-chain success holds, because the carried context covers the drifted stage. Upstream's caveat names the stall through `step` and says `live` avoids it; here the per-state reading drifts through `live`, and the full-chain reading hides it.
Lesson: Replicate a release claim with an instrument that search cannot pass; per-state accuracy also shows the drift that full-chain success hides (after the caregiver leaves, all-four-right fell 9 -> 5 of 12 while full-chain success held).
Process tags: none
Evidence: Script: exp/EXP-46_episodic_memory_stone_age.py | Evidence: exp/EXP-46-pilot.*, exp/EXP-46-full.json/.jsonl/.out
Reflection: EXP-46.md

Per-state greedy accuracy after teaching, default brain (12 seeds) · accuracy

EXP-47After the caregiver leaves: live vs stepBOUNDARYteaching gameUpstream's 0.83 caveat (the greedy chain stalls after time alone through step) did not reproduce: greedy full-chain stayed 12/12 on both paths. The drift is on the live side and only the per-state reading shows it: all four stages right fell 9 -> 5 of 12 through live, 9 -> 9 through step.

Question: After the caregiver leaves, does a memory brain's taught Stone Age chain drift through step, through live, or both, and when?
Dates: 2026-10-13 (none)
Verdict note: 12 seeds, paired (both paths from the same taught brain); pre-registered, pilot read first; 2 of 4 predictions held; one chamber, one budget, four check points
What it means: after the caregiver leaves, the full-chain reading says nothing changes (12/12 greedy solves on both paths), and the per-state reading says the mapping moves underneath: through `live` a third of the fully correct seeds lose a stage and keep it lost through 80; through `step` stages are lost and regained. Upstream's caveat about a greedy stall through `step` was not seen here; what we see instead is a `live`-side drift the full-chain reading hides. For reward-alone learners time alone helps on both paths, so "alone" is not one effect: it erodes what a caregiver installed and improves what the brain found itself.
Lesson: When a claim is about what survives without the teacher, read the mapping per state and at several times; full-chain success can stay perfect while the taught answers drift.
Process tags: none
Evidence: Script: exp/EXP-47_alone_live_vs_step.py | Evidence: exp/EXP-47-pilot.*, exp/EXP-47-full.json/.jsonl/.out
Reflection: EXP-47.md

Corrective + memory: seeds with all four stages right, of 12 · seeds

EXP-44Graded text: the readout's operating point or the brain's size?NULLlanguageNeither lever moved a Cadence brain on graded text: the 0.81 readout gene (.183 / .068, and 1 of 3 brains failed to settle at each target), a smaller actor step (.229) and twice the width (.213, more collapsed) all stayed at or below the control (.253), far from a table on the same grades (.346). The remaining gap reads as exploration.

Question: On graded text, is the limit the readout's operating point or the brain's size?
Dates: 2026-10-13 (iter34)
Verdict note: 3 seeds x 5 arms x 2 passes; pre-registered on 0.81; first run crashed on an unsettled brain, amended before the remaining runs, finished on a pinned 0.81; two arms have 2 usable seeds
What it means: on graded text the brain is not held back by its readout's set points or by its width at this length of training; the 0.81 gene hurt (as upstream found under reward), the smaller actor step changed little, and doubling the width made the brain more collapsed (top answer .88), not more accurate. What separates it from the lookup table on the same grades is most plausibly how it explores, which is the lever the decision rule names next. Cadence 0.83's episodic memory, a table-like record store inside the brain, is the obvious candidate for that lever (EXP-50 in the queue).
Lesson: When a pre-registered experiment outlives its version, pin the version instead of moving it, and count a crash as a result.
Process tags: crash mid-run (unsettled brain); amended and resumed on a pinned version
Evidence: Script: exp/EXP-44_operating_point.py | Evidence: exp/EXP-44-full.json/.jsonl/.out, crashed first attempt exp/EXP-44-full-crash-2026-10-11.out | Text: Alice ch.1 (train), ch.2 (held out), as EXP-42/43
Reflection: EXP-44.md

Greedy held-out accuracy on Alice ch.2 after 2 passes (3 seeds) · accuracy

EXP-48Does the episodic memory generalize the chain, or record it?SUPPORTIVEteaching gameTaught under four weathers and tested under four it never saw, 0.83's memory brain keeps the Stone Age chain (per-state .89 seen, .84 unseen; 9 of 12 seeds lose nothing) and keeps its .31 lead over the brain without memory. It generalizes over irrelevant novelty; it is not an answer key.

Question: EXP-46 taught and tested on the same states. Does the memory brain still get the chain right in situations it was never taught?
Dates: 2026-10-13 (none)
Verdict note: 12 seeds x 2 x 2 arms; pre-registered, pilot read first; 3 of 4 held (P2 failed toward generalization); novelty is irrelevant features only, not a new recipe
What it means: 0.83's episodic memory is not an answer key here. Its records are keyed by the whole situation, yet a chain taught under four weathers holds under four weathers it never saw (unseen .84 against seen .89), and its gain over the brain without memory survives the novelty almost intact (.31 of it on unseen situations). Where it does record, it is a minority of seeds, not the typical case. For the Noesis cross-read this is the condition that matters: transfer that survives a test the lesson never covered.
Lesson: An acquisition result becomes a learning result only when the test holds situations the lesson never covered.
Process tags: none
Evidence: Script: exp/EXP-48_generalize_or_record.py | Evidence: exp/EXP-48-pilot.*, exp/EXP-48-full.json/.jsonl/.out
Reflection: EXP-48.md

Per-state greedy accuracy under unseen weather (12 seeds) · accuracy

EXP-49Noesis-lite v1: a teacher market paid by measured transferBOUNDARYmarket & attacksPaying teachers by twin-ablation transfer against an untaught twin paid fakes 29% of the pot: random labels earned +.18 (about two thirds of a genuine teacher) because they knock a stuck student loose, and pay did not follow skill (Spearman .05). Genuine worth did survive time alone (.86).

Question: Does a market that pays teachers by measured transfer, on unseen situations and after time alone, pay genuine teachers by skill and price every fake at zero?
Dates: 2026-10-13 (iter35)
Verdict note: 3 market seeds x 6 students x 7 teachers, each lesson replicated; pre-registered, pilot read first (bar deliberately not raised); 1 of 5 predictions held
What it means: the first Noesis-lite market fails in a specific, useful way. Twin ablation priced against "no contribution" pays for anything that changes the student's trajectory for the better, and a random label does: a student left alone tends to get stuck on one action, and a stream of random corrections knocks it loose. That is real help, but it carries no information about the chain, so it is not the contribution the market means to pay for, and it is free to fake. The counterfactual has to be a null contribution of the same form (a random-label teacher), so worth measures information over and above being taught at all. The second failure, no skill ranking, is power: single-student worths swing by a full point, and 36 samples per teacher do not resolve differences of .1 between genuine teachers whose skills mostly sit between .75 and 1.0.
Lesson: Compare against a null contribution of the same form, not against no contribution; otherwise any perturbation that helps gets paid.
Process tags: genuine teacher skill did not vary as designed (training budget loosely sets skill)
Evidence: Script: exp/EXP-49_noesis_lite_market.py | Evidence: exp/EXP-49-pilot.*, exp/EXP-49-full.json/.jsonl/.out
Reflection: EXP-49.md

Mean worth per lesson (36 samples per teacher) · worth

EXP-52Noesis-lite v1.1: priced against a null of the same formBOUNDARYmarket & attacksPriced against a random-label teacher instead of no teacher, fakes stop earning on average (random -.07, wrong-chain -.21, echo -.27), but so do the genuine teachers: one who knows the whole chain is worth no more than one labelling at random (.661 vs .648). At 40 attempts the student learns from being corrected, not from what it is told.

Question: Priced against a null contribution of the same form, do fakes price at zero and does pay follow how much a teacher knows?
Dates: 2026-10-13 (iter35)
Verdict note: 3 blocks x 12 students x 7 teachers, each lesson replicated (72 samples per teacher); pre-registered, pilot read first, design kept; 1 of 5 predictions held; one lesson length (40)
What it means: EXP-49's failure was half fixed and half explained. Fixed: against a null of the same form, fakes no longer earn on average. Explained: genuine teachers earned in EXP-49 for the same reason the random teacher did, the correction event itself, not its content. At 40 attempts with sparse corrections, the memory student's gain from a perfect teacher equals its gain from a random one. For Noesis this is the sharpest version of the lesson so far: before pricing a contribution's information, check that the receiving process can take information in through that channel at all; a measure can be correct and still have nothing to measure.
Lesson: Before pricing a contribution's information, check that the channel carries information at all: compare a perfect teacher with a random one first.
Process tags: none
Evidence: Script: exp/EXP-52_noesis_lite_null_counterfactual.py | Evidence: exp/EXP-52-pilot.*, exp/EXP-52-full.json/.jsonl/.out
Reflection: EXP-52.md

Worth against the random-label null (72 samples per teacher) · worth

EXP-53Does the content of a teacher's labels matter?NULLteaching gameA teacher who knows the whole Stone Age chain and one who labels at random are within noise of each other at 40, 120 and 240 lesson attempts (content +.01 / +.11 / +.07). At short lessons the act of correcting is the whole effect (+.25 over untaught for either); the answer itself barely reaches the student.

Question: Is EXP-52's 'perfect teacher = random teacher' a property of short lessons, or does the label's content not get through this teaching channel at all?
Dates: 2026-10-13 (none)
Verdict note: 24 students per lesson length, paired twins; pre-registered, pilot read first; 1 of 4 predictions held; one teaching protocol (labels on executed mistakes), default memory brain
What it means: the Noesis-lite market had nothing to price, and this is why. Through `step(teacher=...)` on executed mistakes in guided windows, the default memory brain takes in the fact of being corrected far more than the answer it is given; a perfect teacher and a random one are within noise at every length tried. EXP-46's caregiver result (.94 at 120) is consistent with this: it never had a random-label control, so part of what looked like teaching was correction. For Cadence this is a question worth putting to upstream (is the teaching path meant to carry the label's content into the policy in a continuing life, or is it designed around settled lessons?); for Noesis it is the cleanest case yet of a channel that moves outcomes without carrying information.
Lesson: Before a market prices teaching, test that the teaching channel carries content: a perfect teacher against a random one, at the lesson lengths the market will use.
Process tags: none
Evidence: Script: exp/EXP-53_does_content_matter.py | Evidence: exp/EXP-53-pilot.*, exp/EXP-53-full.json/.jsonl/.out
Reflection: EXP-53.md

Content of the labels: know-4 minus random-label teacher (24 students per length) · accuracy

EXP-54Does teaching only where the answer differs let a label's content through?NULLteaching gameUpstream's opt-in rule that teaches only where the brain's own answer differs from the label leaves EXP-53's null in place: a perfect teacher and a random one stay within noise at 40, 120 and 240 lesson attempts (content -.01 / +.13 / +.00). Right after a mistake the brain's answer is mostly the mistake it just made, so the rule passes almost every lesson through.

Question: Was EXP-53's 'perfect teacher = random teacher' caused by lessons on answers the brain already gives (the readout saturation upstream PR #197 targets)?
Dates: 2026-10-14 (none)
Verdict note: 24 students per lesson length, paired twins; pre-registered, gate and pilot read first; gate held, 0 of 3 substantive predictions held; upstream PR #197 head (unmerged), one teaching protocol (labels on executed mistakes), default memory brain
What it means: PR #197's rule acts where a brain is shown answers it already gives, and this protocol hardly ever does that: the label arrives only after an executed mistake, and at that moment the brain's own answer agrees with the right action less often than chance. So EXP-53's null is not the readout saturation #197 names, at least not through mistake-only lessons. For #197 this is a narrow outside reading: on a continuing life with episodic memory, mistake-triggered teaching, the rule is close to a no-op for a correct teacher and costs nothing measurable (gene effect within 1.3 SEM of zero at every length, untaught twin bit-identical). It says nothing about the cases the PR targets (row-by-row sequences shown for many passes, repeated lessons on answered rows).
Lesson: Before testing a rule that filters lessons by the learner's own answer, measure how often that answer agrees with the label at the moments the protocol teaches; after mistakes it is below chance, and the filter has nothing to remove.
Process tags: none
Evidence: Script: exp/EXP-54_surprise_teaching.py | Evidence: exp/EXP-54-check.*, exp/EXP-54-pilot.*, exp/EXP-54-full.json/.jsonl/.out
Reflection: EXP-54.md

Content of the labels under the surprise rule: know-4 minus random-label teacher (24 students per length) · accuracy

EXP-56On an ambiguous chain, do misses wash the memory that matters out of Cadence's context?NULLmemoryCadence 0.83's temporal context beats place-only memory on an A/B/A/B chain with identical observations (sampled success .63 vs .33; clean greedy passes 5/48 vs 0/48, matching V7.2's 11/100 vs 0/100). Keeping misses out of the context did not concentrate its gain after misses as predicted; on these seeds it changed first tries, and clean greedy passes went from 5 to 17 of 48, a post-hoc reading confirmed in EXP-57 (where it also helped after misses, less than at first try).

Question: Is the fixed fading context weak on ambiguous sequences because every miss pushes the one decision that tells the two visits apart further back in the trace?
Dates: 2026-10-14 (none)
Verdict note: 24 seeds per arm and signal, paired; pre-registered, mechanical check and pilot read first; 1 of 4 held (the replication); one post-hoc reading declared; our rebuild of Huncho's V7.2 chamber, 120 attempts
What it means: the fixed .5 context does real work on Huncho's ambiguous chain (place 0 of 48 clean greedy passes, context 5), and the mechanism is not the one I proposed in the form I proposed it. I expected the gain to sit after misses, where the deciding step has faded; it sits mostly at the first try. Where hold did change something is the first try, and the greedy clean pass tripled, which fits a different mechanism the episodic guide already names: the context key splits one situation's records over every path that reaches it. Without hold, every different run of misses at a stage is a different path, so that stage's rewards and corrections are spread over many keys; with hold, they all land on the first-try key. That is post-hoc and is what EXP-57 tests.
Lesson: The arithmetic of a trace (0.5 to the power of the misses) can be right while the limit on behaviour lies elsewhere; a paired arm that removes only that link is what tells you.
Process tags: one reading (retry repeats the miss) added after the pilot and declared; full run reran all seeds
Evidence: Script: exp/EXP-56_ambiguous_chain_trace.py | Evidence: exp/EXP-56-pilot.*, exp/EXP-56-full.json/.jsonl/.out
Reflection: EXP-56.md

Clean greedy passes of the ambiguous chain, of 48 (24 seeds x 2 signals) · count

EXP-57Keep misses out of the temporal context: confirmed on fresh seedsSUPPORTIVEmemoryOn an A/B/A/B chain with identical observations, letting only decisions that changed the observation into Cadence's temporal context takes clean greedy passes from 4 of 96 to 38 of 96 at 120 attempts (36 vs 2 discordant pairs, p < .0001), 60% with caregiver corrections, and keeps a lead at 240 (23 vs 9 of 48). Cadence already applies this rule to its replay path; the key that stores its memories does not.

Question: Is EXP-56's post-hoc result (holding misses out of the context triples clean greedy passes) real on fresh seeds, and does it last to 240 attempts?
Dates: 2026-10-14 (none)
Verdict note: fresh seeds, pre-registered, EXP-56 as the pilot; 3 of 4 held (the predicted-flat sampled success rose instead); 96 pairs at 120 attempts, 48 at 240; instrument-level rule on our rebuild of Huncho's ambiguous chain
What it means: Cadence already applies this rule to its replay path (`_extend_paths`: a decision taken on the observations of the previous decision replaces it, because it "left the situation as it was"), but not to the temporal context that keys its episodic records. Applying the same rule to the key, with no learning at all, is the largest single lift we have measured on the ambiguous chain. It is one concrete, non-learned answer to Bernhard's "which memories matter": here, the decisions that changed something. On Huncho's V7.3 question: with corrections, the plain context's clean passes grow with training (2 of 48 at 120 to 7 of 24 at 240), and from reward alone they barely move (2 of 48 to 2 of 24); the rule's lead holds at both horizons.
Lesson: An effect found in a reading you did not predict needs a confirmatory run on fresh seeds before it is said out loud; here it came back larger.
Process tags: none
Evidence: Script: exp/EXP-57_confirm_hold_greedy.py (reuses EXP-56's chamber, brain, trace rule and readings) | Evidence: exp/EXP-57-full.json/.jsonl/.out
Reflection: EXP-57.md

Clean greedy passes at 120 attempts, fresh seeds (of 96) · count

EXP-55Demonstrations at every decision, with and without upstream's surprise ruleBOUNDARYteaching gameShowing the right action at every decision does not carry content either: at 240 attempts it leaves the student below one shown random actions (-.16, 3.4 SEM), the readout saturation upstream's PR #197 names. Its surprise rule removes that harm (+.19) but content stays near zero. With episodic memory on, the rule judges against the cortex's answer (right 34%) while the brain acts on the memory's vote (right 97%).

Question: Does a teacher's content reach the student when it demonstrates at every decision instead of only after mistakes, and does teaching only where the answer differs (#197) help?
Dates: 2026-10-14 (none)
Verdict note: 24 students per lesson length, paired twins; pre-registered, pilot read first; 2 of 4 held (one only on means); upstream PR #197 head (unmerged); side check declared
What it means: two outside readings for #197 and one answer for Noesis-lite. For #197: (1) its stated mechanism shows up here: repeated lessons on answers the brain already gives make a right-answer teacher worse than a random one at 240 attempts, and the rule removes that (+.19); (2) with `memory_choice=True` the rule reads the cortex's answer, which is right a third of the time while the brain's behaviour, carried by the memory's vote, is right almost always, so the rule keeps teaching rows the brain already handles and gates the memory's demonstration records on the cortex's view. For Noesis-lite: in three schedules now (after mistakes, every decision, every decision with the rule), what a teacher says does not reach the student as content in this brain; the market still has nothing to price through this channel.
Lesson: A filter keyed on the learner's own answer must use the answer the learner acts on; when a second system shapes behaviour, the first system's answer is the wrong thing to filter on.
Process tags: none
Evidence: Script: exp/EXP-55_every_decision_demonstrations.py | Evidence: exp/EXP-55-pilot.*, exp/EXP-55-full.json/.jsonl/.out
Reflection: EXP-55.md

Content at 240 attempts: right-answer minus random-answer teacher (24 students) · accuracy

EXP-60The hold rule on the normal chain, where the inventory is visibleSUPPORTIVEmemoryOn the ordinary Stone Age chain, where the brain can see its inventory, keeping misses out of the temporal context changes nothing: 75 vs 75 clean greedy passes of 96, and place-only memory does as well as context (39 vs 40 of 48). The 4% to 40% jump in EXP-57 is specific to chains where the observation does not show progress.

Question: Is EXP-57's gain specific to the hidden-inventory chain, or does the hold rule help on the normal chain too?
Dates: 2026-10-14 (none)
Verdict note: fresh seeds, pre-registered, 3 of 3 held; 96 hold/context pairs, 48 place/context pairs; scope check before reporting EXP-57
What it means: the 4% to 40% jump in EXP-57 is a property of chains where what the brain sees does not show how far it has got, which is exactly the case Bernhard's "learn which memories matter" is about. On the ordinary chain the brain already does well (78% clean greedy passes with or without the rule) and the rule is neutral, so turning it on costs nothing where it is not needed. Whether it costs something where an action is correct but invisible is EXP-59.
Lesson: Before reporting a mechanism's gain, run it where the problem it fixes is absent; a gain that vanishes there is evidence it fixes that problem.
Process tags: none
Evidence: Script: exp/EXP-60_hold_on_visible_chain.py (EXP-56's brain, trace rule and readings; EXP-45's observation) | Evidence: exp/EXP-60-full.json/.jsonl/.out
Reflection: EXP-60.md

Clean greedy passes of 96 at 120 attempts: hidden inventory (EXP-57) vs visible (EXP-60) · count

EXP-58A teacher's content finally gets through: the delayed-credit brainSUPPORTIVEteaching gameOn EXP-45's delayed-credit brain, a right-answer teacher takes the student to .93 per-state accuracy on unseen weather at 120 attempts, a random-label teacher to .46 (content +.47, 11 SEM), and random labels are worth nothing. After four nulls on the default memory brain, this is the first teaching channel that carries content, so a Noesis-lite market finally has something to price.

Question: Is the missing content in EXP-52 to 55 a property of teaching through step(teacher=...), or of the default brain?
Dates: 2026-10-14 (none)
Verdict note: 24 students per lesson length, paired twins; pre-registered (amended before any data: alone phase through step), pilot read first; 3 of 3 held; confound with the alone-phase path stated, EXP-61 splits it
What it means: the four nulls before this (EXP-52 to 55) were not "teaching through labels cannot carry content in Cadence"; on a slower-actor, strong-critic brain without episodic memory, it carries a lot. That fits EXP-45 (the same brain learned the Stone Age chain from every signal while the default brain learned from none) and EXP-55's side check (on the default brain, behaviour follows the episodic vote, not the cortex the labels teach). For Noesis-lite: there is finally something to price, and a market can now be tested against the form-matched random-label null on this brain.
Lesson: When one setup returns null after null, change the thing it holds fixed before concluding the channel is empty; one operating point is not the library.
Process tags: none
Evidence: Script: exp/EXP-58_content_delayed_credit_brain.py (EXP-53's chamber, protocol, seeds and readings; EXP-45's delayed-credit brain) | Evidence: exp/EXP-58-pilot.*, exp/EXP-58-full.json/.jsonl/.out
Reflection: EXP-58.md

Content (right-answer minus random-label teacher), 24 students per length · accuracy

EXP-59Where the hold rule breaks: a correct action that changes nothing visibleSUPPORTIVEmemoryIf gathering wood is correct but invisible, keeping unchanged-observation decisions out of the context erases it: first-try accuracy at the step after it drops .16 (3.7 SEM), clean greedy passes fall from 9 to 2 of 96, and with corrections sampled success falls from .81 to .48. The rule helps only when 'nothing visible changed' really means 'nothing happened'.

Question: Does EXP-57's hold rule break where a correct action leaves the observation unchanged?
Dates: 2026-10-14 (none)
Verdict note: 48 fresh seeds per signal, pre-registered, 3 of 3 held (the predicted break); 120 attempts; our rebuild of the chamber
What it means: EXP-57, 59 and 60 together pin the rule down. It helps a lot when progress is hidden and misses are the only unchanged-observation decisions (EXP-57), does nothing when progress is visible (EXP-60), and hurts when a correct action is invisible (EXP-59). The memory that matters is "the decision that changed something", and the observation is only a proxy for that. A working gate needs a signal that tells a miss from an invisible success: an outcome, a reward, or the brain's own forecast error. Cadence's replay path makes the same observation-equality judgment (`_extend_paths`), so it may share this blind spot; untested here.
Lesson: Name the boundary of a fix and test it before proposing the fix; the boundary belongs in the same message as the gain.
Process tags: none
Evidence: Script: exp/EXP-59_hold_boundary.py (EXP-56's brain, trace rule and readings; a new observation map) | Evidence: exp/EXP-59-full.json/.jsonl/.out
Reflection: EXP-59.md

First-try accuracy at the step after the invisible correct action (pooled, 96) · accuracy

EXP-61It was the brain: the default memory brain blocks a teacher's contentSUPPORTIVEteaching gameThe default memory brain run through EXP-58's exact protocol (alone phase through step, not live) still takes in no content: right-answer minus random-label teacher is -.05 at 40 attempts and +.02 at 120, against +.47 on the delayed-credit brain. Every arm lands within about .06 of EXP-53, so the alone-phase path was not washing content out. The brain's operating point blocks it, and Noesis-lite v2 runs on the delayed-credit brain.

Question: Is it the default brain, or the time alone through live, that hid a teacher's content in EXP-53?
Dates: 2026-10-14 (none)
Verdict note: 24 students per lesson length, paired twins, EXP-53's seeds and world draws; pre-registered, no pilot (EXP-53 fixed the window); 2 of 2 held
What it means: EXP-58's confound is resolved in favour of the brain. On the default composed brain with episodic memory, labels work as a nudge: being corrected at all helps at 40 attempts (+.27), whatever the labels say, and by 120 the untaught twin catches up and the teacher adds nothing. On the delayed-credit brain, the same labels through the same `step(teacher=...)` call carry almost all of their content. This fits EXP-55's side check (on the default brain, behaviour follows the episodic vote, not the cortex the labels train). For Noesis-lite: a teacher market built on the default brain would be pricing jolts, not knowledge, so v2 runs on the delayed-credit brain.
Lesson: When two things differ between a null and a hit, swap one of them alone before writing the story.
Process tags: none
Evidence: Script: exp/EXP-61_default_brain_step_alone.py (EXP-58's protocol with EXP-53's brain) | Evidence: exp/EXP-61-full.json/.jsonl/.out
Reflection: EXP-61.md

Content (right-answer minus random-label teacher) at 120 attempts, 24 students · accuracy

EXP-63Key the hold on the outcome: the gain stays, the invisible-action break goesSUPPORTIVEmemoryHolding out of the context key only the decisions the world answered as failures keeps EXP-57's gain where progress is hidden (17 vs 4 clean greedy passes of 48), stays neutral where it is visible (37 vs 34), and turns EXP-59's break into a gain where a correct action is invisible: 19 vs 5 clean passes of 96 against the plain context (p .004), and the step after the invisible action no longer drops (+.07 instead of -.15). The catch: nothing Cadence receives here tells a miss from the invisible success, so a library gene keyed this way needs a failure signal from the world.

Question: Does a gate keyed on the outcome (hold only failed decisions) keep the hold rule's gain and remove its invisible-action break?
Dates: 2026-10-15 (none)
Verdict note: pre-registered (514e510) before check, pilot and full run; fresh seeds; 5 of 5 held; 96 pairs on the invisible chain, 48 on the hidden and visible chains; the outcome is read from the chamber as an oracle
What it means: the memory to keep out of the key is "a decision the world answered as a failure", and the observation was only a stand-in for it. With the real property as the trigger, the rule no longer has a boundary at invisible actions on these chains; with the stand-in, it does (EXP-59, replicated here). The catch is the signal: in this chamber nothing Cadence receives tells a miss from the invisible WOOD. The observation is identical and the per-step reward is 0 for both under the natural signal; only the chamber's own success flag separates them, and the gate here reads it as an oracle. So for #202 there are two honest versions: an outcome-keyed gene that needs a per-decision failure input from the world (an explicit flag, or a convention such as a negative reward marking a failed action), and the observation-keyed gene, which needs no new input but keeps EXP-59's boundary. Under corrective teaching there is a partial in-library signal (a teacher label arrives after a guided miss, 4 decisions in every 12), untested as a gate here.
Lesson: When a rule's trigger is a proxy for the property that matters, run it keyed on the property itself, even through an oracle: it separates a wrong idea from a wrong proxy and names the signal a real implementation needs.
Process tags: one unpredicted cell (visible chain, corrective, stage-1 first try -.11, 3 SEM) not seen on EXP-60's 48 seeds for the identical rule; recorded, not claimed
Evidence: Script: exp/EXP-63_outcome_gate.py (EXP-56's brain, signals, trace rule and readings; the observations of EXP-56/57, EXP-60 and EXP-59) | Evidence: exp/EXP-63-check.out, exp/EXP-63-pilot.*, exp/EXP-63-full.*
Reflection: EXP-63.md

Clean greedy passes of 96 on the invisible-action chain (A, A, B, C), 120 attempts · count

EXP-65The outcome gate on signals Cadence receives: the label is safe but sparse, the forecast error is blindBOUNDARYmemoryKeyed on the corrective teacher's label, the hold gate never holds a correct move but covers only taught decisions (a third of the misses): 9 clean greedy passes of 48 on the invisible-action chain against 5 for the plain context (p .39) and 19 for the oracle gate. Keyed on the brain's own forecast error it is blind: it cannot tell a miss from the invisible correct action (AUC .525) and does worse than no gate. In this chamber nothing Cadence already receives stands in for the world's failure flag.

Question: Can the outcome-keyed hold gate run on a signal Cadence already receives (the teacher's label, or its own forecast error) instead of the chamber's success flag?
Dates: 2026-10-16 (none)
Verdict note: pre-registered (93d5645), amended before the full run (75dfc6a, check scope and review fixes, no prediction changed); P2 P4 P5 P6 held, P1 and P3 failed; 48 pairs per signal on the invisible chain, 24 on the hidden; comparators are EXP-63 rows on the same seeds, recomputed identically
What it means: the decomposition says where the oracle gate's gain lives and why the label cannot reach it. out5t (the oracle during training only) reproduces all of out5's clean passes, so the gain is made while the brain learns, not while it is read, and it shows up as stage-1 first-try accuracy (+.19 over the plain context): with misses held, the record of the eventual right move lands on the first-try key. Two thirds of the training decisions are autonomous, and that is where most misses happen; the teacher only labels guided misses, so lab5 holds 32% of the misses and loses exactly at stage 1 (-.19 against out5t). The label is the right kind of signal (precise, never wrong about a correct move) with the wrong coverage. The brain's own forecast error is the opposite failure: it is available at every decision but carries no information about the one distinction that matters here, because a miss and the invisible WOOD both leave the same observation and both pay 0. Read-time holding matters for sampled success (out5 beats out5t by .08) but not for clean passes, as the design predicted.
Lesson: Before keying a gate on an available signal, measure its coverage of the decisions the oracle acted on, not only its precision; and use a metric one phase cannot touch (a clean greedy pass has no misses, so read-time holding cannot change it) to locate where an effect is made.
Process tags: first check failed one item scoped too wide (the library resets the context at done); rescoped and reported before the pilot, comparator arms are EXP-63 rows on the same seeds (recomputed identically), not fresh lives
Evidence: Script: exp/EXP-65_inbrain_gate.py (imports EXP-63, which imports EXP-56: same chambers, brain, signals, trace rule and readings) | Evidence: exp/EXP-65-check.out, exp/EXP-65-pilot.*, exp/EXP-65-full.*
Reflection: EXP-65.md

Clean greedy passes of 48 on the invisible-action chain, corrective teaching, 120 attempts · count

EXP-62Noesis-lite v2: transfer prices skill on a content-taking brain; the zero point is the best fake, not noiseBOUNDARYmarket & attacksOn the brain that takes in what a teacher says, priced against a committed random-label null, the market finally ranks skill: teachers who know 1, 2, 3 or 4 stages are worth +.054, +.068, +.138 and +.236 (Spearman .40), while wrong-chain, echo, random labels and abstaining all price below zero and fakes take 4% of pay. The one miss, a labeller that only avoids the last mistake pricing at +.023, did not replicate on fresh students (EXP-62c): it is noise in a band of uninformative arms about +-.03 wide.

Question: On a brain that takes in teacher content, priced against a committed null, does measured transfer order teachers by skill and price every task-blind fake at or below zero?
Dates: 2026-10-17 (iter36)
Verdict note: pre-registered (e6d6d82), pilot + window decision + amendment A1 before the full run (aaafac7); 4 of 5 CONFIRM criteria held, the zero-point criterion failed (anti-echo +.023, 1.2 SEM); 72 shared students, lesson 40 decides, lesson 80 exploratory; CORRECTION after EXP-62c: the anti-echo leak reading did not replicate on fresh seeds and is withdrawn
What it means: for the first time in this program, transfer prices skill on a brain that takes in content, against a committed null: the know-k ladder is ordered, Spearman is .40 (.53 at 80), know-4 clears .2, and wrong-chain, echo, random and abstain all price below zero, with fakes taking 4% of pay. The one failure is informative rather than a fooling: worth follows label information almost one-for-one across every arm, and the corrective schedule hands any labeller one elimination bit per mistake. So the measure is pricing information correctly, including information the protocol leaks. The zero point therefore has to be the best fake in a declared class (here: a labeller that sees only the executed mistake, of which anti-echo is the best possible), not uniform noise. That is the pre-registered "decisive for Noesis" reading in substance, though its formal 2-SEM trigger did not fire.
Lesson: Check whether a small failing gap replicates before building an explanation on it; a near-perfect correlation across arms says nothing about the smallest gap.
Process tags: the registered window rule picked lesson 40 over the predicted 80 (ceiling guard judged on 3 pilot students); 80 ran as a declared exploratory arm, the counterfactual flipped vs prediction (random-label null above untaught); the fixed pooled rule handled it, the label-information correlation and the anti-echo re-pricing are post hoc and labelled exploratory
Evidence: Script: exp/EXP-62_content_market_committed_null.py | Evidence: exp/EXP-62-pilot.*, exp/EXP-62-full.* (outputs, json, jsonl)
Reflection: EXP-62.md

Worth vs the committed null, lesson 40, 72 students (per-state accuracy on unseen weather) · worth

EXP-62cFresh students, zero declared in advance: the skill price replicates; the zero point is a noise bandBOUNDARYmarket & attacksOn 72 students the measure had never seen, teachers who know 1, 2, 3 or 4 stages are worth +.073, +.162, +.300 and +.436 against the declared zero (Spearman .61), and even the weakest beats every uninformative arm by more than two standard errors. The fakes that carry no information (random labels, abstaining, the null, a labeller that avoids the last mistake) form a band about plus or minus .03 wide whose order shuffles between runs, so a rule requiring every fake to sit at or below one chosen fake fails by chance.

Question: With the zero point declared in advance as the best fake in the schedule-only class, does transfer price skill on fresh students?
Dates: 2026-10-17 (iter37)
Verdict note: pre-registered (aa364c5); 4 of 5 CONFIRM criteria held; the zero-point criterion failed from the other side (the declared zero drew low); 72 fresh students, lesson 80
What it means: the skill price replicates on fresh students and is the strongest yet (Spearman .61; even know-1 clears every uninformative arm by more than 2 SEM). What did NOT replicate is EXP-62's reading that anti-echo carries a measurable extra bit: on fresh seeds it priced below the null. The uninformative arms (null, untaught, random, anti-echo) form a band about +-.03 wide at n = 72, and their order shuffles between runs. So the zero point is fuzzy at that scale, and no single fake is a stable zero.
Lesson: Set the zero as the pooled mean of a declared uninformative class and test fakes with a noise allowance plus a separation test against the weakest genuine contributor; a point-estimate every-fake-below-zero rule needs far more data than the effect it guards.
Process tags: the decision rule (every fake mean <= 0 against a single noisy fake) is a max-of-noisy-estimates test that fails by chance when fakes are equal in truth; recorded as a design flaw, verdict unchanged, the paired and pooled-zero reads are post hoc and exploratory
Evidence: Script: exp/EXP-62c_best_fake_zero.py (runs EXP-62's harness unchanged under declared settings) | Evidence: exp/EXP-62c-full.*
Reflection: EXP-62c.md

Worth vs the declared zero (anti-echo), lesson 80, 72 fresh students · worth