OpenAI o3 and o4-mini Explained: The Reasoning-Model Lineage (2026)

OpenAI o3 and o4-mini are OpenAI’s dedicated reasoning-specialist models, released April 16,
2025, with a higher-compute sibling, o3-pro, following in June 2025. Built by OpenAI as
purpose-trained “thinking” models rather than general chat assistants, o3 and o4-mini generate long
hidden chains of reasoning before answering and can interleave that reasoning with tool calls — Python
execution, web browsing, image analysis — inside a single turn. Why they still matter in August 2026:
they were the models that proved reasoning-plus-tools was the path to state-of-the-art math and coding
performance, and o4-mini in particular remains one of the cheapest ways to buy frontier-grade reasoning
accuracy per dollar, even as OpenAI’s flagship line has moved on to GPT-5.6.

This is not a “here’s OpenAI’s best model” post. As of today, o3 and o4-mini are legacy specialists
sitting behind GPT-5.6 in OpenAI’s lineup, and one of them is being retired from ChatGPT in the next
two weeks. This piece is about where that leaves them, what they’re actually good for, and whether
you should still be calling them from your API code in late 2026.

What this covers: lineage and what changed from o1/o3-mini; architecture and reasoning-token
mechanics; training (SFT + RLVR); real benchmark numbers with sourcing caveats; current API pricing and
the ChatGPT retirement timeline; failure modes; and a decision matrix against GPT-5.6, Claude Opus 5,
and DeepSeek-R reasoning models.

Lineage and Context

OpenAI’s reasoning line began with o1 in September 2024, the first shipped model to use
reinforcement-learning-trained chain-of-thought at inference time rather than just next-token
prediction over a static prompt. o1 proved the idea — spend more test-time compute generating hidden
reasoning tokens, and accuracy on hard math, science, and coding problems climbs — but it shipped
without tool access and at a steep price. o3-mini followed in January 2025 as a cheaper, faster,
coding-focused variant aimed at developers who wanted o1-style reasoning without o1’s cost.

o3 and o4-mini, announced together on April 16, 2025, were the generation that closed the gap between
“reasoning model” and “agent.” For the first time, OpenAI gave its reasoning models full tool access
inside a single reasoning chain: the model can decide mid-thought to run Python, search the web, or
inspect an image, fold the result back into its reasoning, and keep going — instead of reasoning once,
stopping, and waiting for a separate tool-call round trip. OpenAI described this as agentic tool use
baked into the reasoning process itself, and it’s the single biggest architectural change from o1/o3-mini
to o3/o4-mini.

o3-pro arrived roughly two months later, in June 2025, as a higher-compute variant of o3 built for
users who wanted “think even longer, get even more reliable answers” at the cost of both latency and
price. It replaced o1-pro as OpenAI’s top-of-line reasoning tier.

The naming itself tells you how OpenAI was positioning these models at the time: “o4-mini” signaled a
smaller, cheaper sibling in a numbered generation, the same pattern as o3-mini before it, while “o3”
and “o3-pro” were the full-size and high-compute members of that same generation. This is different
from how GPT-5.6 is versioned today, where Sol/Terra/Luna are capability tiers within one release rather
than a numbered lineage of separate models — a structural shift that matters more than it might first
appear, because it changes how “upgrading” works for a team building on these APIs. With o-series, you
migrated to a new number (o1 to o3, o3-mini to o4-mini). With GPT-5.6, you adjust a parameter on the
same model family. Codex CLI, OpenAI’s terminal coding agent, launched alongside o3/o4-mini specifically
to showcase this generation’s tool-integrated reasoning in a developer workflow, and it’s worth noting
as a marker of how central “agentic coding” was to this release’s positioning — a positioning that GPT-5.6
and its competitors have since made the default expectation for any frontier-adjacent model, reasoning
or not.

What changed since: OpenAI cut o3’s list price by 80% on June 10, 2025 (from $10/$40 to $2/$8 per
million input/output tokens), citing inference-stack optimizations rather than a new model. Then, in
2026, OpenAI’s product strategy shifted decisively: rather than continuing to ship new numbered o-series
models, reasoning became a mode — a reasoning_effort parameter (none, low, medium, high,
xhigh, max) — inside the unified GPT-5.6 family (Sol/Terra/Luna tiers) that launched July 9, 2026.
There is no “o5.” The o-series brand, as a standalone family, effectively stopped at o3/o3-pro/o4-mini.
If you’ve read this site’s coverage of reasoning-effort controls and thinking budgets,
this is the production version of exactly that idea — o3/o4-mini were the transitional generation that
made the case for it.

