DEV Community

Tahir Nazir
Tahir Nazir

Posted on Originally published at its-tahir.com

I Read Codex's Source to Find When It Auto-Compacts. It's 90%, and You Can't Turn It Off

#ai #openai #programming #productivity

Originally published at its-tahir.com.

Codex users keep asking when auto compaction fires and why raising the limit doesn't delay it. So I read the 0.166.0 source: auto compaction starts at 90% of the context window (244,800 tokens on a 272K model), model_auto_compact_token_limit can only move it earlier, and there's no off switch. Here's what you can actually change. How do you keep long Codex sessions from losing the plot?

Codex auto compacts a conversation when it reaches 90% of the model's context window. In the model catalog bundled with Codex 0.166.0, most models have a 272,000-token window, so compaction starts at 244,800 tokens (your live catalog can differ; check yours): Codex shows Compacting context, replaces older turns with a summary, and then shows Context compacted. There is no setting that turns it off. model_auto_compact_token_limit can only make it start earlier; to make it start later, raise model_context_window. To keep it from interrupting work, run /compact yourself or set model_post_turn_compact_threshold_percent so it compacts between turns.

You want Set this in ~/.codex/config.toml
Compact earlier, at a fixed token count model_auto_compact_token_limit = 150000
Compact later model_context_window = 500000 (up to the model's maximum)
Compact between turns, not mid-task model_post_turn_compact_threshold_percent = 70
A different summary compact_prompt = "..." or experimental_compact_prompt_file = "path"
Compact right now Type /compact
Turn auto compaction off Not possible in Codex 0.166.0

Last reviewed 6 November 2026, against Codex 0.166.0. The threshold rules come from the 0.166.0 source code on GitHub and the bundled model catalog; settings from OpenAI's configuration reference; on-screen messages from the 0.166.0 Linux package, which I downloaded from npm and searched without running it. I couldn't run a signed-in Codex session for this post, so the numbers are what the code computes, not measurements from my own sessions.

When Codex auto compacts, Codex 0.166.0. Default 272,000-token window, the most common size in the bundled catalog: auto compact at 244,800 tokens (90%), hard cap that always compacts at 258,400 (95%). model_context_window = 872000: auto compact at 784,800. model_post_turn_compact_threshold_percent = 70: turn-end compact at 180,880, 70% of the 258,400 usable window. There is no setting that turns auto compaction off.

Auto compaction starts at 90% of the context window. The only ways to move it later are a bigger window or a manual /compact before you reach it.

What is auto compact in Codex?

Auto compact is Codex summarizing its own conversation when the context window is nearly full, so a long task can keep going. Every request Codex sends to the model includes the conversation so far. When that history gets close to what the model can accept, Codex replaces earlier turns with a shorter summary and carries on. In the CLI you see two lines:

Compacting context
Context compacted
Enter fullscreen mode Exit fullscreen mode

The same thing happens when you type /compact; auto compaction just picks the moment for you. Codex can compact at three points in a turn: before it sends your next message, in the middle of a turn when a tool result pushes the context over the limit, and (if you turn it on) after a finished reply.

When does Codex auto compact?

Codex auto compacts when the active context reaches 90% of the model's context window: 244,800 tokens on a 272,000-token model in Codex 0.166.0, and 450,000 on a 500,000-token one. As a rule: the threshold is the smaller of model_auto_compact_token_limit and 90% of the context window, and reaching 95% of the window always forces compaction. This is the function in Codex 0.166.0 that sets it:

pub fn auto_compact_token_limit(&self) -> Option<i64> {
    let context_limit = self
        .resolved_context_window()
        .map(|context_window| (context_window * 9) / 10);
    let config_limit = self.auto_compact_token_limit;
    if let Some(context_limit) = context_limit {
        return Some(
            config_limit.map_or(context_limit, |limit| std::cmp::min(limit, context_limit)),
        );
    }
    config_limit
}
Enter fullscreen mode Exit fullscreen mode

So it returns the smaller of that 90% figure and any limit set for the model or in your config. The model catalog bundled with 0.166.0 sets no per-model limit, so for every listed model the 90% figure is the threshold:

Model (bundled catalog, 0.166.0) Context window Auto compact at Maximum window
gpt-6.1-sol*, gpt-6-sol, gpt-6-luna, gpt-6-astra 272,000 244,800 872,000
gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna 272,000 244,800 872,000
gpt-6.1-terra 500,000 450,000 872,000
gpt-5.5 272,000 244,800 272,000

* Two caveats. Codex downloads a fresh catalog from OpenAI and caches it, so the live values for your account can differ from the bundled file. In one user's cache from 18 October 2026, quoted in #55008, gpt-6.1-sol had a 500,000-token window, which puts its threshold at 450,000. And there's a second, harder limit: 95% of the window (258,400 tokens on a 272K model) is what Codex treats as usable, and reaching it forces compaction regardless of your settings.

Some summaries put the threshold at 40 to 50% of the window, or about 220,000 tokens. In Codex 0.166.0 it is 90% of the window, which is 244,800 tokens on a 272K model.

How do I check my own Codex compaction threshold?

Open ~/.codex/models_cache.json (or models_cache.json in your CODEX_HOME), find your model's entry, and take 90% of its context_window. That file is the catalog Codex downloaded for your account, so it beats any table, including mine. Three fields matter:

  • context_window: the window Codex uses. Your threshold is 90% of it.
  • auto_compact_token_limit: if it's set, the threshold is the smaller of this and the 90% figure. In the bundled catalog it's null for every model.
  • max_context_window: the most you can raise model_context_window to.

If you set model_context_window or model_auto_compact_token_limit in config.toml, those override the file, with the same 90% cap.

How do I change the auto compact threshold?

model_auto_compact_token_limit moves it earlier; model_context_window moves it later. Both go in ~/.codex/config.toml.

To compact earlier, for example to keep each request smaller and cheaper:

model_auto_compact_token_limit = 150000
Enter fullscreen mode Exit fullscreen mode

Codex uses the smaller of your number and 90% of the window, so a value above 244,800 on a 272K model changes nothing. Raising this setting is not a way to stop compaction.

To compact later, give the model a bigger window, up to the maximum listed for it in the catalog:

model_context_window = 500000
Enter fullscreen mode Exit fullscreen mode

Codex caps this at the model's max_context_window (872,000 for most current models in the bundled catalog, 272,000 for gpt-5.5), and the 90% rule applies to the new size: 450,000 tokens for a 500K window, 784,800 for 872K. Keep in mind that a bigger window lets each request near the end of a long session carry more tokens, which uses more of your plan or costs more on an API key. A context window checker helps you see whether a big file or log fits before you paste it in.

There's also model_auto_compact_token_limit_scope. The default, total, counts the whole active context against the limit. body_after_prefix counts only what's been added since the last compaction's carried-over prefix, which is for setups that want each compaction window to have a fixed budget.

Can I disable auto compact in Codex?

No, not in Codex 0.166.0. There's no config key, flag or slash command that turns it off for your sessions. The source does have an off switch, a thread setting called AutoCompactionDisabled in codex-rs/core/src/compact.rs, but only the app server sets it, for threads it starts internally. Nothing in your config can. An issue asking for more control over auto-compaction (#4106) has been open since September 2025.

What you can do instead:

  1. Push it later with a bigger model_context_window, as above.
  2. Choose the moment by running /compact at a natural break, before Codex reaches the threshold mid-task.
  3. Move it between turns with model_post_turn_compact_threshold_percent (next section).
  4. Start a new thread when a task is done, instead of stretching one conversation across several tasks.

The error for a request that doesn't fit in the window reads:

Codex ran out of room in the model's context window. Start a new thread or clear earlier history before retrying.
Enter fullscreen mode Exit fullscreen mode

How do I compact manually?

Type /compact and confirm. Per OpenAI's docs, "Codex replaces earlier turns with a concise summary, freeing context while keeping critical details." Doing it yourself after a task is finished, or before you start a new one in the same thread, means the summary covers finished work instead of half-done work.

Don't confuse it with /recap, which summarizes the conversation for you to read and leaves the context as it is.

How do I stop compaction from losing my task?

Compact between turns, and keep the task somewhere a summary can't drop it. A recurring complaint in Codex's issue tracker is that a summary written mid-task loses the current instruction, after which the agent asks what you'd like to work on or repeats finished steps (#57608, #57806, #57983). Three settings help:

  • model_post_turn_compact_threshold_percent. It's off by default. Set it to compact "after a final response when active context reaches this percentage of the usable context window." At 70 on a 272K model, that is 70% of the 258,400-token usable window, so Codex compacts at 180,880 tokens once a reply is finished, usually well before the mid-task threshold. The normal limits still apply if a single turn grows past them. 
  model_post_turn_compact_threshold_percent = 70
Enter fullscreen mode Exit fullscreen mode
  • compact_prompt (or experimental_compact_prompt_file for a longer one) replaces the instructions Codex uses to write the summary. Tell it to keep the current task, open decisions and file paths word for word.
  • PreCompact and PostCompact hooks run your own command around each compaction, for example to save the current plan to a file before the summary replaces it.

The habit that works in any version: keep the task and its acceptance criteria in a file in the repo (a TASK.md, or a section in AGENTS.md), and tell Codex to re-read it after compaction. A file isn't part of the conversation, so no summary can lose it.

Why does Codex compact too early?

Usually the threshold is lower than the number you're comparing it with. Common reasons:

  • The window is smaller than the model's maximum. Most current models run with a 272K window even though the catalog allows up to 872K, so compaction at about 245K is expected (check yours).
  • An old build. Codex 0.166.0 (29 October 2026) "preserved reasoning-token accounting across resume and fork to avoid premature compaction." If compaction started early after codex resume or a fork, update first. #59081 reports the same symptom on the Windows desktop app, on a build without that fix.
  • The display and the trigger measure different things. Reports such as #55126 describe compaction while the IDE still showed about half the context free. The trigger counts active context against 90% of the window, so a remaining-context figure based on a different total can look misleading.
  • Images. Since 0.150.1, remote compaction counts retained images toward its token budget and trims older ones.

Why is Codex stuck compacting, or compacting in a loop?

Compaction itself failed or didn't free enough room. When remote compaction fails, the 0.166.0 build logs Error running remote compact task, and a failed turn-end compaction logs Post-turn compaction failed; preserving the completed turn. Open reports describe compaction that leaves the next request no smaller, so it runs again and again (#59534), and remote compaction errors that stop further replies in the desktop app (#59475).

What to do:

  1. Update. Codex 0.164.0 stopped failed compactions from leaving partial summaries in the history. That doesn't fix every loop (#59534 was still open on 5 November 2026), but it rules out one cause.
  2. Find what's refilling the context. If it compacts, refills straight away and compacts again, a large tool output or file read is the usual cause. Ask for smaller reads, or narrower command output.
  3. Start a new thread with a short written summary of where the task stands. A fresh thread costs less than a loop that burns usage on repeated summaries.

Is Codex compaction local or remote?

It depends on the model provider. The configuration reference describes a provider capability, remote_compaction: v2 "sends compaction triggers through Responses", and unsupported "uses local compaction." Codex reports both kinds in its task.compact metric, split by type remote or local. Since 0.162.0 you can set the capability for custom Responses-compatible providers, and since 0.147.0 Amazon Bedrock supports remote compaction.

How is Codex auto compact different from Claude Code's?

Codex (0.166.0) Claude Code
Default trigger 90% of the context window (244,800 on a 272K model) The model's context limit, about 967K tokens on 1M-context models (details)
Change the trigger model_auto_compact_token_limit (earlier only), model_context_window (later) /autocompact, or autoCompactWindow
Turn it off Not possible Auto-compact in /config, or DISABLE_AUTO_COMPACT
Manual /compact /compact

If you use both, the Claude Code side is in Claude Code keeps compacting, and its compaction during breaks is covered in Compacted while idle. For how each tool decides what it may run without asking, see Codex auto mode.

What changed in Codex compaction recently?

Between 0.147.0 and 0.166.0 (August to October 2026), Codex brought remote compaction to Bedrock and custom providers, made failed compactions clean up after themselves, and fixed early compaction after resume.

Version Date Change
0.147.0 7 Aug 2026 Remote compaction for Amazon Bedrock
0.150.0 26 Aug 2026 Compaction fixed for Amazon Bedrock models
0.150.1 27 Aug 2026 Remote compaction counts retained images toward its token budget
0.155.0 17 Sep 2026 Accepted prompts are saved even when compaction fails before a turn starts
0.162.0 8 Oct 2026 Remote compaction capability configurable for custom Responses-compatible providers
0.164.0 23 Oct 2026 Failed compaction no longer leaves partial summaries in history
0.166.0 29 Oct 2026 Reasoning-token accounting kept across resume and fork, to avoid premature compaction

The dates are the dates on Codex's GitHub releases.

Key takeaways

  • Codex auto compacts at 90% of the model's context window: 244,800 tokens on the 272K models in Codex 0.166.0's bundled catalog, 450,000 on gpt-6.1-terra.
  • model_auto_compact_token_limit can only lower that point. To compact later, raise model_context_window, up to the model's maximum (872,000 for most current models).
  • There's no setting that turns auto compaction off in Codex 0.166.0. Run /compact yourself at a natural break instead.
  • Set model_post_turn_compact_threshold_percent (for example 70) to compact after a finished reply instead of mid-task, where summaries lose the current instruction.
  • Keep the task in a file Codex re-reads after compaction; no summary can drop it.
  • If compaction starts early after resume, update to 0.166.0; since 0.164.0 a failed compaction no longer leaves a partial summary behind.

FAQ

Related

FAQ

When does Codex auto compact?

When the active conversation reaches 90% of the model's context window. In the model catalog bundled with Codex 0.166.0, most models have a 272,000-token window, so auto compaction starts at 244,800 tokens; gpt-6.1-terra has a 500,000-token window, so it starts at 450,000. Codex refreshes that catalog from OpenAI, so the live values can differ. A lower model_auto_compact_token_limit makes it start earlier.

How do I change the Codex auto compact threshold?

Set model_auto_compact_token_limit in ~/.codex/config.toml to compact earlier. It can only lower the threshold: Codex uses the smaller of your value and 90% of the context window. To compact later, raise model_context_window instead, up to the model's maximum in the catalog (872,000 tokens for most current models in Codex 0.166.0). The 90% rule then applies to the bigger window.

Can I disable auto compact in Codex?

No. Codex 0.166.0 has no config key or flag that turns automatic compaction off for your sessions; the code can only disable it internally for certain threads the app server starts. The closest you can get is a later threshold, by raising model_context_window, and compacting at moments you choose with /compact.

How do I compact manually in Codex?

Type /compact in the CLI and confirm when Codex offers to summarize the chat so far. It replaces earlier turns with a concise summary to free context. /recap is different: it summarizes the conversation for you without compacting the context.

Why does Codex lose my task after compaction?

Because compaction replaces earlier turns with a summary, and a summary written mid-task can drop the current instruction. Several Codex issues report exactly this. Setting model_post_turn_compact_threshold_percent (for example to 70) makes Codex compact after a finished reply instead of in the middle of work, and keeping the task in a file the agent re-reads survives any summary.

Why does Codex compact so early?

Usually because the threshold is lower than the number you're looking at. Auto compaction starts at 90% of the context window, and the window can be smaller than a model's advertised maximum. Codex 0.166.0 also fixed reasoning tokens being counted wrongly after resume or fork, which caused premature compaction, so update first.

What does 'Codex ran out of room in the model's context window' mean?

It's Codex's error for a request that no longer fits in the model's context window: 'Codex ran out of room in the model's context window. Start a new thread or clear earlier history before retrying.' Run /compact, or start a new thread and carry the task over in a short written summary.

Is Codex compaction local or remote?

Both exist. A model provider's remote_compaction capability decides it: v2 sends compaction through the Responses API, and unsupported uses local compaction. Codex counts the two separately in its task.compact telemetry metric, by type remote or local.

Sources

Originally published at its-tahir.com.

Top comments (0)