Concepts · July 11, 2026 · 6 min read

AI agents forget context — the fix isn't a bigger model

The researcher found it; the writer never saw it. It looks like forgetting, so the instinct is more context or a smarter model. But nothing was forgotten — there was never a shared reality to forget from.

The symptom

Your researcher agent digs up the key fact: "Auth flow moved to v2 — PR #42 merged." Three steps later, the writer agent produces a paragraph documenting v1. It didn't get the memo. Run the pipeline again and the token count creeps up as each agent re-derives context the last one already established. From the outside it reads as one thing: the system forgets.

The reflex is to treat that as a capacity problem. Bigger context window. Newer, smarter model. Stuff more history into every prompt. It feels right — forgetting sounds like a memory-size issue. It usually isn't.

Why a bigger context window doesn't fix it

Suppose you take the largest context window on the market and pour every agent's full history into every prompt. Three things go wrong:

• Cost and latency scale the wrong way. Re-sending the whole transcript to every agent on every turn is the thing that made the token bill balloon in the first place. A bigger window doesn't shrink the bill — it raises the ceiling on how much you can overspend.
• More context isn't the right context. Models degrade when the relevant fact is buried in a long, noisy prompt — the "lost in the middle" effect is well documented. Dumping 200K tokens of raw history in doesn't guarantee the one line about PR #42 gets attention. Retrieval quality is a different axis from window size.
• It doesn't answer the timing question. This is the one scale can't touch. Even with an infinite window, the writer's prompt is only as good as the moment it was assembled. If agent A's write hadn't landed — or hadn't been extracted — when agent B's prompt was built, a bigger window just faithfully includes the stale version. The failure isn't that the context was too small. It's that the write wasn't visible yet.

A smarter model hits the same ceiling. It can reason better over whatever it's handed — but it can't reason over a fact it was never shown.

It isn't forgetting — it's a missing shared reality

Here's the tell: a single agent with a scratchpad doesn't have this problem. It writes a note, reads it back, and carries on. Give it a 32K window and it remembers fine. The failure only shows up between agents.

That's because there's nothing to forget. Each agent has its own local context; there is no shared state the fleet reads from and writes to. What looks like amnesia is really the absence of a common reality. The MAST study of 1,600+ multi-agent traces put a number on it: 36.9% of failures are agents disagreeing about the state of the world — the single largest category (more on that in the failure taxonomy). You can't fix a disagreement about reality by handing each agent a bigger private notebook.

The actual fix is a coordination layer

The fix is architectural, not dimensional. Put one shared memory between the agents and give it three jobs:

1. Write — every agent streams what it learns as events. Nothing blocks; the writer never waits on the reader.
2. Consolidate — raw events become versioned facts. When two agents write conflicting versions of the same fact, it's resolved by a policy at write time, not by luck at read time.
3. Pack — any agent asks for a budget-fit, provenance-tagged context block scoped to what it needs, with a guarantee attached.

The guarantee is the part scale can't buy. When an agent writes, it gets a sequence number back. When another agent requests context with that min_seq, the layer promises the returned pack reflects the write — extracted, or included as a raw tail until extraction completes. That's read-your-writes: if agent A wrote it, agent B's next pack contains it. Not "ranked highly if it happens to be retrieved." Contains it.

What each approach actually buys you

Scaling up and coordinating are answers to different questions:

• A bigger model or window improves how well an agent reasons over the context it happens to receive. Useful — but it's a bet on marginal recall over a haystack you keep re-sending.
• A coordination layer changes what context each agent receives: the right facts, guaranteed-visible, in a small deterministic pack. Prompts get shorter, not longer, so the token bill goes down — and because the packs are deterministic, prompt-cache hits compound.

One raises the ceiling on a fundamentally wasteful pattern. The other removes the waste.

The one-line version

When your agents lose the thread, the question isn't "how do I fit more into the prompt?" — it's "why don't these agents share a reality?" A bigger model makes each agent smarter in isolation. It's the isolation that's the bug.

This reframe is the premise behind Lore, an open-source coordination memory layer for multi-agent AI. See the write → consolidate → pack loop, or the repo on GitHub.