Architecture

OpenAI has not disclosed parameter counts, layer depth, or exact architecture family (dense vs
mixture-of-experts) for o3, o4-mini, or o3-pro. That’s consistent with the entire o-series and the GPT-5
line — OpenAI treats these details as competitive information and has published no technical report
with model size for any model since GPT-4. Any parameter-count number you see for o3 or o4-mini
circulating online is a third-party estimate, not an OpenAI disclosure, and this piece will not
repeat one as fact.

What is documented: both models are decoder-only transformer language models trained specifically to
produce an internal chain of reasoning tokens before emitting a final, user-visible answer. That
reasoning happens inside a special channel — OpenAI calls it the “reasoning” or “thinking” phase — that
is not shown to the user by default in the API (only a summary is, depending on endpoint), but is
counted and billed as output tokens. This is the load-bearing architectural fact for anyone budgeting
API costs: a “short” user-visible answer from o3 or o4-mini can still generate thousands of hidden
reasoning tokens under the hood, and you pay output-token rates for every one of them.

Context window is 200,000 tokens for both o3 and o4-mini, smaller than GPT-5.6’s context tiers, and
maximum output (including reasoning tokens) is capped at 100,000 tokens per response for the standard
o3/o4-mini API endpoints, with o3-pro sharing the same 200K input ceiling. That combination — a
200K window with a 100K output/reasoning cap — means o3 and o4-mini are not the right choice for
long-document, whole-repository, or extended-agentic-loop workloads where you need either a much larger
context or a model that reasons more cheaply per token; that’s squarely GPT-5.6 territory today.

Modalities: both models accept text and image input (o3 in particular was marketed around “thinking
with images” — it can rotate, crop, and reason step-by-step about a diagram or photo rather than just
captioning it). Neither is a native audio or video model; multimodal input in the API is text + image
only, with tool results (search snippets, code execution output, generated images) folded back into the
same reasoning context.

Tokenizer and vocabulary details were not published separately from the broader GPT-4o-generation
tokenizer family OpenAI was using at the time of release; there is no confirmed, sourced vocabulary size
specific to o3/o4-mini as of this writing, so none is stated here.

Reasoning effort is exposed to developers as a first-class API parameter (reasoning_effort, typically
low, medium, or high on the standard o3/o4-mini endpoints), and this is the single most important
lever for both cost and latency management. Setting high on a simple factual question wastes tokens
and time generating reasoning the task never needed; setting low on a genuinely hard multi-step proof
or debugging task will often return a worse answer than a properly-scoped high call. In production,
teams typically route by task type — classification and lookup-style queries at low, agentic coding
and math at high — rather than using a single fixed setting across an entire application. This same
pattern, generalized and renamed, is exactly what became the reasoning_effort parameter on GPT-5.6.

The “mini” distinction between o3 and o4-mini is a capability/cost trade-off, not a stripped-down feature
set — o4-mini retains full tool access, image input, and the same 200K context window as o3, and on
several published benchmarks (AIME 2025 without tools, most notably) it outscores the larger o3. OpenAI
has not disclosed why o4-mini outperforms o3 on some evaluations; the most defensible read, consistent
with OpenAI’s own “cost-performance frontier” framing at launch, is that o4-mini benefited from a later,
more refined training pass in the same generation rather than being a strictly smaller model with
strictly lower ability across the board.

The distinguishing architectural feature versus o1/o3-mini is the tool-integrated reasoning loop
described above (see fig1): a request enters, a router or the developer sets a reasoning-effort level,
the model reasons, optionally calls a tool mid-chain and folds the result back in, reasons further, and
only then emits the final answer. o3-pro applies the same architecture with a substantially higher
compute allocation per request, which is why it costs roughly 10x o3’s per-token rate and is
noticeably slower — OpenAI has described it as intentionally trading latency for reliability on the
hardest problems, not as a bigger model in a disclosed sense.

Training

