[Windows][GPT-5.6 Sol] Fresh Codex Desktop session rapidly reaches 90% of 258K context and auto-compacts with repeated tool calls

What version of the Codex App are you using (From “About Codex” dialog)?

26.805.11740

What subscription do you have?

ChatGPT Plus

What platform is your computer?

Microsoft Windows NT 10.0.26200.0 x64

What issue are you seeing?

A fresh Codex Desktop session using GPT-5.6 Sol with Medium reasoning effort is consuming its effective context window unusually quickly during normal development work.

This was my first working session after the weekly usage reset, starting at approximately 100% weekly usage remaining.

The task was ordinary development/review work. Codex used multiple kinds of tools as needed, including file reads/searches, shell commands, repository inspection, browser/Playwright operations, screenshots/image inspection, and other available tool calls.

Within this same fresh thread, the context indicator reached:

• 232k / 258k tokens used
• 90% context full

Automatic context compaction had already occurred for the first time.

At approximately the same point, my weekly usage remaining had dropped from about 100% to 94%.

The main issue is not a particular tool or Playwright specifically. The problem is the rate at which context grows while Codex performs normal tool-driven development work.

I also observed many tool invocations during the task. Some of them may be necessary, but the combination of tool outputs, rapid context growth, and early compaction makes a fresh thread reach context pressure much sooner than I would expect.

The current UI does not provide enough information to determine what is responsible for the growth. For example, I cannot see how much of the 232k context comes from:

• conversation history
• system/developer instructions
• tool schemas
• file contents
• shell/command output
• browser data
• screenshots/images
• MCP/tool metadata
• cached or reconstructed state
• compaction summaries

I am not claiming that the approximately 6% weekly usage reduction was caused entirely by compaction or tool calls. I am reporting the observed combination of rapid context saturation, early compaction, repeated tool activity, and noticeable usage consumption in a fresh thread.

What steps can reproduce the bug?

1. Open Codex Desktop on Windows.

1. Start a completely fresh thread.

1. Select GPT-5.6 Sol with Medium reasoning effort.

1. Open an existing software project.

1. Give Codex a normal development or review task and allow it to use the tools it considers necessary.

1. The task can involve multiple tool types, for example:

• reading or searching project files
• running shell/terminal commands
• inspecting repository state
• using MCP tools
• using browser/Playwright when relevant
• viewing screenshots or images
• other normal Codex tool calls

1. Do not manually paste unusually large files or a very large prompt into the conversation.

1. Continue working normally and monitor the context-window indicator.

Observed in my session:

• Model: GPT-5.6 Sol
• Reasoning effort: Medium
• Initial thread state: fresh thread
• Weekly usage remaining at start: approximately 100%
• Context later reached: 232k / 258k
• Context pressure: 90%
• Automatic compaction: occurred during this first session
• Weekly usage remaining later: approximately 94%

The exact sequence of tools is not important to the issue. The behavior appears during normal development work as multiple tool calls and their outputs accumulate.

I do not currently have a minimal code snippet because this appears to be related to Codex session/context/tool orchestration rather than a specific project code path.

I can provide sanitized session/rollout diagnostics if needed.

What is the expected behavior?

A fresh Codex development thread should maintain usable context for substantially longer during ordinary tool-driven work.

Tool usage is expected, and some tool outputs can be large. However, Codex should manage those outputs efficiently enough that normal repository work does not rapidly push a fresh thread toward the effective context limit.

I would expect Codex to:

• avoid retaining unnecessarily large completed tool outputs in active context
• deduplicate repeated tool/file results where possible
• summarize completed tool activity without immediately requiring the same information to be fetched again
• avoid unnecessary repeated tool invocations when the relevant state has not changed
• reclaim a meaningful amount of context when automatic compaction occurs
• preserve enough post-compaction state to avoid compact → re-read/re-run → refill → compact loops
• keep context growth reasonably proportional to actual progress

It would also be useful for the context indicator to explain what is consuming the active window instead of showing only the total percentage.

Additional information

The closest existing report I found is #31033, which describes repeated
compact → brief work → compact loops while context remains around 94–98%.

My observation differs in an important way: the context reached 232k / 258k
(90%) and triggered its first automatic compaction during a fresh GPT-5.6 Sol
thread, before the session had developed into a long-running compaction loop.

This report therefore focuses on the unusually rapid context growth that appears
to lead into that failure mode, particularly during ordinary tool-driven work.