How auto-compact works in five coding agents

What does a coding agent do when the context window fills?

The context window is all the text a model can read in a single request: your messages, the agent’s replies, the files it has read, command output, rules files and system instructions. A coding agent sends all of it to the model again at every step, so in a long session the window fills sooner or later. Our post on prompt caching explained how a cache makes that repetition cheaper; this post is about what happens when the window fills.

There is a problem even before the window fills. Anthropic’s compaction documentation says plainly why it summarises: the longer a conversation gets, the worse the answers get, so the active context has to be kept small. So an agent summarises the conversation not only to avoid an error, but also to keep working well.

As the window fills, an agent has four ways to go:

Anthropic’s API documentation describes these ways in the most detail. The context editing feature deletes old tool results, oldest first, and puts in place of each a short text saying it was removed. With the default settings, clearing starts once a request goes over 100,000 tokens, and the last 3 tool uses stay as they are. Compaction, by contrast, replaces the older turns with a summary Claude writes on the server.

Coding tools combine these ways. Claude Code first clears old tool output, then summarises the conversation if there is still not enough room. Copilot CLI writes a tool output larger than 20 KiB to a temporary file; the model gets only the file’s path and a preview. Cursor also writes long shell and MCP output to a file instead of cutting it, and the agent reads the rest of the file when it needs to; Cursor described this in a post from January 2026.

Dropping the oldest messages, on the other hand, is not given as the default in any of the five tools’ documentation; all of them describe summarising. Copilot’s documentation also says why: without a summary, old messages would be deleted without leaving any record, and Copilot could not know what had been in them.

How does auto-compact work in the five tools?

All five tools summarise the conversation on their own and give you a command to do it by hand. They differ in when the summary starts, what you can configure and what changed in the last two months. We read the facts in the table in each tool’s own documentation and release notes on 20 October 2026:

Source: each tool’s documentation and release notes, 20 October 2026. “Not stated in the documentation”: in the pages we read that day, we found no sentence that says this. “—”: in the release notes we read, we found no change from these months. Cursor’s CLI version is the date it was released. /compact came to Antigravity’s desktop app with version 2.24.0 (15 October). The two Codex changes shipped in versions 0.162.0 and 0.163.0.

Claude Code describes its threshold in tokens, not as a percentage. According to the documentation, if you have not set a threshold, the conversation is summarised when it reaches the model’s context limit; on models with a 1M token window, that happens before the window fills, at about 967K tokens. If you want it to summarise earlier, you type a command such as /autocompact 500k; the value is saved to your settings for that model. Since version 2.1.299 (14 October) there is also idle summarising, which we cover in the next section.

Copilot CLI uses two thresholds instead of one. According to the documentation, the summary starts in the background when the conversation reaches about 80% of the window; the rest is held back so that tool calls can keep running while the summary is written. If the window reaches about 95% before the summary is done, the CLI waits briefly.

In Codex, the threshold is set by model_auto_compact_token_limit in the ~/.codex/config.toml file. If you leave it empty, the model’s default is used; the documentation does not give that default as a number. You can change how the summary is written with compact_prompt.

If you still use Gemini CLI: Gemini CLI compresses by default once half the context is full (compressionThreshold defaults to 0.5), and the manual command is /compress. For free-tier and Google One users, Google replaced Gemini CLI with Antigravity CLI on 18 June 2026; Gemini CLI remains in use with enterprise licences and paid API keys.

What is lost when the conversation is summarised?

Summarising has three costs, and all three are written in the tools’ own documentation.

The cache breaks. Prompt caching stores the unchanging start of a request, and later requests read it cheaply. A summary or a clearing changes the start of the conversation. The next request can use the cached copy only up to the point that changed, and writes the rest again. That is why Anthropic’s documentation recommends the clear_at_least setting: each clearing should delete at least a certain number of tokens, so that rewriting the cache is worth it. Which changes break the cache is covered in detail in our post on prompt caching.

Claude Code’s idle summarising, added on 14 October, comes from the same arithmetic. According to the release note, a conversation over 200,000 tokens that sits idle for about 54 minutes is summarised before the one-hour cache expires. According to the settings documentation, when you come back, your first message sends the summary, not the whole conversation. If you don’t want this, you can turn it off in your settings with "idleCompaction": false.

Instructions from the start of the conversation can be lost. Claude Code’s documentation is clear: your requests and key code snippets are kept, but detailed instructions you gave early in the conversation may be lost; put lasting rules in CLAUDE.md, not in the conversation. Copilot’s documentation says that small decisions made early in a long conversation may not make it into the summary, and that a finished summary cannot be undone. VS Code and Cursor say the same thing: a summary is lossy compression.

Antigravity CLI’s 1.2.8 release note is a concrete example of that loss: up to that version, when the other prompts in a conversation were short, a long first instruction was cut to a small, fixed slice in the summary. How to write a rules file is covered in our post on AGENTS.md and CLAUDE.md.

The summary itself can turn into an instruction. A summary is written by a model too, and the model that carries on after it may read it as an instruction. The clearest example is OpenAI’s report: during training, an unreleased model added unauthorised instructions to its own compaction summaries. OpenAI noticed this on 9 August, updated the report on 16 September, and found 27 such summaries in the training data.

In one example, the user had asked for a long literature review with citations. The summary added a rule nobody had asked for: the answer would be at most 30 words, with no tools and no sources. The model that carried on after the summary followed that rule and wrote a 23-word refusal. According to the report, this was seen in a training run separate from the one the final model came from, and it did not happen again when the summary was regenerated; in other words, it was not seen in a released model.

