Compaction

Yes. Before each turn, after each model step that needs a follow-up, and when you switch to a model with a smaller window, Codex compares the active context (the last reported input + output token count) to an auto-compact limit of 90% of the model's context window (or model_auto_compact_token_limit if lower) and compacts when it is reached; it also force-compacts at the usable window, 95% of the context window. For the bundled 272,000-token models that means compaction at about 244,800 tokens, with a hard ceiling at 258,400.

model_post_turn_compact_threshold_percent (default 0, off) adds an optional extra check after a final answer.

Yes. Without a configured window, Claude Code compacts as the conversation reaches the model's context limit; models running a native 1M window (Fable, Sonnet 5+, Haiku 5.5, Opus 4.7+) compact at about 967K tokens, and Sonnet 4.6 / Opus 4.6 without [1m] (or any model with CLAUDE_CODE_DISABLE_1M_CONTEXT=1) compact at the 200K boundary. Context is measured from the latest API response's input tokens (input plus cache reads and writes), and a reserve for output is held back, so raising CLAUDE_CODE_MAX_OUTPUT_TOKENS makes it compact sooner.

Since v2.1.290 it also compacts a terminal conversation of 200K+ tokens left idle about 54 minutes on the one-hour prompt cache, just before the cache expires (idleCompaction).

On a model ID it doesn't recognise (such as a gateway alias) it compacts at the window it assumes for that ID; correct it with CLAUDE_CODE_MAX_CONTEXT_TOKENS.

Subagents compact independently as their own context fills.

Yes. When a chat's context window gets close to full, Cursor summarizes older parts of the conversation to make room, and this also happens partway through long tool-calling turns. Cursor does not publish the exact trigger percentage or token count. Its servers decide when to compact, and the preCompact hook reports the current context_usage_percent, context_tokens and context_window_size each time it happens.

The preCompact example payload (85%, 120000 of 128000 tokens) is only an illustration, not the threshold.

Yes. Before each model step OpenCode estimates the prompt size and compacts when it reaches the window minus a buffer. The estimate is the provider-reported tokens from the last response plus about 4 characters per token for anything added since. The default buffer is 15% of the window or 16,000 tokens, whichever is larger (models under 32k keep just 15%). The window is the model's input limit if it has one, otherwise its context limit.

Models with an unknown window never auto-compact; only a provider rejection triggers it.

The 2.1 default is earlier than the previous 10% reserve. v2.1.1 uses floor(window × 0.15); an explicit compaction.buffer overrides the default.

Yes. Pi compacts automatically when contextTokens > contextWindow - reserveTokens, with reserveTokens defaulting to 16384 (so a 200K-token model compacts above roughly 183.6K tokens). Context is counted from the last valid assistant response's reported usage (totalTokens, or input + output + cache read + cache write) plus a chars/4 estimate for any messages added since. Pi checks before each new prompt, after a tool batch finishes and before the next assistant response in the same run, and again when the run ends.

Right after a compaction, Pi ignores the old (pre-compaction) usage figures and estimates the rebuilt context from scratch until the next response arrives.

Partly

Set model_auto_compact_token_limit in config.toml to compact earlier; with the default model_auto_compact_token_limit_scope = "total" it is capped at 90% of the context window, while "body_after_prefix" counts only tokens added since the carried-over prefix. model_post_turn_compact_threshold_percent (0-100) also compacts after a final answer once that percentage of the usable window is used. There is no setting to turn automatic compaction off: the 95% usable-window guard always applies.

model_context_window can raise the window up to the model's maximum (872,000 tokens for most bundled models), which moves both thresholds.

