The AI that
practices
Reasoning compiles into reflex, and the skill lives in the database
Every AI agent you've ever used has a strange disability: it cannot get better at its job.
Watch a reasoning model solve the same class of problem for the thousandth time. It burns just as many tokens and takes just as long as it did on the first. All that chain-of-thought it produced along the way — thousands of careful, expensive deliberations — thrown away, every single time. Your agent's millionth invoice reconciliation costs exactly what its first one did. There is no mechanism, anywhere in the modern stack, by which an agent's experience becomes skill.
Humans don't work like this. The first time you tie your shoes, it takes your full attention. The ten-thousandth time, your hands do it while you talk. Psychologists call the shape of that speedup the power law of practice, and it's one of the most reliable findings in all of cognitive science: effort falls as a power of repetitions, on every task ever measured.
Here's the thing. Machines that practice were invented in 1983. Then they were killed — by their own memory. We rebuilt the mechanism on a different memory, measured everything, and the death certificate doesn't reproduce. At the end of this page, a live Claude agent's reasoning bill falls 4× in 120 problems because its thinking compiles into reflexes.
Allen Newell's lab built SOAR around a single beautiful mechanism called chunking. When SOAR hit a problem it had no rule for, it stopped and solved it the slow way: step-by-step search. Then it did the part that matters: it compiled the entire deliberation into a new rule. Same situation next time? No search. One match, instant answer. Deliberation became reflex, exactly the shoe-tying transition, and SOAR's speedup curves matched the human power law of practice. Newell thought chunking might be the learning mechanism of cognition.
It worked. And then it died, of something with a name and a date.
The utility problem (Minton, 1988): in a rule memory, matching costs time per rule. Every chunk SOAR learned made its matcher slower. Past a few thousand chunks, systems that learned became measurably slower than systems that didn't. Learning made you worse. The field wrote the obituary and moved on. Forty years later, the approaches it moved on to still cannot turn experience into skill.
There was a second wound, quieter but just as deep: brittleness. A compiled rule fired only on situations identical to the one it came from. Almost-the-same got you nothing.
Flip through every rule, every time. More knowledge = slower brain. Learning made it worse.
Think the situation at it; the most similar memory lights up. Cost doesn't depend on how much is stored.
Our substrate, HeatherDB, is an associative memory: retrieval is by resemblance, graded, with an honest confidence score. If the 1983 mechanism was right and only the memory was wrong, chunking on this substrate should simply… work. The loop is small enough to state in full:
situation
like this?
recall the plan · cost ~0
write the chunk
The practice curve appeared immediately. Over 500 problems, effort fell to 10% of the no-memory baseline. On recurring problem types it fell from 26.5 search-nodes to 0.21 — essentially free — following a power law, the human signature. Correctness: 100.0%, identical to solving everything from scratch.
The machine knows when it doesn't know. Before trusting a reflex, the loop checks the similarity score. Across five thousand labelled retrievals, every correct reflex scored above 0.80 and every would-be-wrong one below 0.61: clean empty air between them. Set the trust threshold in the gap and the system never fires a wrong reflex while staying maximally fast.
One law had to be respected. A single memory-vector holds a plan of about five steps — predictable from the substrate's capacity law before measuring it. Store a longer plan and it comes back subtly garbled while still looking confident. The fix is one rule: after writing a chunk, immediately read it back and check it survived; discard it if not. About 8% of writes get rejected, and that one rule is the difference between 95% and 100% correctness.
The utility problem did not reproduce. We loaded one hundred thousand chunks and asked for the right one: found it, decoded it, executed it: 100%, flat, all the way up. The disease that ended the research program in the eighties simply isn't present, because nothing flips through pages anymore.
And the brittleness wound closed with a twist. Store chunks with the specific objects abstracted into roles and a chunk learned on blocks a, b, c fires perfectly on blocks x, y, z. Then we set a trap: same starting position, different goal, so that replaying the remembered answer would be wrong. The system fired anyway — and got it right, because it recognized the new problem had the same shape and re-fitted the old solution to the new goal.
A chunk is not a recording of one answer. It's a recipe for every problem of the same shape — and where the shape genuinely differs, it declines to fire and quietly thinks instead.
The loop doesn't care what deliberation is. So we swapped in the real thing: a frontier LLM (Claude Sonnet) as the deliberator, with a live HeatherDB engine as its chunk store. The LLM reasons through problems it hasn't seen; every verified solution is written into the substrate; every confident recall is executed without invoking the LLM at all.
Reasoning tokens per problem, as the agent works through a stream of 120:
Sit with what that means. The skill is not in the model. The model never changed a single weight. The skill lives in the database: inspectable, transferable, deletable, yours. The LLM does what it's uniquely good at, parsing the world and rendering answers; the practiced competence accumulates in the substrate underneath it.
There's a precise way to say what just happened to the economics. An agent without this memory pays for work: every problem costs tokens, and volume scales the bill forever. A practicing agent pays full price only when a situation is genuinely new; the routine is free at the margin. Its invoice stops measuring volume and becomes a novelty meter: it spikes exactly when, and exactly as much as, the world surprised it.
You pay for surprise, not for work — and only ever once per thing learned.
Everyone building agents right now is bolting on memory that remembers what happened: conversation logs, retrieved documents, episode summaries. Useful, but it's the wrong kind of memory for skill. What's been missing is procedural memory: how to do things, compiled from experience, with a calibrated sense of when it applies. That's what this is.
The strange satisfaction of this study is how little we invented. Chunking is SOAR, 1983. Learning from expectation failure — only writing memory when prediction fails — is Roger Schank, 1982; it fell out of our loop's architecture without us adding anything. The power law of practice is Newell & Rosenbloom, 1981. These people understood the architecture of skill four decades ago. What they didn't have was a memory whose cost of knowing one more thing is zero.
They built practice on a notebook you flip through, and the notebook crushed it. On a memory where the right page lights up by itself, their mechanism runs exactly as designed — and the power law of practice turns out to be a property a database can have.
The machines have been re-deriving everything, every time, for forty years.
They were always supposed to practice.