OpenAI has disclosed relatively little about pre-training data scale or raw compute for o3/o4-mini
specifically; treat any specific token-count or FLOP figure you encounter elsewhere as an unverified
estimate. What OpenAI has stated, consistently across the o-series announcements, is the training
recipe shape: a pre-trained base model (from the same general GPT-4-class pre-training pipeline family
used across OpenAI’s 2024-2025 models) is followed by a reasoning-specific post-training stage built
on large-scale reinforcement learning.

The key post-training claim OpenAI made at launch is that o3’s and o4-mini’s RL training was scaled up
substantially relative to o1 — “the more they think, the better they do,” and more RL compute during
training itself, not just more inference-time thinking, drove the accuracy gains. This is reinforcement
learning with verifiable rewards (RLVR): for domains like math and competitive programming where an
answer can be automatically checked against a ground truth or a test suite, the model is rewarded
directly for chains of reasoning that arrive at correct, verifiable outputs, rather than relying purely
on human preference labels (RLHF) or a reward model trained to imitate human judgment.

Tool-use training is layered on top of that: o3 and o4-mini were specifically trained (per OpenAI’s
announcement) to learn not just “reasoning” but “when and how to use tools” — deciding, inside the RL
loop, whether a given step benefits from calling Python, running a web search, or manipulating an image,
rather than tool use being bolted on as a separate fine-tuning pass. OpenAI frames this as full agentic
tool use trained end-to-end with the reasoning objective, which is what let both models use tools “in
sequence and combination” to reach answers, per their launch materials.

Standard supervised fine-tuning (SFT) on curated reasoning traces and instruction-following data
almost certainly precedes the RL stage, consistent with OpenAI’s general post-training pipeline
disclosed for prior models, though OpenAI has not published an exact SFT dataset description for o3/
o4-mini specifically — that detail should be read as “reported/typical for this pipeline,” not
officially itemized. A safety and refusal-tuning pass follows, aligning outputs with OpenAI’s usage
policies before release; OpenAI’s o3/o4-mini system card describes additional safety testing given the
models’ expanded tool access and agentic capability, since a reasoning model that can browse the live
web and execute code has a meaningfully larger attack surface than a text-only chat model.

o3-pro’s training is described by OpenAI as the same underlying o3 model configured to allocate
substantially more compute per response at inference time, rather than a separately trained larger
model — this is an inference-time scaling difference layered on the same trained weights and RL
recipe, not a distinct pre-training run in any way OpenAI has disclosed.

OpenAI’s system card for o3/o4-mini also describes a “deliberative alignment” approach used in training
— the model is taught to explicitly reason about OpenAI’s safety policies as part of its chain of
thought before answering borderline or sensitive requests, rather than relying purely on a separate
refusal classifier bolted on after generation. This matters for the training story specifically because
it means safety behavior is trained into the same RL loop that produces math and coding accuracy, not
grafted on afterward — a design choice OpenAI carried forward into subsequent model generations. Red-teaming
for the expanded tool-use surface (an agent that can browse the live web and execute arbitrary Python is
a meaningfully different risk profile than a text-only chatbot) is called out explicitly in that same
system card as a focus area unique to this generation, reflecting the fact that o3/o4-mini were the
first OpenAI reasoning models where “the model does things in the world,” not just “the model answers
questions,” was a first-class design consideration during training.

Capabilities and Benchmarks

The headline numbers OpenAI published at launch (April 2025), reasoning effort set high, no tools
unless noted:

AIME 2025 (American Invitational Mathematics Examination, no tools): o4-mini scored 92.7%;
o3 scored 88.9%. With access to a Python interpreter, o4-mini’s AIME 2025 pass@1 rose to
99.5%, with consensus@8 (majority vote across 8 samples) reaching 100% — a strong result, but
one that reflects a model with code-execution access checking its own arithmetic, not pure
chain-of-thought math reasoning, so the two numbers aren’t directly comparable.
GPQA Diamond (graduate-level science questions, no tools): o3 scored 83.3%.
SWE-bench Verified (real-world GitHub issue resolution, 477-task fixed subset, high reasoning
effort): o4-mini scored 68.1%, ahead of its predecessor o3-mini, which is reported at roughly
61.0% under an internal agentic scaffold with high reasoning effort — though independent public
leaderboards have shown o3-mini closer to the high-40s to low-50s percent range depending on scaffold
and harness, a reminder that SWE-bench numbers vary meaningfully with tooling, not just the base
model. Treat any SWE-bench score you see quoted without its harness described as an approximate
data point, not a precise, portable number.

