This model's maximum context length is: fixing context_length_exceeded

This model's maximum context length is N tokens

Three providers, three wordings, one condition. Search traffic clusters around the OpenAI phrasing because it is the oldest and the most quoted, but knowing all three saves you when your gateway abstracts the provider away.

The most useful property of the OpenAI wording is that it gives you both numbers. The gap between them tells you which fix you need: 300 tokens over is a trimming problem, 300,000 over is an architecture problem, and treating the second like the first is how people end up with a truncation function that quietly destroys the beginning of every conversation.

What actually counts toward the window

People budget for the prompt and get surprised by everything else. OpenAI defines the window across three categories, verbatim: input tokens, output tokens, and reasoning tokens, the last being tokens "used by the model to plan a response". That third category is the one you cannot see and cannot easily predict.

Prompt caching is worth a sentence here because it is regularly misunderstood as a context fix. It is not. A cached prefix costs a fraction of the price, typically a tenth on read, and occupies exactly the same number of tokens in the window. Caching solves cost and latency. It does nothing for this error.

The current limits, and the caps hiding inside them

Windows grew enormously through 2026, which changed the character of this error: it is now far more often a history-management bug than a real ceiling.

• The 922,000 input cap on GPT-5.6 is separate from the window. You can be inside 1,050,000 and still rejected for input alone. Two limits, two failure modes.
• Anthropic no longer gates 1M behind a beta header. The docs are explicit: for every model with a 1M window, 1M is the default, no header, and long-context requests are billed at standard rates. If your code still sends context-1m-2025-08-07, delete it.
• Gemini 3.1 Pro prices in two bands, $2 and $12 per million up to 200k input and $4 and $18 above it. The window does not change; the invoice does.
• GPT-5.6 has a price cliff at 272K input: past it, the whole request bills at 2x input and 1.5x output. A 280k-token request costs disproportionately more than a 270k one.

Measure before you fix

Counting tokens before you send is cheap, and both major providers give you an endpoint for it. Guessing at four characters per token is fine for a rough sanity check and useless for a limit that rejects you at one token over.

count = client.messages.count_tokens(
    model="claude-sonnet-5",
    system=SYSTEM_PROMPT,
    tools=TOOLS,          # schemas count, and people forget them
    messages=messages,
)
print(count.input_tokens)

The number that matters is not the total, it is the breakdown. Log the four components separately, once, on a representative conversation:

1. System prompt. Fixed cost, paid every turn. If it is above a couple of thousand tokens, it is worth an edit.
2. Tool schemas. Also fixed, also every turn, and usually the most compressible thing in the request. Descriptions written for a human reader are the usual culprit.
3. History. The part that grows. If this is 80% of your total, no amount of prompt editing will help you.
4. The largest single message. Nine times out of ten it is one tool result: a whole file, an unpaginated query, a full HTML page from a fetch.

Four fixes, cheapest first

1. Trim the history

Drop the oldest turns until you fit. Fast, stateless, and it silently loses whatever was decided early in the conversation, which for a coding agent is usually the requirements. Two rules make it survivable: never split a tool exchange, because a tool_use without its tool_result is an immediate 400 on Anthropic, and always keep the first user turn, because it usually carries the actual task.

2. Compact

Summarize the older half of the conversation into a single message and continue. This is what Claude Code does at its context threshold and it is the best general answer for long-running agent sessions: it preserves decisions and discards transcript. The cost is one extra model call and the permanent loss of exact wording, which matters if the conversation contained precise identifiers or code that will be referenced verbatim later.

3. Move the bulk out of context entirely

If you are pasting a corpus into every request, retrieval is the right answer and the window is not your problem. Chunk, embed, and fetch the three passages that matter per turn. This is more infrastructure than the other options and it is the only one that scales past a window of any size. It also fails differently: instead of an error you get a confident answer based on the wrong chunk, so it needs evaluation in a way trimming does not.

4. Route to a bigger window

The escape hatch, and the one to reach for last. It works, it is one line, and it hides the underlying growth until you hit the bigger limit too. Two costs to weigh: money, since GPT-5.6 doubles input pricing past 272K and Gemini 3.1 Pro steps up past 200k, and quality, because recall across very long contexts degrades well before the hard limit. A conversation that only fits in a million tokens is usually a conversation that should have been compacted. If you do route up, the cards for Claude Fable 5 at 1,000,000 input tokens and gpt-5.6-sol at 1,050,000 carry the exact window and output ceiling for each.

Questions people ask

Keep reading

Continue through Errors and fixes with The server had an error while processing your request: OpenAI 500, 502, 503 and 504.