Context Windows for Coding Agents, Explained

Published September 24, 2026 · by the AQ team

A context window is the maximum number of tokens a model can read and write in a single request: your instructions, every file the agent has opened, every command output, and the model's own replies all have to fit inside it. For coding agents like Claude Code, Codex, and Cursor, the context window is the session's working memory, and it fills far faster than chat, because tool output (file contents, diffs, test logs) lands in it alongside what you typed. As of September 2026 the models these agents run advertise windows from 200K to 2 million tokens, but two facts matter more than the headline number: the harness often runs the model at a smaller effective window than the API advertises, and output quality degrades well before any window is full.

What fills a coding agent's context window

A token is the unit models read text in, roughly three to four characters of code. Your own messages are usually the smallest item in the window. The rest is machinery:

• The system prompt and tool definitions. The harness's own instructions plus a schema for every tool. MCP servers add their definitions on top; Cursor's January 2026 dynamic context discovery research reported that loading MCP tools selectively instead of all at once cut token usage by 46.9 percent.
• Memory and instruction files. CLAUDE.md, AGENTS.md, rules files, and loaded skills ride along on every turn.
• Tool output. Every file read, every grep result, every build log, every failing test trace. This is the bulk of a real session.
• The conversation itself. Prior turns accumulate, and each new request resends everything so far, which is also why long sessions cost disproportionately more; coding agent token costs for teams works through that math.

Why long sessions degrade before the window is full

Context rot is the measured decline in model output quality as input context grows, and it starts long before the window limit. Chroma's context rot study (published July 2025) tested 18 frontier models, including GPT-4.1, Claude Opus 4, and Gemini 2.5, and found every one performed worse as input length grew, even when the window was nowhere near full. Two mechanisms compound in coding sessions. Models attend most reliably to the beginning and end of context and least to the middle (the lost in the middle effect), which is where a long session buries the constraint you stated at the start. And distractors accumulate: even one near-miss passage in context measurably reduced accuracy in the study, and a coding session generates near-misses constantly, in the form of stale file versions, abandoned approaches, and error output from paths already left behind.

In practice this shows up as an agent that re-reads files it already saw, forgets an instruction from an hour ago, or confidently edits a version of a function that no longer exists. That is not a broken model; it is a full, noisy window.

What compaction actually does in Claude Code, Codex, and Cursor

Compaction (some vendors say summarization) replaces the transcript with a model-written summary, freeing the window so the session can continue. It is lossy by design: the summary keeps what the summarizer judged important, and everything else is gone. As of September 2026, per each vendor's own documentation:

• Claude Code compacts automatically as the conversation nears the window limit, replacing older messages with a summary. The /compact command compacts on demand and takes instructions (for example, /compact focus on the auth bug), the /rewind menu can summarize from or up to a chosen message, and the threshold at which the automatic pass fires is configurable in settings or via an environment variable.
• Codex CLI compacts once tokens cross a threshold, producing a handoff summary that frames the next turn; a /compact command triggers it manually. Notably, Codex runs the GPT-5.6 family at a 272K effective window even though the models advertise 1M at the API level: OpenAI's own harness chose a smaller, denser window over a bigger, noisier one.
• Cursor summarizes older messages when the window fills, and its documentation is candid that the agent's knowledge can degrade after summarization. Its mitigation is writing the chat history to files the agent can search afterward: when the summary lacks a detail, the agent greps its own past instead of guessing. Long tool outputs are converted to files rather than held in the window.

Memory files are the other half of the story, and they are not session memory. CLAUDE.md and AGENTS.md are standing instructions loaded fresh into every session: conventions, build commands, review rules. They persist because they live outside the window, in the repository. What they do not hold is anything the agent learned mid-session; that lives only in the transcript, survives compaction only if the summary kept it, and dies with the session. Durable rules go in memory files; anything a future session will need gets written to a file or a commit, not left in conversation.

Context windows of the models coding agents run (September 2026)

Advertised windows, verified on each vendor's documentation as of September 2026; where the harness uses a different number, the notes say so.

Read the table with the Codex row in mind: OpenAI deliberately caps a million-token model at roughly a quarter of its window inside its own harness, Claude Code's auto-compaction fires well before the limit, and Grok's pricing step above 200K prompt tokens makes the economics explicit. The harness treats the advertised window as a ceiling to stay under, not a budget to spend.

The operating habits that follow

If quality decays with context length and compaction is lossy, the goal is not a bigger window. It is keeping each window small, clean, and on one subject:

• One task per session. Finish the bug fix, land it, and start the refactor in a fresh session with a clean attention pattern; carrying it into the bug fix's leftover context imports every one of its distractors.
• A fresh session in a fresh worktree per task. Session isolation and file isolation solve the same problem at two layers. Git worktrees for AI coding agents covers the file layer: each task gets its own checkout and branch, so parallel work never collides.
• Parallel sessions instead of one long one. Three agents on three scoped tasks in three worktrees beat one agent grinding through a nine-hour transcript. Running multiple Claude Code sessions in parallel shows the mechanics.
• Compact deliberately, at boundaries. A /compact with instructions after a milestone keeps what you choose; an auto-compact firing mid-task keeps what the summarizer guessed.
• Keep standing context lean. Memory files, MCP servers, and skills ride in every window. Prune the servers you do not use and keep CLAUDE.md to rules the agent actually needs.
• Externalize state the next session will need. A plan file, a progress note, a commit message. Files survive compaction; transcripts do not.

Where AQ fits

AQ is the multiplayer coding harness where engineering teams run AI coding agents like Claude Code and Codex together: shared live terminals, a code editor, and app previews, in your own cloud. The habits above are AQ's workspace model. Each workspace is one task in its own isolated git worktree (branch ai/{id}-{slug}, dependencies installed automatically, one-click rebase onto main), so a fresh session per task in a fresh checkout is the default rather than a discipline, and running several scoped sessions in parallel is just opening several workspaces. The agents are the real CLIs (Claude Code, Codex, Cursor Agent, Kimi, Grok, or plain shells) in persistent tmux sessions on your team's VM, streamed live to the browser, so a long run survives a closed laptop and resumes from any device, and teammates can open the same workspace and watch the same live session. Everyone logs into the CLIs with their own Claude or OpenAI account, and AQ never marks up usage on your own subscriptions.

Pricing is two plans: Free is a personal sandbox for one person (AQ creates a private machine in an isolated network, nothing to install, no time limit), and Team is $50 per user per month early access (standard $200, billed monthly), covering VMs you connect from your own cloud or a dedicated always-on AQ-managed VM, with your rate locked for your first 12 months.