A caveat OpenAI stated explicitly and that is worth repeating here: their published SWE-bench
evaluation excludes 23 samples not runnable on OpenAI’s internal infrastructure and uses a 256K
effective context length for the eval (larger than the model’s standard 200K/100K production limits),
which improves o4-mini’s measured solve rate by roughly 3 percentage points versus a stock configuration
and has under 1 percentage point of impact on o3. That’s a meaningful methodology note: the benchmark
number is not necessarily what you’ll reproduce running the same model at default settings through the
public API.

On contamination and reproducibility more broadly: AIME-style competition math benchmarks are widely
flagged in the field for potential training-data leakage risk once a competition’s problems circulate
online, and OpenAI’s self-reported numbers on its own launch blog are not independently audited in the
way a third-party leaderboard run would be. Where independent trackers (LMArena, SWE-bench’s own public
leaderboard, Epoch AI) report different numbers than OpenAI’s launch blog, that’s the more defensible
comparison point for procurement decisions — and by mid-2026, several of those trackers show o3 and
o4-mini meaningfully behind current-generation GPT-5.6 reasoning tiers and Claude Opus 5 on the same
suites, which is expected given the roughly 15-month gap since o3/o4-mini’s release.

No independently verified LMArena Elo score specific to o3 or o4-mini as configured for chat (rather
than benchmark) use is cited here, since LMArena rankings shift continuously and a snapshot number would
be stale within weeks — check LMArena’s live leaderboard directly if you need current chat-preference
rankings.

Access and Deployment

API access (current as of August 2026):

Model	Input ($/MTok)	Output ($/MTok)	Context window	Max output
o4-mini	~$1.10 (list; some third-party trackers report spot prices as low as ~$0.55 in 2026 — unconfirmed against OpenAI’s own pricing page)	~$4.40	200K tokens	100K tokens
o3	$2.00 (post-June-2025 80% cut from $10)	$8.00	200K tokens	100K tokens
o3-pro	$20.00	$80.00	200K tokens	100K tokens

All three bill hidden reasoning tokens at the output rate — the number that shows up in your invoice is
not just the visible answer, it’s answer-plus-reasoning. For tasks with a lot of internal deliberation
(hard math, multi-step agentic coding), actual cost per request commonly runs several times the naive
“short prompt, short answer” estimate; budget accordingly and log usage.reasoning_tokens from the API
response rather than guessing.

The retirement timeline matters more than the pricing table right now. o4-mini was retired from
ChatGPT’s model picker on February 13, 2026, alongside GPT-4o and GPT-4.1, as part of OpenAI’s broader
GPT-4-era cleanup; it remains callable via the API. o3 is scheduled to be retired from ChatGPT on
August 26, 2026 — thirteen days from this post’s publish date — following a 90-day sunset notice. In
both cases OpenAI has been explicit that these are ChatGPT-app retirements, not API deprecations: as of
this writing there is no announced end-of-life date for o3 or o4-mini in the API itself. Separately,
OpenAI has been deprecating specific dated snapshots of older GPT-5 and o3 model versions from the API
(a June 11, 2026 notice set several such snapshots to be removed by December 11, 2026) — that’s routine
snapshot hygiene, not a signal that the o3/o4-mini model family is being pulled from the API wholesale.
Practically: if you’re a ChatGPT consumer user, o3 is about to disappear from your model picker; if
you’re an API developer, nothing changes today, but you should not build new production systems on a
model family OpenAI has visibly stopped iterating on.

Rate limits scale with usage tier as with other OpenAI models; there is no o-series-specific rate-limit
carve-out publicly documented beyond the standard tier system. Latency: o3 and o4-mini typically return
within “under a minute” per OpenAI’s own framing for standard reasoning effort, but this varies widely
with reasoning effort setting and tool calls — a high-effort o3 request with a Python tool call
in the loop can take substantially longer than a low-effort o4-mini call with no tools. o3-pro is
explicitly slower by design; OpenAI positions it for asynchronous or batch-style workflows rather than
interactive chat.

