OpenAI retired professional coding model
GPT-5.2 Codex
OpenAI’s GPT-5.2 model optimized for long-horizon agentic software engineering, large refactors and migrations, reliable tool use, Windows development, visual coding workflows, native context compaction, and defensive cybersecurity.
- Context window
- 400K
- tokens
- Max output
- 128K
- tokens
- Input
- $1.75
- historical · per 1M
- Cached input
- $0.175
- historical · per 1M
- Output
- $14.00
- historical · per 1M
01 / Overview
What GPT-5.2 Codex Was
GPT-5.2 Codex was OpenAI’s coding-specialized GPT-5.2 model for complex, real-world software engineering and long-running agentic development.
Professional Software Engineering, Not Generic Code Completion
OpenAI announced GPT-5.2 Codex on December 18, 2025.
The model was a version of GPT-5.2 further optimized for agentic coding in Codex.
OpenAI positioned it around difficult engineering work such as:
- large refactors;
- code migrations;
- feature implementation;
- long-running debugging;
- realistic terminal work;
- Windows development;
- frontend implementation from visual references;
- defensive cybersecurity workflows.
The model built on two separate lines of progress.
From GPT-5.2 it inherited stronger professional knowledge work, factuality, long-context understanding, visual perception, and tool use.
From GPT-5.1 Codex Max it inherited the long-horizon coding architecture built around native compaction and sustained terminal interaction.
The result was a model intended to be a more dependable engineering partner across long sessions rather than simply a stronger code generator.
Its API specification included:
- 400,000-token context window;
- 128,000 maximum output tokens;
- August 31, 2025 knowledge cutoff;
- text input and output;
- image input;
- reasoning tokens;
low,medium,high, andxhighreasoning effort;- streaming;
- function calling;
- structured outputs;
- no fine-tuning;
- no predicted outputs.
OpenAI released gpt-5.2-codex to the Responses API on January 14, 2026.
The model is now retired from the API.
- Provider
- OpenAI
- Family
- GPT-5.2 Codex
- Model ID
- gpt-5.2-codex
- Announced
- Dec 18, 2025
- API release
- Jan 14, 2026
- Status
- Retired
- Knowledge cutoff
- Aug 31, 2025
- Input
- Text, Image
- Output
- Text
02 / Professional engineering
GPT-5.2 Codex Targeted Professional Software Engineering
The model’s defining positioning was complex real-world engineering: tasks where repository understanding, tools, terminal state, changing plans, and repeated validation matter as much as code-generation quality.
The Unit of Evaluation Is the Completed Engineering Task
A realistic coding agent may need to:
- inspect a repository;
- identify the relevant architecture;
- read project instructions;
- create a plan;
- modify several files;
- run tests or builds;
- inspect failures;
- revise the plan;
- repair the implementation;
- validate the final state.
OpenAI emphasized that GPT-5.2 Codex could keep working even when plans changed or earlier attempts failed.
That persistence matters because many production engineering tasks are not solved by the first plausible patch.
Representative workloads include:
- feature development;
- dependency migrations;
- framework upgrades;
- repository-wide API changes;
- multi-stage debugging;
- build-system repair;
- frontend implementation;
- security hardening;
- code review.
For model evaluation, measure the entire trajectory.
Useful metrics include:
- accepted patch rate;
- tests passed;
- files touched;
- unnecessary diffs;
- commands executed;
- tool failures;
- repair loops;
- reasoning tokens;
- elapsed time;
- human correction.
- 01
Understand
Inspect architecture, repository instructions, dependencies, and the actual implementation surface before changing code.
- 02
Implement
Make coordinated changes that preserve project conventions and surrounding behavior.
- 03
Validate
Use tests, builds, terminal output, screenshots, and other tools as evidence rather than assuming the first patch is correct.
- 04
Recover
Change course when a plan fails while preserving the original objective and useful evidence already collected.
03 / Compaction
Native Compaction Supported Long-Running Coding Sessions
GPT-5.2 Codex continued the multi-context architecture introduced by GPT-5.1 Codex Max, using native compaction to sustain work beyond one active context window.
A 400K Context Window Was Not the Same as a 400K Task Horizon
The model’s native context window was 400,000 tokens.
But a long coding session can accumulate much more than that through:
- source files;
- repository instructions;
- tool definitions;
- shell output;
- test failures;
- patches;
- reasoning state;
- previous decisions.
Compaction reduces older history while preserving the state needed to continue.
A fresh active context can then carry the task forward.
This makes two measurements important:
Native context
How much the model can consider in one active window.
Task horizon
How much information and work the agent can process coherently over the entire trajectory.
OpenAI specifically cited improved long-horizon work through context compaction as a core GPT-5.2 Codex improvement.
The useful evaluation question is not merely how many tokens can fit.
Measure whether the model preserves:
- requirements;
- architecture decisions;
- failed approaches;
- completed changes;
- unresolved work;
- repository constraints.
- 01
Accumulate
Repository content, tools, command output, patches, and reasoning grow during a long engineering task.
- 02
Compact
Reduce older state while retaining the decisions, constraints, and evidence needed to continue.
- 03
Resume
Continue in a refreshed working context without treating the task as a new session.
- 04
Validate memory
Check whether long-horizon execution preserves requirements and avoids repeating or undoing completed work.
04 / Refactors & migrations
Large Refactors and Migrations Were a Core GPT-5.2 Codex Target
OpenAI explicitly highlighted stronger performance on project-scale code changes such as refactoring and migration work.
Large Changes Test Coordination, Not Just Syntax
A repository-wide migration can require the model to update:
- public APIs;
- internal abstractions;
- callers;
- tests;
- build configuration;
- documentation;
- dependency versions;
- generated types.
The challenge is preserving consistency across all of those surfaces.
A model can produce individually valid edits and still fail the project if one dependency path is missed.
That is why large-change evaluation should track:
- files that should change;
- files that changed unexpectedly;
- compile errors;
- failing tests;
- incomplete call-site migrations;
- stale configuration;
- incompatible assumptions.
GPT-5.2 Codex was intended to sustain this coordination over long sessions.
Useful historical regression cases include:
- framework migrations;
- SDK upgrades;
- type-system migrations;
- repository reorganizations;
- API version changes;
- database-layer refactors.
- 01
Map dependencies
Identify callers, tests, generated artifacts, configuration, and other surfaces affected by the change.
- 02
Change coherently
Apply a consistent migration strategy rather than producing unrelated local fixes.
- 03
Validate broadly
Use project-wide tests, type checking, builds, and search to detect incomplete migration work.
- 04
Repair residual failures
Continue iterating until the repository satisfies the new contract instead of stopping after the main edit.
05 / Windows
GPT-5.2 Codex Improved Agentic Coding on Windows
OpenAI highlighted substantially more effective and reliable agentic coding in native Windows environments, building on Windows support introduced with GPT-5.1 Codex Max.
Platform Semantics Affect Coding-Agent Reliability
A coding agent operating on Windows may encounter:
- drive letters;
- backslash paths;
- PowerShell;
- Windows command syntax;
- platform-specific environment variables;
- different process behavior;
- filesystem semantics;
- Windows-native build tooling.
A model trained mostly around Unix assumptions can create subtle failures even when the source-code change is correct.
GPT-5.2 Codex therefore extended the Codex line’s environment coverage rather than treating Windows as a thin compatibility layer.
Historical migration testing should retain Windows-specific tasks if the original workload used them.
Test:
- path handling;
- shell commands;
- package scripts;
- build tools;
- environment setup;
- process management;
- repository tests.
- 01
Filesystem
Respect Windows paths, drives, quoting, and platform-specific file behavior.
- 02
Shell
Use PowerShell or the configured Windows command environment correctly.
- 03
Toolchain
Work with Windows-native build, package, process, and development tooling.
- 04
Validate on platform
Run the actual Windows workflow rather than assuming a patch validated on another operating system is equivalent.
06 / Vision
Stronger Vision Expanded Frontend and Debugging Workflows
OpenAI highlighted improved interpretation of screenshots, technical diagrams, charts, and interface surfaces shared during coding sessions.
Visual Evidence Can Become Part of the Engineering Loop
A frontend task is often difficult to specify completely in text.
A developer may provide:
- a design mockup;
- a screenshot;
- a broken UI state;
- a chart;
- a technical diagram;
- a browser error view.
GPT-5.2 Codex could use that visual evidence alongside repository context.
OpenAI specifically described a workflow where Codex takes a design mockup, turns it into a functional prototype, and then iterates toward production quality.
That suggests evaluation cases such as:
- screenshot-to-implementation;
- layout repair;
- responsive UI debugging;
- chart reproduction;
- diagram-guided implementation;
- visual regression repair.
Measure both functional and visual correctness.
A patch can pass tests and still fail to match the intended interface.
- 01
Observe
Use screenshots, mockups, diagrams, or interface state as evidence alongside source code.
- 02
Implement
Translate visual requirements into components, styles, assets, and behavior.
- 03
Compare
Inspect the rendered result rather than evaluating frontend work only from source code.
- 04
Iterate
Use visual differences as feedback for the next coding turn.
07 / Cybersecurity
Cybersecurity Was a Major GPT-5.2 Codex Differentiator
OpenAI described GPT-5.2 Codex as significantly stronger in cybersecurity and positioned the release around professional software engineering and defensive cyber work.
Stronger Security Capability Came With Additional Safeguards
The GPT-5.2 Codex system-card addendum describes improvements in cybersecurity while also documenting specialized safety training, sandboxing, monitoring, and configurable network access.
OpenAI evaluated the model under its Preparedness Framework.
The company described GPT-5.2 Codex as very capable in cybersecurity but below its threshold for High cybersecurity capability.
For legitimate defensive engineering, useful evaluation categories include:
- vulnerability triage;
- secure code review;
- patch validation;
- dependency-risk investigation;
- defensive testing;
- security-oriented repository analysis;
- incident-response support in controlled environments.
Long-horizon context management mattered here as well.
Security investigations can require many commands, evidence collection steps, and hypothesis changes.
OpenAI attributed part of GPT-5.2 Codex’s cyber progress to compaction and the ability to continue coherently across extended tasks.
- 01
Review
Inspect code and configuration for security-relevant defects in authorized defensive workflows.
- 02
Investigate
Correlate logs, repository state, dependencies, and controlled test evidence across a longer analysis.
- 03
Repair
Generate defensive patches and validate that the intended security property is restored.
- 04
Operate with safeguards
Keep sandboxing, network restrictions, authorization boundaries, and human review as part of the engineering environment.
08 / Reasoning
Low, Medium, High, and xhigh Reasoning
GPT-5.2 Codex supported four documented reasoning-effort levels: low, medium, high, and xhigh.
Use Deeper Reasoning Only When It Improves the Engineering Outcome
A coding workload can vary from a tiny targeted fix to a repository-wide migration.
The same reasoning setting is not necessarily optimal for both.
Lower effort can be useful when:
- the task is narrow;
- acceptance criteria are explicit;
- validation is cheap;
- latency matters.
Higher effort can be useful when:
- architecture is ambiguous;
- debugging spans several systems;
- the task requires a large migration;
- failure is expensive;
- the agent must preserve a long chain of decisions.
The later OpenAI benchmark appendix reports GPT-5.2 Codex results using xhigh, so those numbers should not be interpreted as the cost or latency of a default everyday configuration.
For real product evaluation, perform an effort sweep.
Measure:
- successful completion;
- reasoning tokens;
- tool calls;
- retries;
- elapsed time;
- total cost.
Routine repository work
Start with medium or lower when the change is well specified and automated validation provides a strong feedback loop.
Hard professional engineering
Test high or xhigh for complex migrations, long debugging trajectories, or difficult security and terminal tasks where additional reasoning materially improves completion.
09 / Benchmarks
GPT-5.2 Codex Benchmark Results
OpenAI’s later GPT-5.3 Codex launch appendix provides a useful retrospective benchmark snapshot for GPT-5.2 Codex at xhigh reasoning.
Agentic Coding, Terminal Work, Computer Use, and Security
The published comparison lists GPT-5.2 Codex at:
- 56.4% on SWE-Bench Pro Public;
- 64.0% on Terminal-Bench 2.0;
- 38.2% on OSWorld-Verified;
- 67.4% on Cybersecurity Capture The Flag challenges;
- 76.0% on SWE-Lancer IC Diamond.
These results describe different aspects of agent behavior.
SWE-Bench Pro
Repository-level software-engineering problem solving.
Terminal-Bench 2.0
Realistic terminal environments involving tasks such as compiling code, configuring systems, and interacting with development infrastructure.
OSWorld-Verified
Broader computer interaction rather than source-code work alone.
Cybersecurity CTF
Controlled cybersecurity challenge performance.
SWE-Lancer IC Diamond
Difficult independent-contributor software-engineering tasks.
Benchmarks are useful for historical positioning, but migration decisions should still use your own repositories and acceptance criteria.
- 56.4%
SWE-Bench Pro Public
OpenAI retrospective result for GPT-5.2 Codex at xhigh.
- 64.0%
Terminal-Bench 2.0
Measures agent performance in realistic terminal environments.
- 38.2%
OSWorld-Verified
Measures broader computer-interaction capability.
- 76.0%
SWE-Lancer IC Diamond
Published result on difficult professional software-engineering tasks.
10 / Pricing
GPT-5.2 Codex Pricing
GPT-5.2 Codex cost $1.75 per million input tokens, $0.175 per million cached input tokens, and $14 per million output tokens.
Higher Token Price Than the GPT-5.1 Codex Generation
GPT-5.1 Codex and Codex Max used $1.25 / $0.125 / $10 headline rates.
GPT-5.2 Codex increased those rates to:
- input: $1.75 per 1M tokens;
- cached input: $0.175 per 1M tokens;
- output: $14.00 per 1M tokens.
That is a 40% increase in each headline text-token category.
OpenAI positioned GPT-5.2 as a more capable generation and priced it accordingly.
For a coding agent, however, token price is not the complete cost.
A more capable model can still reduce total engineering cost if it:
- completes more tasks;
- uses fewer repair loops;
- calls tools more reliably;
- preserves context better;
- requires less human correction.
Measure cost per accepted engineering task, not just cost per million tokens.
1M tokens · USD
- Input
- $1.75
- Cached input
- $0.175
- Output
- $14.00
Example: 100K input + 10K output
- Input cost
- $0.1750
- Output cost
- $0.1400
- Estimated token cost
- $0.3150
11 / Context
400K Context and 128K Maximum Output
GPT-5.2 Codex retained the 400,000-token context window and 128,000-token output ceiling used by the earlier GPT-5 Codex generation while improving long-context understanding and context management.
Same Native Size, Better Long-Horizon Behavior
The important change was not a larger context number.
GPT-5.2 Codex improved:
- long-context understanding;
- native compaction;
- factuality;
- reliable tool calling;
- reasoning efficiency.
That distinction matters.
Two models with the same maximum context can behave very differently when:
- a repository is large;
- instructions compete with code;
- tool logs accumulate;
- earlier decisions must remain available;
- the session crosses context boundaries.
A 400K native window also means context selection still matters.
Search for relevant code first.
Avoid loading entire repositories when a narrow slice is sufficient.
Keep stable instructions clear.
Measure context consumed across the entire trajectory.
Context window
400,000
Max output
128,000
GPT-5.2 Codex retained a 400K native window, while native compaction allowed Codex workflows to continue across longer task horizons.
12 / API
GPT-5.2 Codex Reached the Responses API in January 2026
OpenAI announced GPT-5.2 Codex in December 2025 and released gpt-5.2-codex to the Responses API on January 14, 2026.
The model supported the application features expected from a modern coding agent:
- reasoning tokens;
- streaming;
- function calling;
- structured outputs;
- text input and output;
- image input.
Fine-tuning and predicted outputs were not supported.
The Responses API is especially relevant to agentic coding because it can preserve structured interaction state across:
- model messages;
- tool calls;
- tool outputs;
- reasoning-related items;
- structured results.
OpenAI later optimized the inference stack for GPT-5.2 and GPT-5.2 Codex, reporting roughly 40% faster execution without changing model weights.
For historical comparisons, distinguish model capability from infrastructure improvements.
A latency measurement from early January 2026 may not match one collected after the February inference optimization.
- Supported
Responses API
OpenAI released gpt-5.2-codex to the Responses API on January 14, 2026.
- Supported
Streaming
Receive model output progressively during interactive and long-running coding work.
- Supported
Function calling
Connect model decisions to repository, terminal, test, and application-defined tools.
- Supported
Structured outputs
Return schema-constrained machine-readable output for agent harnesses.
- Supported
Image input
Use screenshots, diagrams, charts, and UI surfaces as part of software-engineering context.
- Not listed
Fine-tuning
The official model page lists fine-tuning as unsupported.
13 / 5.2 vs 5.1 Max
GPT-5.2 Codex vs GPT-5.1 Codex Max
GPT-5.1 Codex Max introduced the multi-context Codex architecture; GPT-5.2 Codex built on it with stronger professional engineering, long-context understanding, tool reliability, Windows behavior, vision, factuality, and cybersecurity.
What Stayed Similar
Both models used:
- 400K native context;
- 128K maximum output;
- native compaction;
- long-horizon agentic coding;
- image input;
- reasoning tokens;
- Responses-oriented Codex workflows.
What GPT-5.2 Codex Added or Improved
OpenAI highlighted:
- stronger project-scale refactors;
- stronger migrations;
- better long-context understanding;
- more reliable tool calling;
- improved factuality;
- better Windows agentic coding;
- stronger visual perception;
- significantly stronger cybersecurity capabilities.
Pricing also increased.
GPT-5.1 Codex Max:
- $1.25 input per 1M tokens;
- $0.125 cached input per 1M tokens;
- $10 output per 1M tokens.
GPT-5.2 Codex:
- $1.75 input per 1M tokens;
- $0.175 cached input per 1M tokens;
- $14 output per 1M tokens.
That is a 40% increase across the three headline text-token rates.
The tradeoff was a stronger professional-engineering model with better real-world software work, visual understanding, Windows behavior, tool reliability, long-context handling, and cybersecurity capability.
For migration evaluation, preserve both generations in the regression history.
The useful question is not whether GPT-5.2 Codex was universally better.
Measure whether its higher token price reduced retries, human correction, failed migrations, and incomplete engineering tasks enough to lower cost per accepted result.
- 01
Same native context envelope
Both generations exposed 400K context, 128K maximum output, native compaction, image input, reasoning tokens, and Responses-oriented agent workflows.
- 02
Stronger project-scale engineering
GPT-5.2 Codex emphasized large refactors, migrations, factuality, tool reliability, and long-context understanding.
- 03
Broader environment understanding
OpenAI highlighted more reliable Windows development and stronger interpretation of screenshots, diagrams, charts, and interface surfaces.
- 04
Higher price for the newer generation
GPT-5.2 Codex increased the headline input, cached-input, and output rates by 40% compared with GPT-5.1 Codex Max.
14 / Retirement
GPT-5.2 Codex Is Retired From the OpenAI API
OpenAI deprecated GPT-5.2 Codex in April 2026 and shut down API access on July 23, 2026.
The Professional Codex Generation Is Now Historical
The lifecycle was:
- announcement: December 18, 2025;
- Responses API release: January 14, 2026;
- deprecation announcement: April 22, 2026;
- API shutdown: July 23, 2026;
- substitute:
gpt-5.6-sol.
The shutdown date has passed.
Operationally, gpt-5.2-codex is a retired API model.
Its remaining value is as a historical reference for:
- professional software-engineering behavior;
- native compaction;
- long-horizon agent loops;
- project-scale refactors;
- migration workloads;
- Windows development;
- visual coding;
- defensive cybersecurity;
- reasoning-effort comparisons;
- benchmark baselines;
- historical cost analysis.
Do not start a new production integration with GPT-5.2 Codex.
Keep old traces, prompts, repository revisions, tool configurations, and accepted outcomes if you need to validate a replacement model.
- 01
Announced · Dec 18, 2025
OpenAI introduced GPT-5.2 Codex as a GPT-5.2 model optimized for professional agentic software engineering.
- 02
Responses API · Jan 14, 2026
OpenAI released gpt-5.2-codex to API developers through the Responses API.
- 03
Deprecated · Apr 22, 2026
OpenAI announced retirement of older GPT and Codex model variants.
- 04
Shut down · Jul 23, 2026
API access ended. OpenAI’s deprecation table names GPT-5.6 Sol as the substitute.
15 / Migration
Migrating From GPT-5.2 Codex to GPT-5.6 Sol
OpenAI’s deprecation table names GPT-5.6 Sol as the substitute for GPT-5.2 Codex, but a safe migration should replay the professional software-engineering workloads that made the Codex model distinctive.
Preserve the Engineering Workload, Not Just the Prompt Text
Start with historical GPT-5.2 Codex tasks that exercise the model’s defining behavior.
Include:
- large repository refactors;
- framework and dependency migrations;
- long-running debugging;
- Windows-native workflows;
- screenshot-to-frontend tasks;
- visual regression repair;
- long terminal sessions;
- tool-heavy agent loops;
- defensive security review;
- tasks that depended on compaction;
- difficult
highorxhighreasoning cases.
Preserve the original:
- repository revision;
- issue or user request;
- system and developer instructions;
- tool definitions;
- shell environment;
- platform;
- screenshots or diagrams;
- tests and validation commands;
- expected final state.
Then replay the workload with GPT-5.6 Sol.
Compare:
- accepted completion rate;
- correctness;
- files changed;
- unnecessary diffs;
- tests passed;
- tool failures;
- repair loops;
- reasoning tokens;
- context consumption;
- latency;
- total cost;
- human correction.
Do not copy the old reasoning setting automatically.
A newer model can have different reasoning controls, a different context envelope, and different tool behavior.
Recalibrate the configuration around completed-task quality and economics.
For long-horizon tasks, also check whether the replacement preserves requirements and completed work as context grows.
For visual and Windows cases, keep the original environment because removing those dimensions can hide regressions.
- 01
Freeze the historical baseline
Preserve repositories, prompts, screenshots, Windows cases, security tasks, tools, tests, and accepted GPT-5.2 Codex outcomes.
- 02
Keep the harness stable
Hold environment, tool access, validation commands, and acceptance criteria constant during the first replacement comparison.
- 03
Recalibrate reasoning and context
Evaluate the replacement model’s reasoning controls and context behavior empirically instead of copying GPT-5.2 Codex settings.
- 04
Measure accepted-task economics
Compare successful completion, tool reliability, context use, latency, retries, human correction, and total cost rather than token price alone.
16 / Evaluation
GPT-5.2 Codex Strengths and Limitations
GPT-5.2 Codex is historically useful as OpenAI’s professional Codex generation for long-horizon software engineering, but its API retirement means its practical role today is evaluation, regression testing, and migration reference.
Historical strengths
Professional software-engineering focus
OpenAI optimized GPT-5.2 Codex for real repository work including large refactors, migrations, debugging, tool use, and long-running implementation.
Native long-horizon context management
The model continued the Codex compaction architecture so one engineering task could preserve progress across extended agent trajectories.
Stronger Windows and visual workflows
OpenAI highlighted improved native Windows coding and stronger interpretation of screenshots, diagrams, charts, and interface surfaces.
Defensive cybersecurity capability
GPT-5.2 Codex received specialized cybersecurity improvements and was positioned for legitimate defensive software-engineering workflows.
What to consider
API access has ended
OpenAI shut down gpt-5.2-codex on July 23, 2026 and names gpt-5.6-sol as the substitute.
Historical pricing no longer applies
The $1.75 input, $0.175 cached-input, and $14 output rates are useful only for historical cost analysis.
Long agent trajectories can consume substantial resources
Compaction extends task horizons, but repeated tools, reasoning, logs, retries, and generated output can still make difficult engineering tasks expensive.
Benchmark scores are configuration-dependent
Published retrospective results used xhigh reasoning, so they should not be treated as the latency or cost profile of an everyday production configuration.
Preserve the GPT-5.2 Codex baseline
Replay professional software-engineering tasks with a supported model
Use real refactors, migrations, Windows repositories, frontend screenshots, terminal tasks, long-running tool loops, and defensive security cases to compare completion quality, reasoning efficiency, tool reliability, context management, latency, and total cost.
Start FreeGPT-5.2 Codex is retired from the OpenAI API. OpenAI’s deprecation table names GPT-5.6 Sol as the substitute.
Common Questions
What was GPT-5.2 Codex?
GPT-5.2 Codex was OpenAI’s coding-specialized GPT-5.2 model for professional, long-horizon agentic software engineering.
What was the GPT-5.2 Codex model ID?
The API model ID was gpt-5.2-codex.
When was GPT-5.2 Codex announced?
OpenAI announced GPT-5.2 Codex on December 18, 2025.
When did GPT-5.2 Codex reach the API?
OpenAI released gpt-5.2-codex to the Responses API on January 14, 2026.
Is GPT-5.2 Codex deprecated?
Yes. OpenAI deprecated the model in April 2026 and shut down API access on July 23, 2026.
Can I still call GPT-5.2 Codex through the API?
No. The July 23, 2026 API shutdown date has passed.
What model replaces GPT-5.2 Codex?
OpenAI’s API deprecation documentation names gpt-5.6-sol as the substitute.
What was the GPT-5.2 Codex context window?
The official model specification listed a 400,000-token context window.
What was the maximum output for GPT-5.2 Codex?
The official model specification listed a maximum output of 128,000 tokens.
What was the GPT-5.2 Codex knowledge cutoff?
OpenAI listed August 31, 2025 as the knowledge cutoff.
What input and output modalities did GPT-5.2 Codex support?
GPT-5.2 Codex supported text and image input and generated text output.
How much did GPT-5.2 Codex cost?
Historical pricing was $1.75 per 1M input tokens, $0.175 per 1M cached input tokens, and $14 per 1M output tokens.
Did GPT-5.2 Codex support reasoning tokens?
Yes. The official model page listed reasoning-token support.
What reasoning levels did GPT-5.2 Codex support?
GPT-5.2 Codex supported low, medium, high, and xhigh reasoning effort.
Did GPT-5.2 Codex support native compaction?
Yes. GPT-5.2 Codex continued the Codex multi-context architecture, using compaction to preserve important task state across long engineering trajectories.
Was GPT-5.2 Codex designed for large refactors and migrations?
Yes. OpenAI explicitly highlighted stronger project-scale refactoring and migration work as a core target for the model.
Was GPT-5.2 Codex improved for Windows development?
Yes. OpenAI highlighted substantially more effective and reliable agentic coding in native Windows environments.
Could GPT-5.2 Codex use screenshots and other images for coding?
Yes. The model accepted image input, and OpenAI highlighted stronger interpretation of screenshots, technical diagrams, charts, and interface surfaces.
Was GPT-5.2 Codex a cybersecurity model?
It was a professional coding model with significantly improved cybersecurity capability and specialized safeguards. OpenAI positioned legitimate defensive cybersecurity as an important use case.
How did GPT-5.2 Codex perform on published benchmarks?
OpenAI’s later retrospective xhigh table reported 56.4% on SWE-Bench Pro Public, 64.0% on Terminal-Bench 2.0, 38.2% on OSWorld-Verified, 67.4% on cybersecurity Capture The Flag challenges, and 76.0% on SWE-Lancer IC Diamond.
Which API supported GPT-5.2 Codex?
OpenAI exposed GPT-5.2 Codex through the Responses API with streaming, function calling, structured outputs, reasoning tokens, text input and output, and image input.
Did GPT-5.2 Codex support fine-tuning?
No. OpenAI listed fine-tuning as unsupported.
What is the difference between GPT-5.2 Codex and GPT-5.1 Codex Max?
Both used 400K native context, 128K maximum output, native compaction, image input, and long-horizon Codex workflows. GPT-5.2 Codex added stronger professional engineering, long-context understanding, tool reliability, Windows behavior, vision, factuality, and cybersecurity, while increasing headline text-token rates by 40%.
How should teams migrate from GPT-5.2 Codex?
Preserve representative repositories, prompts, tools, tests, Windows workflows, visual inputs, long-running agent tasks, and accepted outcomes, then replay them with GPT-5.6 Sol or another supported model and compare completion quality, reasoning, context management, tool use, latency, and total cost.
Should I use GPT-5.2 Codex for a new application?
No. API access has ended. Use GPT-5.6 Sol or another supported model and keep GPT-5.2 Codex only as a historical engineering, benchmark, pricing, regression, and migration reference.
Model information
Last updated
Specifications, pricing, context limits, modalities, reasoning levels, API release timing, native compaction, long-horizon coding behavior, Windows and vision improvements, defensive cybersecurity positioning, benchmark results, lifecycle status, and migration guidance are based on OpenAI’s official GPT-5.2 Codex model page, launch announcement, API changelog, GPT-5.2 Codex system-card addendum, later GPT-5.3 Codex benchmark appendix, and API deprecations documentation.