Your AI's Context Should Stop Growing

We have spent two posts arguing that you should keep everything. Own the record, because history you do not hold is a retention policy.

Follow that through and it creates a problem. Something that records every session permanently gets far too big to hand to a model, and it gets there within about a fortnight. So what does your assistant actually read?

Not the record. A selection from it. Getting that selection right turns out to be most of what this kind of tool is for, and it is the part worth being specific about.

fAI is a workbench that runs underneath the AI coding tools you already use. It watches your work and keeps what it learns in ordinary git repositories on your machine.

Two Layers

The record is every capture, as a commit, in the order it happened. All of it stays, and the lineage stays with it, so you can go back and see how any of it got there. We went through how that works in detail separately.

The synthesis is what your assistant actually reads when a session starts. It is called that because it is not a copy of anything. It is a distillation of the record into the few pages worth someone's attention right now: what the project is, the decisions that still hold, the conventions you genuinely follow. It gets rebuilt constantly as the record grows.

Keep everything. Read what matters.

Those are not in tension. The record is what makes the second half safe: you can be ruthless about what leaves the synthesis precisely because nothing leaves the record.

Where Most People Actually Are

It's worth being realistic about the starting point here. Most people have no context tooling at all. Sessions begin cold, you re-explain the project, and whatever the assistant worked out last week is gone.

The major coding assistants now ship some memory of their own, which is a real improvement on starting from nothing. And plenty of people keep a CLAUDE.md or an AGENTS.md in the repo. We do too, in fAI's own projects. Those are durable instructions that you write on purpose and update when they stop being right, and they are good practice.

They are also a different job from the one here. Instructions are what you tell your assistant. What we are talking about is everything it worked out while you were busy, captured automatically, which nobody hand-maintains because nobody could.

That is the material that has to be selected from rather than handed over whole. And the cost of getting it wrong is measurable. Chroma ran 18 models through a set of deliberately simple tasks, varying how much input came along for the ride. Claude, GPT, Gemini, Qwen. Every one of them got less reliable as the input grew.

"models do not use their context uniformly; instead, their performance grows increasingly unreliable as input length grows."

Two qualifications, both the authors' own. The tasks were controlled deliberately, and the write-up says the evaluation "is not exhaustive of real-world use cases." They also expect real work to be harder rather than easier, noting that added complexity means "the influence of input length may be even more pronounced in practice." Take the direction from that, not a law.

The part that bears on this is what they found about irrelevant material. Adding a single piece of it measurably hurt performance against a clean baseline. Adding four hurt more. And the damage got worse as the input got longer rather than washing out in the noise.

Stale or irrelevant context degrades your AI assistant's performance. It does not need to know everything about your project. It needs what is relevant right now, whether that is something from this morning or a decision from three months ago that still holds.

What Bounded Looks Like

The synthesis is not one file written by a model. It is a set of pages, one per prescribed section, each compiled separately and then concatenated in a fixed order. For a project those sections are Architecture & Design, Conventions & Patterns, Key Decisions, Environment & Build, Vocabulary, and Coherence Notes. A personal workbench gets different ones: Working Style & Preferences, Communication & AI Framing, Tooling & Environment Defaults.

That list is the part that is actually enforced. The headings and their order come from code, and the final assembly is a concatenation with no model involved, so a section cannot quietly rename itself or vanish. What is not enforced is length. There is a token budget on each synthesis pass, but nothing caps the finished document.

So the size is free to grow, and it doesn't. Running fAI on my laptop, across 104 revisions since early August, individual versions swing widely, from 17KB up to 64KB. Split those revisions down the middle and compare the halves:

first half   mean 30,664 bytes
second half  mean 29,500 bytes

Four percent apart, pointing down. On the same rough chars-over-four estimate fAI uses internally, that is somewhere near 7,400 tokens of working context. It swings around a great deal, but across those 104 revisions it is not getting progressively larger.

Size of the synthesized project file across 104 consecutive revisions. The line is jagged, ranging from 17KB to 64KB, with the two half-period means drawn as level segments at 30,664 and 29,500 bytes.