There are no open-weights releases in the o3/o4-mini family — both are API/ChatGPT-only, closed-weight
models. If open-weight reasoning matters to your deployment, look outside this lineage entirely (e.g.,
DeepSeek-R-class or gpt-oss models), not within it.

For teams already integrated against o3 or o4-mini, migration to GPT-5.6 is largely a matter of swapping
the model name and mapping your existing reasoning_effort-style logic onto GPT-5.6’s own
reasoning_effort parameter, since OpenAI designed the newer parameter as a direct generalization of the
older one. The API request/response shape (messages in, tool-call loop, reasoning tokens counted
separately in usage) has stayed materially consistent across this transition, which is one of the
more developer-friendly parts of OpenAI’s 2026 consolidation — you are not being asked to rewrite your
integration, just to re-point it and re-validate your prompts against the new model’s behavior, which
can differ meaningfully even when the interface is unchanged.

Limitations and Failure Modes

Reasoning-token cost blowups. Because hidden reasoning tokens bill at output rates and their count
isn’t fully predictable in advance, workloads with open-ended or ambiguous prompts can generate far more
reasoning than expected, producing invoice spikes that are hard to forecast from prompt length alone.
Set explicit reasoning-effort levels and monitor reasoning_tokens in production rather than assuming
cost scales with visible output length.

Context ceiling for large-codebase or long-document work. At 200K input tokens and 100K output
tokens, o3 and o4-mini cannot ingest very large repositories, long legal documents, or extended
multi-turn agent transcripts in a single call the way some GPT-5.6 configurations or Claude Opus 5 can.
Workloads that need to reason over hundreds of thousands of tokens of context will hit this wall before
they hit any accuracy limitation.

Tool-use reliability is not perfect. OpenAI’s own documentation and third-party reviews note that
while o3 and o4-mini can chain tool calls inside a reasoning trace, they can still misuse a tool result,
over-trust a web search snippet, or hallucinate confidently despite having browsed for an answer — image
reasoning in particular has been reported to occasionally over-interpret ambiguous visual detail with
high apparent confidence. Treat tool-augmented answers as a strong prior, not ground truth, especially
on anything safety- or compliance-relevant.

Benchmark-to-production gap. As shown above, OpenAI’s own published SWE-bench methodology uses a
larger context window and excludes non-runnable samples relative to a stock API call. Expect real-world
task success rates on your own codebase or problem set to land somewhat below the headline number,
particularly for o3-mini-class comparisons where independent leaderboards report meaningfully lower
scores than OpenAI’s internal-scaffold figures.

A model OpenAI has stopped actively iterating on. This is the most important limitation for
mid-2026 buyers, and it’s a strategic one rather than a technical one: o3 and o4-mini are not receiving
new versions, and OpenAI’s own roadmap has moved reasoning capability into the GPT-5.6 family via the
reasoning_effort parameter. Choosing o3/o4-mini today means choosing a model family that is not going
to get materially smarter, cheaper, or more capable going forward — any future OpenAI reasoning
improvements will land in GPT-5.6-generation models, not in a new o-series release.

No persistent memory or session state beyond the context window. Like other OpenAI API models of
this generation, o3 and o4-mini do not retain information between separate API calls; every request is
stateless unless your application explicitly re-sends prior conversation history within the 200K token
budget. For long-running agentic workflows this means context management (summarization, retrieval,
truncation strategy) is entirely the caller’s responsibility, and poor context management is a common,
avoidable cause of degraded performance on extended tasks that has nothing to do with the model’s
underlying reasoning quality.

Hidden reasoning is not fully auditable. Because the raw chain-of-thought is not exposed by default
in the API (only an optional summary is, depending on endpoint), teams building compliance-sensitive
or safety-critical applications on o3/o4-mini have limited visibility into why the model reached a
given answer, beyond what the visible response and any tool-call log show. This is a known trade-off
across the reasoning-model category generally, not unique to OpenAI, but it’s worth flagging explicitly
for any use case where explainability is a requirement, not a nice-to-have.

How It Compares

