Compacting an agent's memory: when to clear context without losing what matters

What compacting memory means in plain words

Picture your desk. Papers all over it: the task, drafts, notes, printouts. As long as everything you need is within reach, your brain hums along. But the desk isn’t infinite. Pile it up until there’s nowhere to set your coffee, and suddenly you’re digging through stacks and grinding to a halt.

An agent has the exact same problem. Its “desk” is the context Context (the context window) is all the text the model can see right now: your messages, the files it has read, command output. Anything that doesn't fit simply doesn't exist for the model. . Full up? The agent does a compact Compacting (compact) is the squashing of the conversation history. The agent folds the old back-and-forth into a short summary to free up room. Details get lost in the process. : it rakes the old papers into a single “misc” folder and labels it with a line or two - “built a landing page, talked about the font.” Room freed. But then you need one specific sheet from that folder? It’s not in there anymore. All that’s left is the label on the cover.

Why a vibecoder should understand clearing context

You’re a vibecoder. You don’t write code by hand - but you steer a long session with the agent. And sooner or later you run into one of two scenarios:

• the agent suddenly forgets what you were talking about an hour ago and asks you to repeat the obvious;
• the agent gets dumber and slower, starts repeating itself and mixing up details.

Both are about memory and compacting. Get the mechanics, and you bag three wins at once:

• you pick the cleanup moment yourself instead of waiting for the agent to do it at the worst possible second;
• you don’t lose your work to a random cleanup;
• you keep the agent fast and focused instead of drowning in walls of logs.

The difference between “the agent suddenly forgot everything” and “the agent stays on task” usually comes down to a single skill: clearing the desk at the right time and saving what matters to a file ahead of time.

What survives a compact, and what gets lost

The most important part of the lesson. Compacting doesn’t erase everything indiscriminately - it draws a clear line. Memorize these two columns, and the fear of cleaning up evaporates.

How to tell it’s time to compact

The agent gives off signals itself. Watch for three of them.

The session has gotten too long

Been chatting for a while, with a mountain of read files and logs piling up? The desk is probably close to overflowing. Time to think about tidying up.

The task has changed

Finished one chunk and picking up a completely different one? The old context is just in the way now - dead weight that throws the agent off.

The agent has started to “drift”

Replies got slower, the agent repeats itself, mixes up details, asks again about things it knew a moment ago. Classic: the desk is jammed, and the chef has nowhere to set down the knife.

When to clear the agent’s memory, and when not to

Here’s a cheat sheet for the transitions between stages of work. Green - clean away with confidence. Red - hands off.

Example: how auto-compact ate half an hour of work

You’ve been building an online store with the agent for three hours. First you spent ages digging into which products to show, reading examples, arguing about the structure. Then you laid out the storefront. Then you spent half an hour chasing a bug in the cart - the agent read a dozen files, tried, failed, tried again.

And now the bug is nearly caught. The agent cheerfully reports: “looks like the problem is in the total calculation, let me check.” At that very instant the desk overflows and auto-compact fires. The agent comes back - and innocently asks: “so what was our problem again?” All the bug-hunting work has moved into the “misc” folder. Half an hour - down the drain.

Where did it go wrong? The cleanup happened at the worst moment - mid-debugging. And it happened on its own, because you hadn’t tidied up earlier at a safe boundary.

Here’s how a vibecoder who gets it would do it:

We’ve finished the big block of product research and laid out the storefront. Before tackling the cart, do this:

Write the key decisions to a file, DECISIONS.md: which products we show, the storefront structure, the design agreements. That way it all survives the cleanup.
In the same file, note that we’re now starting to fix the cart and what the problem is.
Now do a compact - free up the memory, there’s a separate task ahead for the cart.
From here, work on the cart WITHOUT interrupting for a cleanup until the bug is caught.

A three-step ritual before cleaning up

To make sure a compact never bites, run through three steps before every manual cleanup. This is literally the heart of the strategic-compact skill.

1. Am I at a boundary? Is the job done, or am I in the middle? In the middle - stop, don’t clean up.
2. Is the important stuff written down? Are the decisions, agreements, and current task in a file? If not - ask to have them written down first.
3. Will I give a short hint? With a manual compact, add a couple of words: “next we’re doing the cart.” The agent starts with a clear desk but already knows where it’s headed.

Common mistakes when compacting context

• Cleaning up mid-debugging. The most painful one: you erase exactly the details you fought for. Finish off the bug, then clean up.
• Hoping the chat will remember everything itself. Requests made in passing won’t survive a compact. Important stuff goes in a file, and only then the cleanup.
• Waiting for auto-compact. It’ll fire at a random, usually deeply inconvenient moment. Do it yourself, early, at a convenient boundary.
• Cleaning up too often “just in case.” Every cleanup loses context. Don’t touch the desk without a reason.
• Cleaning up without giving a hint. After a bare compact the agent may not understand what to do next. Add a short line about the next task.
• Confusing a cleanup with a breakdown. The agent “forgot”? It’s not a glitch, it’s a compact that fired. The fix: repeat the key points and write them to a file.