The first stretch runs higher and comes down, which is the file finding its size rather than a trend. After that it holds, and the two level marks are the point: the jagged line under them never climbs past where it started.

One pass, close up:

$ git -C ~/.fai/workbenches/<hash> diff --stat HEAD~6 HEAD
 FAI-PROJECT.md                | 454 ++++++++++++++++++-------------
 pages/architecture-design.md  |  82 +++++---
 pages/conventions-patterns.md | 133 +++++++------
 pages/key-decisions.md        | 166 ++++++++-------
 8 files changed, 508 insertions(+), 376 deletions(-)

508 lines arrived and 376 left. The file is not being appended to, it is being rewritten, with material leaving on the same order as material arriving.

That much churn can look alarming the first time you watch it. It is the synthesis working as designed: pages get recompiled rather than extended, so what sits in front of your assistant stays current instead of going stale underneath it.

Two Speeds

Early on, the work is learning. The file is thin, and every session adds foundations that were not there before.

That phase ends. At some point the synthesis holds a decent picture of what you are building, and new sessions stop revealing basics. A file that could only grow would begin rotting right here: still correct, increasingly buried.

What replaces growth is selection. Every pass, something decides what earns the space. What is still load-bearing. What quietly stopped being true. What was urgent in July and is finished now, like a feature that already shipped to prod and no longer belongs in your assistant's working picture of the project.

So fAI runs at two speeds. One is an archive that only ever grows. The other is your assistant's briefing, which keeps getting re-cut from it.

When the Pages Disagree

This next part is a different operation, and worth being precise about.

Because each section is compiled on its own, no single compile ever sees the whole document. A decision that contradicts a convention is invisible to both of them, since neither is looking at the other.

Catching those needs a pass that reads every page at once, and fAI runs one on a slower clock, a quarter as often as the compile. It looks for four specific shapes: a decision contradicted by patterns, a decision contradicted by context, a pattern whose context has since changed, and a decision resting on a tool that is gone.

Say Key Decisions records that you standardised on Postgres, while Conventions & Patterns has quietly accumulated evidence that every service you have started since uses SQLite. Both entries are honest. Read together, they cannot both be current.

Whatever the pass finds goes under a heading called ## Coherence Notes, written up with what each side is relying on and a suggested way to resolve it. Find nothing and the heading is absent rather than padded with reassurance, so the section appears only when a pass identified something worth surfacing.

What it does not do is pick. An assistant that averaged those two entries into one confident answer would read better and deserve less trust. But that's the point. The disagreement is the useful part, and smoothing it over would hide the only thing worth knowing, which is that you have not actually decided yet.

About That Thirty-Day Window

One thing to be straight about, since we spent a whole post criticising a thirty-day window.

fAI keeps a search index over your raw captures so it can find things by meaning rather than by filename. That index holds about thirty days at a time. Older entries drop out of it.

Anthropic's thirty days is different in the way that matters. Their retention window applies to the version history itself: after thirty days it can be deleted, and if you want it you export it first. fAI's window applies only to the search index. The capture commits are still in a git repository on your disk, and git log still finds them in a year.

It also applies only to raw captures, not to what has been worked out from them. Once something has been distilled into a decision or a convention, the synthesis reads it straight from the text and does not go through that index at all.

Keep Everything. Read What Matters.

Your project will keep changing, which means some of what your assistant has recorded about it will stop being true. That is not a flaw in the recording. It is what happens to any description of a moving thing.

So there are two jobs here, not one. Keep the whole record, because you cannot know today what you will want to ask of it later. And keep the briefing short, because everything in it competes with everything else in it.

The record should grow forever. What you put in front of a model should not.

On macOS or Linux:

curl -fsSL https://www.fathym.com/fai/install.sh | sh

On Windows:

iwr -useb https://www.fathym.com/fai/install.ps1 | iex

Work for a couple of weeks, then read a diff of your own synthesis and see what left.

Your vault stays in ~/.fai/. Yours to keep.

Start building - free ->

Read more: Your AI Finally Remembers ->