GPT-5.1 Codex Max

The Model That Changed Codex From Long Context to Multi-Context Work

OpenAI introduced GPT-5.1 Codex Max on November 19, 2025.

It was built on an updated foundational reasoning model trained on agentic tasks across software engineering, mathematics, research, medicine, computer use, and related domains.

For Codex, the important innovation was not simply a better coding score.

It was compaction.

GPT-5.1 Codex Max was the first model in the line trained to:

• fill a context window;
• compact older session state;
• preserve the most important information;
• continue in a fresh context window;
• repeat the process until the task is complete.

That made it possible for one coding task to coherently process millions of tokens over time even though the model’s native per-window context limit remained 400,000 tokens.

OpenAI positioned the model for:

• project-scale refactoring;
• deep debugging;
• PR creation;
• code review;
• frontend coding;
• repository Q&A;
• multi-hour agent loops;
• long-running autonomous engineering.

It became the default model across Codex surfaces when it launched.

The API model is now retired.

OpenAI shut down gpt-5.1-codex-max on July 23, 2026.

Long-Horizon Quality Is About Staying on Task

A multi-hour coding agent needs more than raw coding intelligence.

It must avoid:

• forgetting the original objective;
• repeating completed work;
• undoing earlier fixes;
• rereading the same files unnecessarily;
• drifting into unrelated refactors;
• ignoring new test evidence.

Representative Max workloads included:

• project-scale refactors;
• deep debugging sessions;
• multi-file migrations;
• frontend implementation;
• code review;
• large PR creation;
• difficult repository Q&A.

Evaluation should therefore cover the full trajectory.

Track:

• completion rate;
• elapsed agent time;
• context-window transitions;
• compactions;
• files touched;
• commands executed;
• failed approaches;
• repair iterations;
• tests passed;
• human intervention.

A model that eventually returns a good patch after excessive looping may be less useful than one that reaches the same result with fewer tools and less reasoning.

Environment Diversity Matters for Coding Agents

Coding-agent quality depends on more than programming language knowledge.

The model may need to understand:

• filesystem conventions;
• shell differences;
• path separators;
• platform-specific commands;
• build tooling;
• environment variables;
• process behavior.

OpenAI’s Windows training was therefore a meaningful extension of the model’s practical engineering coverage.

At launch, Max was available across Codex surfaces including:

• CLI;
• IDE extension;
• cloud;
• code review.

The model was also trained with tasks intended to make it a better partner in Codex CLI workflows.

For evaluation, include the environments your real developers use.

A Linux-only benchmark may miss failures that appear in Windows repositories or PowerShell-oriented workflows.

Published High-Effort Comparison

OpenAI published the following comparison:

• SWE-bench Verified: GPT-5.1 Codex high — 73.7%; Codex Max xhigh — 77.9%;
• SWE-Lancer IC SWE: GPT-5.1 Codex high — 66.3%; Codex Max xhigh — 79.9%;
• Terminal-Bench 2.0: GPT-5.1 Codex high — 52.8%; Codex Max xhigh — 58.1%.

OpenAI noted that Max evaluations used compaction and Extra High reasoning.

These benchmark numbers should not be interpreted as a direct model-only comparison because effort settings differ.

They are still useful as historical evidence that Max targeted a higher ceiling on difficult engineering tasks.

The more controlled efficiency comparison is the separate medium-effort SWE-bench result where Max performed better while using around 30% fewer thinking tokens.

For production decisions, benchmarks should be supplemented with:

• your repositories;
• your test suites;
• your tool harness;
• your coding standards;
• your definition of an accepted patch.

Context Window and Task Horizon Became Different Numbers

This is the central architectural insight of Codex Max.

The model specification remained:

• 400K context;
• 128K max output.

But the task horizon could be much larger.

When Codex approached the active window limit:

1. accumulated history was compacted;
2. important state was retained;
3. a fresh window was provided;
4. execution continued.

OpenAI described this as coherent work over millions of tokens in a single task.

This distinction matters when comparing Max with models that advertise a very large single context window.

A larger native window reduces how often context management is needed.

Compaction instead allows the agent harness to explicitly manage long-term state.

Both approaches have tradeoffs.

Evaluate:

• information retained after compaction;
• number of compactions;
• forgotten constraints;
• duplicated work;
• total input tokens;
• completion success.

What Stayed the Same

Both models used:

• 400K native context;
• 128K output;
• $1.25 input;
• $0.125 cached input;
• $10 output;
• Responses API;
• text and image input;
• reasoning tokens;
• function calling;
• structured outputs.

What Changed

GPT-5.1 Codex Max added or emphasized:

• native training across multiple context windows;
• compaction;
• coherent multi-million-token task horizons;
• project-scale refactoring;
• multi-hour agent loops;
• improved reasoning-token efficiency;
• xhigh reasoning;
• explicit Windows training;
• stronger published coding benchmarks.

That makes ordinary GPT-5.1 Codex the single-window baseline and Codex Max the multi-context baseline.

For SEO and evaluation, this is the most important separation between their pages.

Preserve the Task Horizon During Migration

A replacement model may have:

• a larger native context;
• different reasoning levels;
• different tool behavior;
• different state-management infrastructure.

That does not automatically make a Max migration equivalent.

Create a regression set containing:

• project-scale refactors;
• tasks that crossed one 400K window;
• deep debugging;
• multi-hour loops;
• large test logs;
• repeated patch-and-repair cycles;
• code reviews;
• Windows workflows.

Preserve:

• repository revision;
• tool access;
• shell environment;
• validation commands;
• original instructions;
• expected final state.

Then compare:

• completion rate;
• context consumed;
• compaction or context-management events;
• reasoning tokens;
• tool calls;
• forgotten requirements;
• repeated work;
• latency;
• accepted-task cost.

Recalibrate reasoning from scratch.