Use case	o4-mini	o3 / o3-pro	GPT-5.6 (Sol/Terra)	Claude Opus 5	DeepSeek-R (reasoning)
Cheap high-volume coding agent	Strong — $1.10/$4.40, 68.1% SWE-bench Verified	o3 usable but ~2x o4-mini’s price for similar-tier coding work	Terra tier competes on price at GPT-5.5-class quality per OpenAI’s own framing	Typically priced and positioned above o4-mini; strong on long-horizon agentic coding	Often the cheapest of the group; open-weight option available depending on variant
Hardest math/science, cost no object	o3-pro out of budget for routine use	o3-pro is the pick — highest reliability in this lineage, $20/$80	GPT-5.6 xhigh/max reasoning effort is OpenAI’s current top tier and the actively-improving option	Competitive on graduate-level science reasoning; check current published scores before deciding	Depends on variant and whether verifiable-reward math training is emphasized
Long-document or large-repo context	Not viable past 200K input / 100K output	Not viable past 200K input / 100K output	Larger context tiers available — better fit	Strong long-context handling historically	Varies by release; check current context window
Production system you’ll maintain past 2026	Workable short-term, but a frozen model family	Same caveat, plus a ChatGPT sunset already in motion	Actively iterated — the safer long-term bet per OpenAI’s own roadmap	Actively iterated by Anthropic	Actively iterated by DeepSeek

Read this matrix as: o4-mini remains a legitimately good, cheap choice for narrow, well-scoped reasoning
and coding tasks where 200K context is enough and you don’t need the model to keep improving under you.
o3-pro is defensible only for the specific case of “I need the single most reliable answer to one hard
problem and don’t mind paying $20/$80 per million tokens and waiting.” For anything you expect to run
and maintain for the next year or more, GPT-5.6 (or the equivalent current-generation tier from Claude
or DeepSeek) is the more defensible default, precisely because o3/o4-mini are not going to keep getting
better. See this site’s coverage of Claude Opus 5
and Grok 4.5 for
deeper looks at two of those current-generation peers.

Frequently Asked Questions

Is OpenAI o3 still available in August 2026?

Yes, via the API, with no announced end-of-life date as of this writing. In ChatGPT specifically, o3 is
scheduled for retirement on August 26, 2026, following a 90-day sunset notice — so consumer access
through the ChatGPT app is ending imminently even though API access continues.

Is o4-mini better than o3?

On OpenAI’s own published benchmarks, o4-mini actually scores higher than o3 on AIME 2025 without tools
(92.7% vs 88.9%) and costs roughly half as much per token, because o4-mini’s RL training frontier
“strictly improves” over o3-mini’s, per OpenAI’s launch claims, and it inherited a lot of that
efficiency gain. o3 is not simply “the bigger, better o4-mini” — the two were trained and priced as
different points on a cost/capability frontier, and on several tasks o4-mini is the stronger and cheaper
option.

What is o3-pro and is it worth the price?

o3-pro is a higher-compute variant of o3, released roughly two months after o3/o4-mini, priced at
$20/$80 per million input/output tokens with a 200K context window. It trades latency and cost for
reliability on the hardest problems. It’s worth it for low-volume, high-stakes single queries where
getting the answer right matters more than speed or cost; it’s a poor fit for high-volume or
interactive workloads.

How are reasoning tokens billed?

Reasoning tokens — the hidden chain-of-thought the model generates before its visible answer — are
billed at the same rate as output tokens, and are not shown to end users by default in the API (only a
summary may be exposed, depending on endpoint). This means invoice cost can be much higher than the
visible answer length suggests; monitor usage.reasoning_tokens in API responses rather than
estimating from prompt/answer length alone.

Should I build a new product on o3 or o4-mini today?

Generally, no, unless you have a specific reason (very low latency requirements, a workload that’s
already tuned and validated against these models, or a budget-driven preference for o4-mini’s pricing
tier). OpenAI has visibly shifted new-model investment into the GPT-5.6 family with its
reasoning_effort parameter; o3/o4-mini are stable but frozen. For new builds, evaluate GPT-5.6 first
and treat o4-mini as a fallback for cost-sensitive, narrowly-scoped tasks only.

What replaced o3 and o4-mini in OpenAI’s lineup?

The GPT-5.6 family (Sol, Terra, Luna tiers), launched July 9, 2026, replaced the standalone o-series
approach. Rather than shipping a separate numbered reasoning model, every GPT-5.6 model accepts a
reasoning_effort parameter (none through max) so one model line spans everyday chat and deep,
multi-step reasoning. There is no “o5” and no announced continuation of the o-series brand as a distinct
product line.