Self-Learning Agents Concepts › What a self-learning agent writes down
01 · part 1, conceptsconcept

What a self-learning agent writes down

A self-learned rule is a rule the agent wrote from its own attempt and follows on a later one. Nobody reviewed it, and it says what to do, not what happened.

The definition

Both halves matter:

  • The agent wrote it. Nobody checked it on the way in.
  • It’s a rule, not a record. It says what to do next time, not what happened last time.

Four things it isn’t

“Learning” usually means one of four things, and three of them aren’t this subject:

what it changesis it this volume?
training, fine-tuningthe model’s weightsno: nothing here retrains a model
a transcriptnothing; it’s a recordingno: it says nothing about how to act
a memorya record of what was trueno: a memory is a claim about the world
a self-learned rulewhat the agent will do next timeyes

The difference from a memory is the one to be careful about, because the machinery looks the same: something is written in one attempt and read in a later one.

  • A memory says the cap is 180. You can check it against the world.
  • A rule says turn accented letters into plain ones first. You can only check it against outcomes, and Part 2 is about what happens when the outcome you check against is the wrong one.

The shape of the loop

attempt one step 1 step 2 step 3 failed the rule book written by the agent reviewed by nobody a policy, not a record it says what to do next time attempt two step 1 step 2 step 3 carried in and every attempt after this one a wrong rule is wrong in the same direction, every time
A rule written once and carried into every later attempt. Read it left to right.
Nothing in this drawing is measured. It shows the mechanism; step 4 measures it.
  • The first attempt fails, and a rule falls out of it into the book.
  • The next attempt picks the rule up and carries it into its own steps, and so does every attempt after that.
  • Nothing reviews the rule on its way in.

Why the rule is the risky part

A wrong memory makes one answer wrong. A wrong rule makes every later attempt wrong, in the same direction, while looking like progress. It’s small, cheap to write, and applies to everything after it.
Try it. In the labs folder, run:
cd fix-a-test && python3 run.py --rules

The rule book the complete loop ends with: each rule, when it applies and what it does, and every rule it refused.