What an agent may conclude from its own attempts, and what has to be true before it acts on it

Twelve steps, four parts, three runnable labs — eight switchable layers, two scores, and the gap between them.

Introduction

You gave an agent the ability to write notes to itself — rules, heuristics, a file it edits, a prompt it appends to — and the number went up. This volume is about which number went up, and whether it is the one you care about.

The shape of every self-learning loop

However it is dressed up, it is this. Steps 2 and 3 are where the subject lives; step 4 is where the engineering effort usually goes.

#	the agent…	where the subject lives
1	attempts the task
2	finds out how it went	this is where the result is decided
3	works out which part went wrong	step 6
4	writes a rule	where the effort usually goes
5	attempts the next task with the rule in hand

A wrong memory makes one answer wrong. A wrong rule makes every later attempt wrong, in the same direction, while looking like progress.

What self-learning engineering is

Self-learning engineering is the practice of deciding what an agent may conclude from its own attempts, and what has to be true before it is allowed to act on that conclusion.

Eight switchable layers in four phases. This volume measures what each one buys by holding the agent fixed — it is scripted and deterministic — and turning the layers on and off around it, over 102 measured configurations. A change in the outcome can only have come from a layer.

phase	the question it answers	layers	stages
keep a record	what did I do, and did it work?	`tracing` · `outcome`	5–6
work out what went wrong	which step, and what rule follows?	`credit` · `extraction`	7–8
check before you believe it	does the rule hold, and hold on something new?	`validation` · `unseen`	9–10
tidy the rule book	do the rules argue, and do they still pay?	`conflict` · `retirement`	11–12

The headline, up front

The layer that fixed the work made the dashboard worse. On one lab the agent reaches a perfect visible score of 40 of 40 while the real score is 38 of 40 — one of its rules edits the test file, so the check reports success on a program that still has a bug. Adding the layer that catches this drops the visible score to 38 of 40 and leaves the real score exactly where it was. Anyone tuning against the visible number would have reverted the change.

And on a second lab, nothing helps at all. A perfect visible score sits on two confidently wrong answers, with all eight layers switched on and not one of them able to see it — because the cheap check cannot tell a plausible cause from the right one.

And on a third, learning simply works. Real score 3 to 20 of 20 in a single round, and every held-out task correct. The exploit was sitting in its rule space and was never proposed, because the honest rules worked first. A volume that showed only failures would be lying about what this loop does most of the time.

The two scores

Everything here rests on a distinction that is not a design choice. Only one of these can be inside the loop: if the agent could run the expensive one continuously, it would be the cheap one, and you would need a new one behind it.

	the score the agent can see	the score that counts
what it is	a cheap check, runnable as often as you like	the real standard the work is held to
who runs it	the agent, every round	you, occasionally
in the loop?	yes — necessarily	no — necessarily
examples	a test suite, a linter, a regex, a rubric prompt	a careful review, a pristine test, whether the customer complained

Is this for you?

if…	then
your agent edits a file that your checks read	step 7 — one free rule closes it
your score went up and you cannot say what improved	step 4, then step 11
you are about to add more checking layers	step 5. Four of the eight change nothing in any lab
your cheap check accepts a plausible answer as a right one	step 9. That is the case where nothing in this volume helps
you hold tasks back and the held-out score is rising	step 11 — that is a different instrument for a different failure

The three labs

Eight tasks each — five to practice on, three never practiced on — and three rounds of learning. What differs between them is a property of the scorer, not of the agent or the task.

	the agent's job	can the cheap check be satisfied without being right?	outcome
A · `fix-a-test`	repair a program until a test file passes	yes, by editing the test file	a defense works
B · `triage`	name the cause of a failure from a crash report	yes, by naming any framework the report mentions	nothing helps
C · `answer`	state a figure from a policy document	not by any rule it proposed	learning simply works

How to read the source labels

label	means
concept	argued from first principles, quotes nothing from a lab
measured	a lab compares configurations and reports the difference
hands-on	you run it on your own material

Nothing here is a benchmark. Eight tasks per lab, three rounds, one scripted agent, and one rule space fixed in the open. The gaps are counts of points, not rates, and nothing here licenses a claim about how often self-learning agents cheat in general. Step 12 lists every limit, starting with the one that makes step 6's headline figure an artifact.

Build state: 12 of 12 steps written.

Part 1 — Concepts

01What a self-learning agent writes downA policy the agent wrote from its own attempt and reads on a later one. Not weights, not a transcript, not a memory — a rule about how to act.concept

02The two scoresThe score the agent can see and the score that counts. Only one of them can be inside the loop, and the distance between them is the subject.concept

03Why a loop drifts toward the score it can runThe agent may run the cheap check as often as it likes, so the cheap check is the objective in practice. Mechanical, not a moral failing.concept

Part 2 — Method

04The gap, and its two originsTwo causes that look identical on a dashboard: a lenient scorer, or a rule that games it. One lab opens its gap while merely scoring; another while learning.measured

05The eight layers, in four phasesThe headline: switched on in order, the visible score reaches a perfect result and then falls — and the layer that makes it fall is the one that fixed the work.measured

06Credit assignment, and why a perfect score here is bad newsThe blamed step is right every time it was asked. That is an artifact of very short attempts, and the step exists to say so.measured

07Validation, and the one rule that needs no answer keyOf the refused candidates only one is cheating; the rest are ordinary bad guesses. The rule that catches the cheat is a set membership test.measured

Part 3 — Evidence

08Lab A: a defense that worksThe gap opens at extraction and validation closes it, lowering the visible score. All of the learning happens in the first round.measured

09Lab B: nothing helpsA perfect visible score on two confidently wrong answers, with all eight layers on and not one of them able to see it.measured

10Lab C: learning simply worksPerfect on practice and on held-out tasks, with no gap at any point — and the exploit sat in the rule space unproposed.measured

Part 4 — Result

11What a perfect visible score is evidence ofThe same score sits on a real bug, on two wrong answers, and on genuine success. Two instruments separate them and neither is the score.measured

12Limits, and your own agentWhat these numbers do not support, the five files to rewrite, and the question to ask before letting an agent write its own rules.hands-on