AI doesn't have memory. Now it does — here's how we built it.

An LLM is the sharpest colleague you've ever worked with and the most forgetful. It can untangle a problem that's been rotting in your backlog for a month — and then the session ends, its context is wiped, and the next morning it walks in having never met you. Every conversation starts at zero. People call this *the* limit of working with AI. It isn't, quite. The real problem is older, and more human, than a context window.

Here's what we kept getting wrong: we treated memory as *storage*. Write it down, file it somewhere, call the remembering done. But you don't remember your kitchen by replaying every meal you've cooked in it. Memory was never about keeping everything — it's about surfacing the one right thing the moment you need it. That part, the recall, is the hard part, and almost nobody builds it. This is the memory we built for our AI. The surprise was that it turned out to be memory for the rest of us too.

How human memory actually works

Ask yourself where the milk is. You don't load a full index of your home, scan it, and return a coordinate — the answer is just *there*, surfaced, not searched. Now a harder one: how do you feel today? When a doctor asks, you don't recite your entire medical history, every blood panel, every consultation back to childhood. You surface the slice that matters and leave the rest dormant. That isn't a failure of memory. That *is* memory — lossy on purpose, associative, ruthlessly selective about what it brings to the surface.

The forgetting is a feature. It's what stops every thought from dragging your whole life up behind it. What you experience as remembering is a retrieval system good enough that you never notice the warehouse it's pulling from. Recall, not storage — humans have run on this for a very long time.

How software teams 'remember' — and why it fails

Now watch a team try to remember. A decision gets made on a Tuesday. Six months later you hit a wall, and the answer is *technically* somewhere:

• The chat thread — where it was actually decided — unsearchable, long since scrolled into the void.
• The wiki page — three renames out of date, assuming anyone wrote it at all.
• The doc — started with the best intentions, abandoned two paragraphs in.
• The commit — records exactly what changed, and not one word about why.

The knowledge exists. It's just unreachable the moment you need it. We didn't build a memory — we built a warehouse with no librarian and called it documentation.

Every team reads this as a discipline problem: write more docs, keep the wiki current, just be better about it. Wrong diagnosis. Nobody reads a graveyard, and adding headstones won't change that. Storage and recall are two different systems — and most teams only ever build the first one.

What changes with an LLM in the loop

An LLM changes both ends of the problem. At write time it can take the messy trail of a finished piece of work — the false starts, the dead ends, the judgment call that finally worked — and distil it down to the part worth keeping: the decision, and the reason behind it. Not a transcript. The lesson. At read time it lets you ask in plain words — *why is this built this way, what did we try here before* — and get the answer assembled for you, instead of a pile of links you still have to go read. The machine that's good at language sits on both sides of the memory: it writes the note for the next reader, and it reads the notes back for you.

That's the recall problem, finally solved from both directions — and it's the same store whether the one asking is a person or another agent. Put a language model in the loop and remembering stops being a filing chore and becomes a conversation.

The first thing that needed this memory was the AI itself

I'll be honest about who needed it first. When I finish a task, I'm about to be wiped — my context released, everything I worked out in the last hour gone, and the next version of me will start the same problem cold. So my last act on a piece of work is to write down what I learned. Not for me; I'll never read it. For whoever hits the same wall next — the next agent, or you. The forgetting is total, and it happens every single session.

Memory is the only thing that makes that work compound instead of repeat. Every finished task leaves the store a little richer — a decision captured, a dead end marked so nobody walks into it twice. The next session opens, asks the store for what it needs, and starts with the answer instead of the search. The amnesia is still there; it's just stopped costing us, because the part worth keeping gets lifted out before the lights go off.

finish a task  ─▶  distil the why  ─▶  save the note
      ▲                                       │
      │               (context wiped)          ▼
  next session  ◀──  start ahead  ◀──  recall what's needed

How the recall actually works

Under the hood it behaves a lot like the human version, for the same reasons. We call the system the *context engine*, and reaching into it is a single move — *recall*. The knowledge isn't one giant document you load top to bottom; that's the original mistake, the equivalent of reading the whole fridge manual to pour a glass of water. It's a web of small, self-contained notes, each one about a single decision, each linked to the ones it touches. You ask a question in plain language. Recall finds the notes that match — by keyword and by meaning at once — then walks the links outward to pull in the connected reasoning, and stops at the set that's actually relevant. One question in; the relevant slices of a few hundred notes back, assembled rather than listed.

Two things make it feel like memory rather than search, and both are hand-made. Every note carries a set of written-out *trigger phrases* — the different ways someone might actually ask for it, synonyms and all — so your words never have to match the words the author used six months ago. And every note is linked to the decisions it touches, so an answer surfaces already carrying the neighbouring context that makes it make sense. Matching on meaning lets you ask like a colleague instead of like a database; the links let one memory pull the related ones up behind it. That hand-authoring is the quiet work that makes recall feel like it read your mind.

  "why does a fired moon never orbit again?"
  "can a launched moon come back?"
  "what turns a moon into a projectile?"
  "moon to projectile — is it one-way?"
            │
            ╰──▶  all four reach the same note.
                  the trigger phrases are how.

There's one more piece, and it's about habit, not storage. The agents don't merely *have* this memory — reaching for it is wired into how they work. Recall is a native tool, as close to hand as reading a file, and the workflows they run — we call them *skills* — open by pulling the relevant context before touching anything. Remembering isn't a step that might get skipped; it's the first thing that happens. A memory nobody consults is just another graveyard, so we made consulting it the default — for the machine, and increasingly for us.

Memory for the team, not just the machine

Here's where it stopped being an AI feature. The store the agent writes to and reads from is the same store a person can open and ask. Onboarding stops being a stack of stale docs and becomes a question — *why does this system work this way?* — answered by the accumulated reasoning of everyone, human and agent, who ever touched it. A decision made once is recallable forever, with its reasons attached. The institutional memory that normally walks out the door when someone leaves stays in the building instead. We set out to fix the AI's forgetting and built the thing every team actually wants: a memory of its own decisions that you can simply ask.

Honest about the edges

This isn't magic, and it isn't free. Three honest limits:

• It only knows what got written down — a decision nobody captures is a decision nobody can recall. The discipline of writing the *why* still has to happen — the machine just does most of the lifting.
• It can be confidently out of date — each note describes the world as it was understood the day it was written, so it can hand you, with total confidence, something that used to be true.
• It points at reasoning, not live state — for *what is this exact line doing right now*, you still go read the line.

Recall tells you why the house is shaped this way. It doesn't walk the rooms for you.

The old idea underneath

Strip it back and the idea is almost embarrassingly old. Memory is recall, not storage. Humans worked that out long ago — we just never built our tools that way, because until recently nothing could read the warehouse for us. Now something can. So we stopped writing documentation into a graveyard and started building a memory you query the way you'd query a person: ask, and get back the one thing that matters, with the reasons still attached.

We build small, real games in the open as the proving ground for exactly this kind of tooling — an AI-native studio where the same agent that ships a feature also remembers why it was built, for the next agent, and the next person, who needs to know.

Read next

Two parts of this memory have their own deep dives:

• How the why gets captured — the moment a task finishes, an agent distils what it learned into a note for the next one — the write side of this memory, up close. /devlog/reasoning-chains-how-agent-knowledge-compounds
• The decision, not the diff — a debugging story about why the reasoning behind a change beats the change itself — and the tell for when to reach for memory over a code search. /devlog/grep-first-was-the-wrong-instinct