Anneal
← The Anneal log

Related Isn't Right: Why Aim Beats Memory

You know the moment. You ask your assistant to do one specific thing, and it comes back fast, fluent, sure of itself — and pointed slightly to the left of what you meant. Not wrong because it forgot anything. Wrong because it grabbed the nearest handful of things instead of the one thing this task actually needed.

Everyone is trying to fix that by making the AI remember more. Store the conversation, embed it, pull it back next time. And remembering more is fine — it’s just not the thing that was broken.

What was broken is aim.

Here’s how “AI memory” actually works under the hood. Your past interactions get turned into vectors. When you start a new turn, the system grabs the ones that sit closest to your request in that vector space — the nearest neighbors — and pastes them into the prompt.

Nearest-neighbor means similar. And similar is a lower bar than you think.

Say you’re fixing a bug in a checkout flow. A similarity search cheerfully returns: the last three times you touched anything with the word “checkout,” a decision about a payment provider you already ripped out, a preference you stated once in a different project. All of it is related. Almost none of it is what this fix needs. But it’s in the prompt now, taking up room and quietly steering the model toward the average of everything you’ve ever done near this word — instead of the specific thing in front of you.

That’s the trap. A bigger memory store doesn’t make the retrieval more accurate. It makes it more confident about pulling in more adjacent-but-wrong material. You don’t feel it as “the AI forgot.” You feel it as “the AI is technically knowledgeable and somehow still not helping.”

What you actually wanted was aim

Sit in your own seat for a second. When you hand a task to a good collaborator, you don’t want them to recite everything they know that’s tangentially connected. You want them to walk in already pointed at the problem — carrying the two or three things that matter for this, and nothing else.

That’s aim. And aim is a different operation than recall.

Recall asks: what’s near this? Aim asks: what does this specific turn need, and what should I deliberately leave out? The second question is the whole game, and a memory store never asks it. It can’t. Retrieval-by-similarity has no notion of “this turn needs X but not Y” — it only knows what’s close.

Just-in-time context is the layer that asks the aiming question. Before the model runs, something looks at what you’re actually doing right now and delivers exactly that — the relevant slice, shaped so the model can act on it immediately — and leaves the adjacent-but-wrong stuff on the shelf where it belongs.

Why leaving things out is the point

This is the part that feels backwards until you’ve felt it work: the value isn’t only in what gets delivered. It’s in what gets withheld.

A model given ten related things and one right thing has to spend its own reasoning figuring out which is which — burning attention, mid-turn, on triage you can’t see. Every extra “related” item you stuff in is a small nudge away from the target. That’s why long sessions get worse, not better: the context keeps accreting things that were relevant once, and the model keeps having to re-decide what still matters.

Aim fixes that by never letting the noise in. The turn gets what it needs, assembled fresh, and the model spends its cycles on your actual problem instead of on sorting your history.

You experience it as an assistant that seems to get what you’re doing — that doesn’t need to be re-briefed every few turns, doesn’t drag in a decision you already reversed, doesn’t average your intent across everything you’ve ever asked. Not because it remembers more. Because it’s aimed better.

The tools you use are all about to remember

Here’s why this matters right now, practically. Memory is about to be free. Claude Code, Codex, Gemini, the assistant living in your editor — every one of them ships persistent memory within months. It’ll be table stakes by year-end, and none of them will differentiate on it, because a feature everyone has is a feature no one wins on.

So when you’re deciding which tools deserve a place in your daily loop, “does it remember me?” stops being a useful question. Everything will. The question that separates a tool that’s genuinely good at your work from one that just has a good memory is: what does it do with each request before the model runs?

If the honest answer is “we retrieve what’s related and inject it” — that’s a memory feature, and it’ll behave exactly like the confident-wrong moment you already know. If the answer is “we read what this turn needs, deliver that and only that, hold the output to a standard, and get sharper each time” — that’s aim. That’s the thing you actually feel.

It gets better the more you use it

One more piece, because aim compounds in a way recall doesn’t.

When the layer that aims each turn watches how things actually land — what worked, what got corrected, what shipped — it uses that to point better next time. Not by hoarding more of your history, but by getting more accurate about what this kind of task needs from you specifically. The tenth time you reach for it on a familiar problem, it starts closer to the target than the first. You don’t manage any of it. It just tightens.

That’s the difference between an AI that remembers you and an AI that’s getting better at helping you. One accumulates. The other aims — and keeps re-aiming.

Anneal is built on that aiming layer — just-in-time context, powered by grāmatr underneath — running on every request, across the AI tools you already use. Not so it remembers more of what you did. So the tool in front of you is actually good at the thing in front of you.

Related isn’t right. Aim is the difference.