Feel the Tipping Point Yourself

Stop taking my word for it.

You're going to run two memories side by side. Same notes. Same questions. Same amount of time. One cleans up after itself; the other just saves.

You need nothing installed. The starter kit has no dependencies — plain Python and SQLite, both of which came with your computer.

1. Run it

cd phantom-university-starter
python3 demo.py

It builds two memories, fills both with the same 12 notes that matter and 60 low-value log entries on the same topics, then simulates 30 nights of someone using them identically.

Here's what comes out:

  RECALL PRECISION — fraction of results the user actually wanted

    accumulator    25.0%  of 24 results
                  noise returned: log 000 insulin note, log 012 insulin note,
                                  log 024 insulin note
    hippocampus   100.0%  of 6 results
    difference    +75.0%

Read the two numbers next to the percentages, because they matter as much as the percentages.

The accumulator returned 24 results, six of which were wanted. The hippocampus returned 6 results, all six wanted.

The accumulator didn't fail to find your notes. It found them and buried them in eighteen others.

2. The receipt

Below that, the demo prints something the other system structurally cannot:

  WHAT THE HIPPOCAMPUS FORGOT — and can prove

    [prune] log:42aa8af8… -> log:413a526c… w=0.05 used=0
    [prune] log:1f0768c8… -> log:86f908dd… w=0.05 used=0
    ... 29 ledger entries. Every one recoverable.

  The accumulator cannot produce this list at all.
  It does not know what it should have forgotten.

Every removal, with the reason attached: weight had fallen to 0.05, used zero times. Written down before the deletion, so it can be undone.

That last line is the point. The accumulator can't produce this list — not because nobody wrote the feature, but because it never recorded what was used. The information required to make the list never existed.

3. Now make the gap disappear

This is the most important thing in this lesson.

Open demo.py, find this line near the top:

NIGHTS = 30

Change it to 5. Run it again.

    accumulator    25.0%
    hippocampus    25.0%

The gap is gone. They're identical.

Five nights isn't long enough for anything to fade, so nothing is prunable, so cleanup has nothing to do. The two systems are indistinguishable.

Try 15. Still identical.

Try 30. The gap appears. Try 45, 60, 90 — it holds at 100%.

4. Sit with what that table means

Cleanup cannot be demonstrated on a fresh install. Its value depends entirely on time and accumulation.

Which produces a genuinely nasty trap:

By the time you can feel that you need this, you have already lost the history you would need to apply it to everything you saved before.

Every note from those first months has no usage record. Cleanup looks at them and sees things that were apparently never useful, because nobody was counting.

You build this part before you need it, or you don't get to build it.

That's the whole argument for why the three extra columns from the last lesson have to exist on day one — and now you've watched the reason rather than been told it.

5. Something honest about this demo

Two things the demo tells you about itself, which are worth more than a clean result.

It reports its own dead stage. In the output you'll see:

    pipeline totals: 29 links pruned, 0 merged, 0 replay lifts
    (replay lifts 0 — every query here is a direct keyword hit, so no
     association link ever earns access_count. Dream has nothing to
     replay. Honest limitation of this demo's query pattern, not a bug.)

One of the five nightly stages did nothing at all, and the demo says so instead of quietly reporting a total that looks fine. A pipeline that always claims success is a pipeline you can't learn anything from.

This exact demo caught a real bug. Before you got this kit, the table above looked different: 100% at night 30, and back down to 25% at night 60.

The cause was one line in the reward stage:

r["salience"] or 0.5      # 0.0 is FALSY in Python

When a memory's importance decayed all the way to zero — the exact state the whole system works toward — that or treated it as "no value" and reset it to the 0.5 default. Dead memories sprang back to life and started decaying again, forever, on a 25-night cycle.

Every nightly run reported success. All 27 tests passed. The only thing that revealed it was running the demo for longer than anyone had run it before and noticing a number moved the wrong way.

There are 28 tests now. The new one asserts that a salience of zero stays zero, and it fails if you put the or back.

That story is the course in miniature: a control that silently doesn't apply is indistinguishable from one that does, until you measure the outcome instead of the status.

Try it

6.1 Run demo.py unchanged. Find the 24-vs-6 result counts.

6.2 Set NIGHTS = 5, run, confirm the gap vanishes. Put it back to 30.

6.3 Read the ledger lines. Every one says used=0. Ask yourself what would have happened if the counter had been broken and everything said used=0 regardless — how would you tell those two situations apart from this output?

(Answer: you couldn't. That's Course 04's four most important lines of code.)

6.4 Open brain/consolidate.py and read the constants at the top. You don't need to understand them yet. Notice there are about a dozen, and that each one is a decision about what your memory should be like:

DECAY_AFTER_DAYS = 7      SALIENCE_SHIELD  = 0.14
DECAY_FACTOR     = 0.85   PRUNE_MIN_AGE_DAYS = 14
MIN_WEIGHT       = 0.05   GRACE_DAYS = 7

Course 09 is where you learn what each one costs you.

You finished this course

You now know the thing most people building AI memory don't:

• Saving everything makes it worse, and the decline is invisible
• A faster machine and a bigger context window do not fix a growth problem
• Three of the seven jobs are the ones nobody builds
• Three columns must exist in your first table, or cleanup can never be added
• And you've watched the difference with your own eyes

Next course: you build it. The table, the saving, the finding, the connecting — and the four lines that record what was used, which everything afterwards depends on.