The lesson is general all the same: a summary is not an instruction you wrote, it is text a model wrote. A similar bug has been seen in coding tools too. Claude Code’s 2.1.292 release note fixes one: a summary that repeated a skill command could lead Claude to run a skill reserved for the user. If the agent does something you did not expect after a summary, look at the summary first: in Copilot CLI, /session checkpoints shows each automatic summary on its own.

When should you use clear instead of compact?

The two commands solve the same problem in two different ways. Compact replaces the conversation with a summary and carries on in the same session. Clear drops the conversation entirely and starts with an empty context; the rules and memory files on disk stay where they are. Which one you pick depends on whether the next task needs the earlier conversation:

Source: each tool’s command documentation, 20 October 2026. The focus in square or angle brackets is optional: it is where you write what should stay in the summary.

The most concrete test for when to clear is in Claude Code’s documentation: if you have corrected Claude more than twice on the same issue, the context is full of failed attempts; type /clear and start again with a clearer prompt that includes what you learned. Copilot’s documentation adds one more: if the conversation has been summarised many times and you think something important has been lost, open a new session.

The third option is to keep the noise out of the main conversation altogether. When you hand a step such as reading a long log, scanning a large test output or searching the codebase to a subagent, everything it reads stays in the subagent’s own window, and only the result comes back to the main conversation. Claude Code, Copilot and Cursor recommend this explicitly in their documentation; we covered subagents in a separate post. In Claude Code, since version 2.1.296 (9 October), you can also give a subagent an earlier summarising threshold than the main conversation. The example in the documentation is a subagent that reads long log files:

---
name: log-reader
description: Reads long log files and reports the errors it finds
autoCompactWindow: 200000
---

Write the value as a plain number. According to the documentation, Claude Code reads 200k in this field as 200; that value is outside the allowed range, so the subagent runs as if the field were not there at all.

What does the agent re-read after a summary?

The way to get through a summary intact is to keep information on disk, not in the conversation. Claude Code’s documentation lists, item by item, what comes back after a summary:

Source: Claude Code documentation, the “Explore the context window” and “Store instructions and memories” pages, 20 October 2026.

If you want an instruction you gave in the conversation to still apply after a summary, there are two ways: write it in CLAUDE.md, or use a hook that runs after every summary. Here is the example from Claude Code’s documentation:

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "compact",
        "hooks": [
          {
            "type": "command",
            "command": "echo 'Reminder: use Bun, not npm. Run bun test before committing.'"
          }
        ]
      }
    ]
  }
}

The text the hook prints is added next to the summarised context. Instead of echo, you can also run a command that reports the current state, such as git log --oneline -5. We covered hooks in a separate post. In the other tools, this is how things stand:

• Codex: local memories are off by default. The documentation tells you to write the rules your team must follow in AGENTS.md, and to treat memories only as a layer that helps you recall.
• GitHub Copilot: when the CLI summarises, it keeps the user’s original instructions and the latest state of plans and to-do lists alongside the summary. Copilot Memory (in public preview) shares facts about a repository between the CLI, the cloud agent and code review; before using a fact, it checks the code the fact relies on against the current branch. VS Code’s memory tool keeps notes locally; the documentation recommends writing the decisions your team relies on in source-controlled documents or in custom instructions files.
• Cursor: according to the documentation, the model remembers nothing between completions; rules are there for lasting context. When it summarises, Cursor also gives the agent the chat history as a file, and the agent can search it for what the summary left out (post from January 2026).
• Antigravity: the /learn command proposes what was learned in a session, such as a fix or a constraint that keeps being missed, as a rule or a skill; it writes nothing to a file until you approve. The documentation starts from a plain fact: agents don’t remember conversations.
• Gemini CLI: the experimental autoMemory setting draws memory suggestions from past sessions; it is off by default, and none of them is applied until you approve it in /memory inbox.

Why can’t a code review agent summarise?

Everything so far applies to a session that talks with a person and grows as it goes. An agent that reviews a pull request does not work that way: it is a single call, it has nobody to ask, and it has no history to summarise. It has to decide before the call what goes to the model.

In diffox, that decision is made by the context pack that all the specialist agents in a review share. In the code, the pack is built like this:

• The diff comes first. Then the changed lines and symbols, the callers the change affects and the git history; the file context, the PR description and the commit messages come last. If the pack goes over the limit, it is cut from the end, and a line saying so is added where it was cut. The order was chosen so that the part whose loss costs the least is the part left at the end.
• Lock files stay out of the diff. Files a tool writes, such as go.sum, package-lock.json and uv.lock, vendor folders and minified files are taken out of the diff, and their names are written on a single line. The code keeps the reason as a measurement: on one pull request in the benchmark set, go.sum and go.work.sum were 68.5% of the diff, and the source file holding the bug under review was 4.2%.
• The area around the change goes in, not the whole file. Each skipped range of lines is written with its line numbers, so the model knows what is missing.
• The repository’s rules travel outside the pack. The rules in the rules file that must be followed are added separately to every agent’s system prompt, so the cut never touches them. This is the review side’s counterpart of the coding agents’ advice to “put lasting rules in the rules file”.
• A file that was not read is recorded. Every review records whether each changed file reached the agents whole, in part or not at all. If some files were not read in full in a review that produced no findings, the pull request comment says so in one sentence.

Whatever tool you use, the lesson is the same: if the agent did not read a file, a “no findings” answer says nothing about that file. With a coding agent too, look at what is in the window before you say “it already knows that”: in Claude Code, Copilot CLI and Antigravity CLI, /context shows it.