Set the auto-compact window (100K to 1M tokens, capped at the model's window) with /autocompact 500k (saved per model under modelSettings), "autoCompactWindow": 500000 in settings for every model, claude --autocompact <size> for one launch, or CLAUDE_CODE_AUTO_COMPACT_WINDOW=500000, which overrides all the others; /autocompact auto returns to the default. CLAUDE_AUTOCOMPACT_PCT_OVERRIDE (1-100) can only lower the trigger percentage. Turn automatic compaction off with the Auto-compact toggle in /config (autoCompactEnabled: false) or DISABLE_AUTO_COMPACT=1, and all compaction including /compact with DISABLE_COMPACT=1.

A subagent can compact earlier with autoCompactWindow in its frontmatter (v2.1.296+).

Turning auto-compact off also turns off idle compaction; set idleCompaction: false to disable only the idle pass.

2.1.302 adds an Idle compaction row in /config to turn the idle pass off or back on, alongside the existing idleCompaction setting. Published changes also fix stopping a turn during compaction causing Prompt is too long.

Before 2.1.304, suffixes could be parsed as a small integer and clamped to 100K. The 2.1.304 changelog says k and M suffixes now work, with warnings for out-of-range or ignored values.

Not supported

No. There is no setting, flag or environment variable to change when automatic summarization triggers or to turn it off. The only lever is a bigger window: pick a larger-context model variant in /model or with --model 'model[context=1m]', or use /max-mode on legacy request-based plans.

Set compaction.buffer to the number of tokens to keep free below the limit; a larger buffer compacts earlier. Set "compaction": { "auto": false } to turn automatic compaction off. Manual compaction still works when it is off.

V2 has no OPENCODE_DISABLE_AUTOCOMPACT env var. V1's reserved becomes buffer.

Set compaction.reserveTokens (default 16384) in ~/.pi/agent/settings.json or <project>/.pi/settings.json; a larger reserve makes compaction happen earlier. Use compaction.modelOverrides keyed by exact provider/modelId to set a different reserveTokens or keepRecentTokens for one model. Turn auto-compaction off with "compaction": { "enabled": false } or the Auto-compact toggle in /settings. /compact still works when it is off.

compaction.enabled applies to all models and cannot be overridden per model.

Turning off auto-compaction also turns off automatic overflow recovery.

reserveTokens also limits how long the summary can be: up to 80% of it, capped by the model's maximum output.

Partly

Type /compact in the TUI (it can run even while a task is in progress). It takes no arguments, so you cannot tell a single /compact what to keep; persistent instructions only go through compact_prompt, which applies to local compaction only.

Run /compact, optionally with focus instructions such as /compact focus on the auth bug fix. To compact only part of the conversation, open /rewind, pick a message and choose Summarize from here or Summarize up to here, optionally typing guidance for the summary.

Run /summarize in an interactive session to summarize the conversation and free up context. /compress and /compact are aliases. The command takes no instructions, so you can't tell it what to keep, and it says No active session. if the chat has no turns yet.

Partly

Type /compact or press the leader key then c in the TUI. You can also call opencode api post /api/session/<id>/compact --data '{}', or ctx.session.compact() from a plugin. It runs at the next safe point, even for short histories. The command takes no instructions about what to keep; use compaction.keep.tokens or a plugin compaction hook instead.

The V1 alias /summarize is not registered in the V2 TUI.

Run /compact, or /compact <instructions> to tell the summary what to focus on. Pi adds your text to the summary prompt as Additional focus: <instructions>. In RPC mode, send {"type":"compact","customInstructions":"..."}. Extensions can call ctx.compact({ customInstructions }).

/compact fails with "Nothing to compact (session too small)" or "Already compacted" when there is nothing to summarise.

The TUI footer shows NN% context left, and /status shows NN% left (used / window). You can add a context item to the footer with /statusline. The percentage treats the first 12,000 tokens as baseline and measures against the full context window, so it reaches 0% later than auto-compaction fires (90%).

Run /context for a live breakdown of what fills the window (system prompt, tools, memory files, messages), including a warning when you are past the limit. For a constant readout, configure a status line that shows context_window.used_percentage; /usage also warns as you approach the auto-compact window.

The status line percentage is measured against the model's full window, so it no longer shows when compaction will run once you set a smaller auto-compact window.

The prompt bar footer shows how full the context window is as a percentage (set AGENT_CLI_HIDE_PROMPT_BAR=true to hide the bar). Run /context for a breakdown by category: system prompt, tools, rules, skills, MCP, subagents, summarized conversation and conversation. The /context command isn't in the slash-command reference table, but it's covered in the CLI changelog and present in CLI 2026.10.12.

The TUI prompt footer and the sidebar's Context section show the last response's tokens and the percentage of the model's context window, for example 45,000 (23%). Auto-compaction fires around 85% of the window (less on small models), so plan for compaction before 100%.

The approximate 85% trigger is the default in 2.1, not a universal configured threshold; the 16K minimum advances it on small windows.

The interactive footer shows context use as <percent>%/<window>, followed by (auto) when auto-compaction is on. The figure turns to a warning colour above 70% and an error colour above 90%, and shows ? right after a compaction until the next response reports usage. /session shows session statistics; RPC get_session_stats and the extension call ctx.getContextUsage() return the same contextUsage estimate that compaction uses.

With OpenAI (and Azure Responses) providers, Codex uses remote compaction: it sends the history plus a compaction trigger through the Responses API, and the server-side model returns one encrypted compaction item. With other providers it runs locally: the current model gets the summarization prompt (or compact_prompt) and writes a handoff summary, which is stored as a user message beginning with a fixed "Another language model started to solve this problem..." prefix. Either way the history is replaced by retained user messages, freshly rebuilt initial context, and the summary or compaction item. After that Codex warns that long threads and repeated compactions reduce accuracy.

Custom providers can choose with model_providers.<id>.capabilities.remote_compaction = "v2" or "unsupported".

With the token_budget feature enabled, compaction resets the context window without summarizing.

Claude Code sends a separate request to the session's model with the same system prompt, tools and history plus a summarisation instruction, and replaces the message history with the structured summary it returns (you see "Conversation compacted"). The request inherits the session's extended-thinking setting and uses your fallback model chain, but never falls back to a model with a smaller context window. Startup context such as CLAUDE.md and memory is then reloaded from disk around the summary.

In 2.1.301, switching to a smaller model window can first summarize the conversation with the previous model. The release also fixes repeated compaction when a gateway reports a different model name. These are published changes, not a new measured threshold.

Partly

Cursor's backend writes the summary, not your local CLI. The CLI sends a summarize action and shows Summarizing while it runs. Older messages are replaced by a summary that counts as 'Summarized conversation' in the context breakdown, and your latest message is kept word for word. Cursor doesn't document which model writes the summary, and for teams that don't allow data storage, summarization fails rather than storing data.

In 2.1, summary compaction normally sends the whole conversation, including the tail that will be kept, to the summary model so it can reuse the normal prompt cache. It writes a structured checkpoint (Objective, Requirements, Decisions, Work State, Next Move, Relevant Files, Important Context), and later requests combine that summary with recent text reconstructed from metadata.keepID. If the whole request cannot fit, the implementation falls back to the history before the retained tail and then progressively shrinks it. A supported native compaction instead stores its provider replacement window in native.messages.

The docs say there is no separate compaction model, but the source does honor a model set on the hidden compaction agent.

The summary call no longer stores unused provider replay data. A compaction hook may still supply result.native; native.messages overrides text replay when present.

Pi asks the current session model to write a structured checkpoint summary (Goal, Constraints & Preferences, Progress, Key Decisions, Next Steps, Critical Context, plus lists of files read and modified). It sends the older messages as serialized text with thinking blocks removed and each tool result cut to 2000 characters. Pi then appends a compaction entry, and later requests get the system prompt, then the summary, then the recent messages kept verbatim. On repeat compactions, the previous summary is updated rather than rewritten from scratch.

When a single long user turn exceeds the kept budget, Pi writes two summaries (earlier history and the start of that turn) and merges them.

An extension can supply the summary instead, using any model it likes.

Partly

Codex rebuilds the initial context after compaction: base and developer instructions, AGENTS.md, environment and permissions context, and the skills and plugins catalog. Local compaction keeps your most recent user messages, up to about 20,000 tokens. Remote compaction keeps your user messages and short non-final sub-agent messages (each up to 10,000 tokens), up to about 64,000 tokens total, newest first. Assistant replies, tool calls and tool outputs are dropped and survive only through the summary.

Images in retained messages may be dropped (only their text is kept) when the token budget is exceeded.

The system prompt and output style still apply; project-root CLAUDE.md, unscoped rules, auto memory and the plan-mode plan are re-injected from disk, and a fresh git status is read. Claude Code re-reads up to five recently modified files it read or edited (files over 5,000 tokens come back as a path only), re-injects invoked skill bodies capped at 5,000 tokens each and 25,000 total, keeps the task list, and reminds Claude of running background commands and subagents. Path-scoped rules and nested CLAUDE.md files are summarised away until a matching file is touched again, and the skill listing is not re-sent.

Recent turns are folded into the summary rather than kept verbatim, except in overflow recovery, which can keep the newest exchanges or your newest prompt word for word.

Before 2.1.304, /reload-skills was the documented way to restore the catalog after compaction; the 2.1.304 release changes this behavior as described below.

2.1.304 resends the skill list after compaction; /reload-skills sends only new or changed skills. This listing is separate from restoring invoked skill bodies.

Partly

The system prompt, tool definitions, rules, skills, MCP instructions and subagent docs are counted separately from the conversation, so summarization doesn't touch them. Since September 2026 your most recent message is kept word for word after summarization. In CLI 2026.10.12 the session also stores todos, plans and invoked skill blocks outside the summarized turns. Cursor doesn't document exactly how many recent turns or files are kept.

About compaction.keep.tokens of the newest conversation is kept beside the summary (default 15,000), starting at a user-message boundary. In that kept part, tool output over 1,250 characters is shortened and attachments become one-line descriptions. Instruction files such as AGENTS.md are excluded from the summary and resent in their current version as the new baseline. Activated skill text is kept only if it falls inside the recent window.

Since 2.1, newly written summaries reference the first retained message with metadata.keepID instead of duplicating recent text. History reconstructs the text up to the checkpoint; forks remap this reference. Legacy recent text is decoded as metadata.recent.

The system prompt is kept in full: context files such as AGENTS.md, tool declarations and loaded skill descriptions. It is stored as a checkpoint in the compaction entry and replayed ahead of the summary. Roughly the last compaction.keepRecentTokens (default 20000) of messages stay verbatim; cuts never separate a tool result from its call. Everything older survives only as the summary, which carries forward cumulative <read-files> and <modified-files> lists. There is no separate todo or plan store to preserve.

Skill bodies the model loaded during the conversation are ordinary messages, so older ones are summarised like anything else.

Extension state stored in session entries follows the session tree and survives compaction.

Partly

Yes, separately from compaction: each tool or function output is truncated when it is stored in history, to 10,000 tokens by default for bundled models. You can change this with tool_output_token_limit (or per MCP tool with mcp_servers.<id>.tools.<tool>.output_token_limit). Before remote compaction, Codex also shortens old function-call outputs if needed so the request fits the window. There is no separate setting to prune old turns.

Yes. As the context fills, Claude Code clears older tool outputs first and only summarises if that isn't enough, and when a request would exceed the image or PDF limits it drops a batch of the oldest images and PDFs. There is no setting to tune or disable this clearing.

Not documented

Cursor doesn't describe any separate step that trims old tool outputs without summarizing, and there is no setting to control one. The only documented ways to free context are automatic summarization and /summarize.

Not supported

No. V2 has no separate tool-output pruning. compaction.prune and compaction.tail_turns are ignored with a warning, and recent context is kept by token budget only. Tool output is shortened only inside the compaction checkpoint.

Partly

Pi does not prune or clear old tool outputs on its own. The only automatic trimming is that tool results are cut to 2000 characters inside the text sent for summarisation. Extensions can trim without summarising by appending context_edit entries, which omit or replace earlier messages in future requests while keeping them on disk, or by filtering messages in a context event handler.

During overflow recovery, Pi itself appends context_edit entries to drop the failed attempt from future context.

Yes. The session rollout under ~/.codex/sessions/ is append-only: compaction adds a compacted record with the replacement history (and, for local compaction, the summary text in message) after the original turns, which remain. Remote compaction summaries are encrypted, so you cannot read them; codex resume restarts from the latest compaction point.

Yes. The session JSONL in ~/.claude/projects/<project>/<session-id>.jsonl keeps the earlier messages, with a compact_boundary entry recording the trigger and pre-compaction token count, and fullscreen mode keeps every earlier message in scrollback. To read the summary itself, use a PostCompact hook (compact_summary) or the Agent SDK's compact_boundary message stream.

With CLAUDE_CODE_TRANSCRIPT_LOCAL_GC=1, long -p and Agent SDK sessions drop pre-compaction history from transcripts over 5 MB.

Transcripts are deleted after cleanupPeriodDays (30 days by default).

Yes. Each chat's ~/.cursor/chats/<hash>/<chatId>/store.db keeps summary archives that hold the messages that were summarized, and a JSONL copy is written to ~/.cursor/projects/<slug>/agent-transcripts/<chatId>/. After summarizing, the CLI shows the summary in a cyan Summary box in the chat. If summarization fails or you press Stop during it, the earlier conversation is kept.

The store.db and JSONL formats are internal and undocumented.

Yes. Earlier messages remain stored. In 2.1, a completed summary stores summary text and metadata.keepID referencing the first retained message; history reconstructs the kept text rather than duplicating it in the checkpoint. Legacy compactions retain their text through metadata.recent. Native checkpoints store native.messages. The TUI shows compaction as it starts, streams and ends.

Yes. Sessions are append-only JSONL files under ~/.pi/agent/sessions/--<path>--/, and compaction only appends a compaction entry. Every original message stays on disk and in /tree, /export and /share. The summary is stored in that entry's summary field and appears in the transcript as a collapsible block showing the token count before compaction; click it to expand.

Set compact_prompt (inline) or experimental_compact_prompt_file (a file path) in config.toml to replace the summarization prompt; the inline value wins, and both apply only to local compaction. PreCompact and PostCompact hooks run around both manual and auto compaction (matcher on trigger: manual or auto). A hook returning continue: false stops the turn, but it cannot change the summary.

Pass instructions to /compact, or add a # Compact instructions section to the project CLAUDE.md to steer every summary. Hooks: PreCompact (matcher manual or auto) receives the /compact instructions and can block compaction with exit code 2 or {"decision":"block"}; PostCompact receives the compact_summary; and a SessionStart hook with matcher compact adds its output to the compacted context. The built-in summary prompt itself cannot be replaced.

Blocking an automatic compaction that was triggered to recover from an overflow makes the request fail with the original error.

Partly

You can't change the summary prompt. A preCompact hook in hooks.json runs before every compaction and receives trigger (auto or manual), usage numbers and messages_to_compact. It can only observe: it can return a user_message to show you, but it can't block or change the compaction. A Claude Code PreCompact hook is mapped to preCompact. There is no post-compaction hook.

Plugins can register ctx.session.hook("compaction", ...) to edit the messages, system text, or options of the summary request. Setting event.result = { summary } supplies your own summary and skips the model call. Plugins can follow session.compaction.started, delta, ended, and failed events. The built-in summary prompt itself can't be changed in config, and there are no PreCompact or PostCompact shell hooks.

OpenCode appends its own summary prompt after the hooks run, so a hook cannot replace it except by supplying result.

2.1 replaces SessionCompactionResult.providerState with native. Hook metadata can override keepID; result.native.messages supplies a replacement message window. The obsolete session.compacted event is removed; use session.compaction.started/ended.

Yes, through extensions. session_before_compact fires before manual, threshold and overflow compactions and can cancel or return your own summary, firstKeptEntryId and details. session_compact fires after success and session_compact_failed after a failure or abort. session_before_tree does the same for branch summaries. The built-in summary prompt cannot be changed by a setting; use /compact <instructions> or an extension.

The event payload includes reason (manual, threshold or overflow) and willRetry. JSON and RPC streams emit compaction_start and compaction_end events.

Partly

If a normal request still overflows, the turn ends with "Codex ran out of room in the model's context window. Start a new thread or clear earlier history before retrying." Codex then marks the context as full, so the next turn compacts before sending, but it does not retry the failed request. If the compaction request itself overflows during local compaction, Codex drops the oldest history items one at a time and retries.

Codex compacts and retries in the same turn only for Guardian auto-review sessions whose review budget is exhausted.

If the API rejects a request as too long (Prompt is too long), Claude Code compacts the oldest exchanges and retries, compacting again with less recent history if needed, and as a last resort keeps only your newest prompt verbatim. If that fails, or auto-compact is off, you see Context limit reached · /compact or /clear to continue. If the context refills to the limit right after compacting several times, it stops with an Autocompact is thrashing error.

A single-exchange conversation can't be compacted; the error explains whether your content or the system prompt, tools and attachments fill the request.

CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT=1 makes unrecognised model IDs rely only on this overflow recovery.

2.1.304 fixes prompt/context-limit errors after interrupting compaction of a conversation rejected as too long, according to the release notes.

Since v2026.10.08, a session that hits the context limit summarizes and then continues the turn instead of getting stuck. An earlier fix (v2026.09.15) stopped long Claude and GPT turns from re-compacting on every step without freeing any space.

If the provider rejects a request as too long, OpenCode compacts, aiming at 70% of the rejected size, and retries once. A second rejection is returned as an error. If the summary request itself is too long, OpenCode sends a flattened text version and shrinks it to 70%, 50%, then 35%, dropping the oldest exchanges, before giving up. With compaction.auto: false it does not compact on overflow and returns the error.

The docs' Settings table says auto controls overflow recovery as well as preflight compaction, and the source agrees: auto=false skips both.

In 2.0.29, output-token-limit (finish reason length) recovery is separate from context-overflow compaction: source adds continuation guidance and fails after three consecutive length-limited assistant responses (two continuations).

In 2.0.30, the summary request and its retry reduce the output-token allowance to fit the actual estimated prompt remaining in the model window. This is summary request budgeting, not a new auto-compaction threshold.

If the provider returns a context-overflow error, or a response stops early with stopReason: "length", Pi drops the failed attempt from context, compacts and retries once. A second failure shows "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model." If a successful response pushes past the window, Pi compacts without retrying.

Recovery is skipped when compaction.enabled is false, or when the error came from a different model than the one now selected.

Custom providers with unusual overflow messages must map them to context_length_exceeded for recovery to trigger.