In the last post I made the case that the model is a firehose and good steer is backpressure — the resistance your environment pushes back to shape a context-blind producer into something specifically right for your world. Tests around the loop are the cleanest example: the bar goes red, the agent corrects, the flow bends toward correct.
Here's the flaw I glossed over. That correction evaporates the instant the loop closes.
Next session, same firehose. Same wrong turn. Same red bar. Same fix, rediscovered from scratch, because nothing remembered that you already solved this exact problem last Tuesday. Your beautiful test harness has no memory. Skynet has no memory. Governor has no memory. They all apply resistance in the moment and then forget it completely.
That's not steering. That's re-steering the same ship into the same rock, forever, and feeling productive because your hands are on the wheel. Backpressure without memory is Groundhog Day with extra CI minutes.
The third axis
The org-scale backpressure I described in that post runs on two axes.
Skynet is backpressure across *space* — resistance from what a change breaks in the other three thousand repos it can see and your repo-myopic harness can't.
Governor is backpressure from *policy* — resistance from what cyber, cloud, data and LRC require, asserted as code at invocation and hard-gated on CI.
There's a third axis, and it's the one almost nobody builds: time. Backpressure from what you already decided, already tried, already watched blow up. Resistance sourced not from another repo or another team, but from your own past. That axis is memory. That's what I built Rekall to be — and once you see memory as the time-axis of backpressure, it stops looking like a nicer notepad and starts looking like the thing that makes the other two axes matter at all.
The gate is backpressure. Literally.
People hear "AI memory" and picture recall — fetch the fact, hand it back. That's the read path, and it's the boring half. The interesting half is the write-side gate, and it is backpressure in the most literal sense the word has.
Rekall's validation gate governs what an agent is allowed to do, and two of its rules are the whole thesis in a config file: no_contradict_confirmed and respect_superseded. The model reaches out to do the thing you already decided against — the approach you tried in March that took down staging — and the gate pushes back. Not with a polite reminder in a system prompt it'll ignore. With a hard verdict at the action boundary, sourced from accumulated judgment, promoted through shadow → warn → enforce so you watch it be right before you let it block anything.
That is resistance applied to the producer at exactly the moment Phelps says you want to control the producer — except the resistance is coming from your own history. The past reaching forward to grab the model's wrist. Memory-as-backpressure, enforced as code.
The only backpressure that compounds
Now the property that makes memory different in kind, not just degree.
Tests, Skynet, Governor — they apply the same resistance every time. Consistent, valuable, and flat. The test that caught the bug today catches it exactly as well tomorrow, no better. It doesn't learn.
Memory is the only backpressure that gets stronger every time it's used.
Rekall's decision graph makes decisions first-class — a real choice, made over alternatives — and then record_outcome writes how it actually turned out, as a resulted_in edge. So the next time the firehose points at that same wall, the wall doesn't just say "no." It says "you tried this; here's exactly how it went; here's what you replaced it with." Every correction becomes a permanent increment of steer. The resistance compounds. You are, for once, not paying the same tuition twice.
This is the difference between a firehose hitting a wall and a firehose hitting a wall that remembers every previous collision and is a little harder to knock over each time. Over a year, that gap is the whole ballgame.
Multiplayer backpressure: the hive mind
This is where it stops being a personal-productivity trick and becomes the thing your whole org has been missing.
Rekall doesn't keep memory in one undifferentiated pile. It layers it — personal, hive, and agent. Personal memory is your own. Agent memory is a given agent's whole working self. And the hive is the shared layer: the collective, the org's mind. When one engineer's hard-won correction moves out of their personal memory and into the hive, it becomes backpressure for everyone. The "no, we tried that, here's why it blew up" that used to be tribal knowledge — locked in one senior's skull, gone the day they take a better offer — now lives in the hive mind and resists the producer for the entire org, permanently. One person learns the lesson once. Everyone, and every agent, gets steered by it forever.
That's institutional memory that stops walking out the door. It's also the exact argument I make in Human in the Loop Is a Trap, pointed at good steer: the correction shouldn't live in a single-player silo waiting to be re-derived. It should land in the hive mind the moment it exists, and push back on every producer that comes after. Turn the org's accumulated judgment into a wall the firehose keeps running into — on purpose.
A test steers one loop. A decision in the hive steers every loop, for every builder and every agent, until someone deliberately supersedes it. That's not a bigger notepad. That's the backpressure getting a nervous system — a shared one.
This is how the buffer drains
Back to POC hell, and the unbounded buffer.
An org stuck in POC hell is re-deriving the same production-hardening corrections on every single prototype — relearning the same lessons every Tuesday because the backpressure resets to zero between projects. The buffer never drains because every demo has to independently rediscover the same twelve dragons before it can ship, and nobody's demo remembers the last one's fight.
Give the backpressure a memory and the buffer starts to drain. The corrections compound. The tenth project inherits the scar tissue of the first nine. The dragons get fought once and stay fought. Good steer stops being something each engineer improvises alone and becomes something the org accumulates — a standing body of judgment that makes the next thing specifically-good faster than the last.
The model is a firehose, and it's getting wetter every month. Tests, cross-repo sight, org policy — build all of it. But if none of it remembers, you'll fight the same current every single loop.
Memory is the only backpressure that compounds. Build the amnesia out.
This is a companion to POC Hell Is an Unbounded Buffer, which lays out the backpressure frame, and to A Bigger Notepad Won't Save You, the Rekall build itself.