GPT-5.1 Codex

A Coding Task Can Be Dozens of Decisions, Not One Completion

OpenAI launched GPT-5.1 Codex and GPT-5.1 Codex Mini specifically for longer-running agentic coding work.

A realistic repository task may require the model to:

• search for the relevant files;
• inspect existing architecture;
• understand project instructions;
• form an implementation plan;
• edit several files;
• run tests;
• inspect failures;
• repair the implementation;
• run validation again;
• stop only when the task is complete.

This means model quality cannot be measured from the first generated patch alone.

A strong result is a complete trajectory.

Useful evaluation metrics include:

• accepted patch rate;
• tests passed;
• number of files changed;
• unnecessary edits;
• repeated file reads;
• tool-call count;
• failed approaches;
• repair iterations;
• human intervention;
• total time and cost to completion.

GPT-5.1 Codex is therefore best understood as a repository agent model, not as a code-completion endpoint.

Reasoning Cost Should Be Measured Against Completed Work

For a coding agent, reasoning is not separate from execution.

The model may need to decide:

1. which files to inspect;
2. whether the issue is local or architectural;
3. which tool to call;
4. how much code to modify;
5. whether a test failure invalidates the approach;
6. when to stop.

OpenAI later used GPT-5.1 Codex as the baseline when introducing GPT-5.1 Codex Max.

That comparison is useful because it reveals the efficiency profile of the older model.

On SWE-bench Verified, OpenAI reported that Codex Max at medium reasoning effort achieved better performance than GPT-5.1 Codex at the same effort while using about 30% fewer thinking tokens.

The implication is important.

Reasoning-token count by itself is not a quality metric.

A migration should measure:

• reasoning tokens;
• accepted-result quality;
• tool calls;
• retries;
• elapsed time;
• final test status;
• total cost.

The least expensive model is the one that reaches the required engineering outcome efficiently—not necessarily the one that reasons least.

Large Enough for Serious Repository Work, but Still a Single Window

The 400K context limit matched the original GPT-5 Codex specification.

A coding session could use that space for:

• system and developer instructions;
• repository guidance;
• source files;
• test files;
• screenshots;
• conversation history;
• tool schemas;
• shell output;
• previous response items.

The important historical limitation is that GPT-5.1 Codex remained a single-context-window baseline.

Six days after its API release, OpenAI introduced GPT-5.1 Codex Max as the first Codex model natively trained to operate across multiple context windows using compaction.

That difference defines the two models.

GPT-5.1 Codex could work on long tasks inside a 400K window.

Codex Max was designed to continue beyond one window by compacting accumulated state and opening fresh context.

For migration benchmarks, include tasks that:

• fit comfortably inside 400K;
• approach the context ceiling;
• produce large test logs;
• require many iterative tool turns.

This reveals whether a newer model’s context management improves completion rather than merely providing a larger technical limit.

Agent State Was Part of the API Design

The official model page lists:

• Responses API: supported;
• streaming: supported;
• function calling: supported;
• structured outputs: supported;
• reasoning tokens: supported;
• image input: supported.

It lists Chat Completions and other non-Responses endpoints as unsupported for this model.

Fine-tuning and predicted outputs were also unsupported.

This API choice matters in migration.

A Codex-style integration can contain structured response items for:

• model messages;
• function calls;
• tool outputs;
• reasoning-related state;
• structured results.

Replacing GPT-5.1 Codex should ideally preserve this agent architecture first.

If the model, endpoint, tools, and state-management strategy all change at once, it becomes harder to isolate regressions.

Same Envelope, Newer Coding Generation

Both models used:

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

GPT-5 Codex established the GPT-5 coding-agent pattern.

GPT-5.1 Codex carried that pattern into the GPT-5.1 generation and was explicitly released for longer-running agentic coding tasks.

Because the technical envelope was so similar, a migration benchmark should emphasize behavior:

• persistence;
• tool discipline;
• repository navigation;
• repair quality;
• code completeness;
• test success;
• token efficiency.

This distinction also makes the pages SEO-separable.

GPT-5 Codex is the original specialized GPT-5 coding model.

GPT-5.1 Codex is the longer-running GPT-5.1 Codex baseline immediately before compaction changed the architecture with Codex Max.

Migrate the Engineering Outcome, Not Just the Model ID

Build a regression set from real historical tasks.

Include:

• small bug fixes;
• feature implementation;
• multi-file refactoring;
• failing-test repair;
• repository Q&A;
• frontend work with screenshots;
• long debugging sessions;
• tasks that approached the old 400K context limit.

Preserve:

• repository revision;
• system instructions;
• agent tools;
• patch mechanism;
• shell environment;
• tests;
• network restrictions;
• acceptance criteria.

Then change the model.

Measure:

• accepted patch rate;
• tests passed;
• reasoning tokens;
• context tokens;
• cache behavior;
• tool calls;
• failed approaches;
• elapsed time;
• total cost;
• human correction.

Newer OpenAI model families also changed reasoning and context-management behavior.

Do not assume a historical GPT-5.1 Codex effort configuration maps directly to a modern model.

Run a new reasoning-effort sweep.

Likewise, do not automatically expand the amount of repository context sent just because a newer model supports more.

Start from the old context strategy so the model difference is observable.