ChatGPT · The OpenAI model family: GPT, reasoning models, and when to use each
OpenAI ships two different kinds of behavior under one roof: fast general answering, and deliberate reasoning that thinks before it responds. Picking the wrong mode wastes either your money or your accuracy. This lesson is about routing: matching the task to the model (or the reasoning level) so you stop overpaying for trivial work and stop under-powering hard work.
Two behaviors, converging into one product
OpenAI used to split these into two named lineups: the GPT "chat" models (GPT-4o and friends) and the "o" series reasoning models (o3, o4-mini). The GPT-5 family (GPT-5 in August 2025, then GPT-5.1 and GPT-5.2) collapsed that split. One model now decides how hard to think, and you can set the level yourself. The underlying tradeoff is the same, so the routing logic below still holds.
Fast answering is optimized for breadth and latency. You send a prompt and tokenstokensA token is the basic unit of text that language models process, often a word fragment, whole word, or punctuation mark rather than a single character.View full definition → stream back almost immediately. It handles writing, summarizing, classification, formatting, code completion and conversation well.
Reasoning spends extra hidden compute on a problem before it gives the final answer. That hidden work is made of *reasoning tokens*: internal steps you pay for and never see. It trades latency and cost for accuracy on multi-step problems: math, hard debugging, planning, scientific analysis, and anything where a wrong intermediate step ruins the result.
The family also comes in smaller variants (mini and nano tiers). They have the same general profile at lower cost and lower latency, with a bit less depth. A mini model with reasoning turned up still thinks, just more cheaply.
The official mapmapUsing software to automate repetitive marketing tasks and campaigns, enabling personalisation at scale across channels like email, web, and social.View full definition → of current models lives in the models documentation. Point releases arrive every few months, so check it when names change. The routing logic does not change with them.
The routing decision in one question
Ask: does this task have a verifiable chain of steps where an early mistake breaks the outcome?
- No: answer fast. Rewrites, tone changes, drafting, extraction, summarization, simple Q&A, casual chat.
- Yes: turn reasoning up. Multi-constraint analysis, math proofs, ambiguous bug hunts, multi-document synthesis with logic, planning a sequence of actions.
Then ask a second question for cost: is this high-volume or latency-sensitive? If yes, drop to a `mini`/`nano` variant.
Concrete example: rewrite vs analysis
Task A: "Rewrite this paragraph to be more concise and confident."
This is a one-shot transformation with no chain to get wrong. Turn reasoning off and let it answer fast.
from openai import OpenAI
client = OpenAI()
resp = client.responses.create(
model="gpt-5.2",
reasoning={"effort": "none"},
input="Rewrite to be concise and confident:\n\n" + paragraph,
)
print(resp.output_text)Task B: "Here are three vendor contracts. Find every clause where renewal terms conflict, and tell me which contract wins under the precedence rules in section 12."
This one is multi-step. The model has to extract clauses, compare them, apply precedence logic and resolve the conflicts. An early misread cascades through everything after it, so turn reasoning up and let it spend tokens.
resp = client.responses.create(
model="gpt-5.2",
reasoning={"effort": "high"},
input=contracts_text + "\n\nFind conflicting renewal clauses and resolve per section 12.",
)
print(resp.output_text)Three things to notice:
- Both calls use the Responses APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.View full definition → (
responses.create), OpenAI's primary interface. reasoning.effortis your main lever: same model, different amount of thinking. The allowed values depend on the model. GPT-5.1 and later acceptnone,low,mediumandhigh, and GPT-5.2 addsxhighfor the hardest problems. The original GPT-5 usedminimalinstead ofnone.- If you pin an older model (gpt-5, o3, o4-mini), check its supported values in the docs before copying code across. Sending an unsupported effort value returns an error.
In ChatGPT: the picker in plain terms
In the ChatGPT apps the default is Auto. It decides internally whether to answer fast or think harder, and you can override it:
- Auto handles most daily work without you touching anything.
- Instant forces quick answers. Use it for drafting and rewrites when you want speed.
- Thinking forces deliberate reasoning. Switch to it when a fast answer keeps coming back shallow or subtly wrong.
- Pro (on higher plans) spends the most compute and is meant for the hardest, highest-stakes questions.
On Auto, your prompt is also a lever. Writing "think carefully and check each step" cues the model to spend more reasoning. Older models may still sit under a legacy menu on some plans, but they are no longer the default path.
A practical habit: start fast, and escalate to Thinking only when you catch the model skipping logic. Thinking is slower, and on paid plans it draws on tighter usage limits.
Where this intersects ChatGPT's features
Model choice, or how hard you tell it to think, changes how the rest of the ChatGPT toolset behaves.
Data analysis. When you upload a CSV and ask for analysis, the model writes and runs Python in a sandbox. High reasoning is far better at planning a correct multi-step analysis (clean, join, aggregate, validate) before it writes the code. A fast answer is fine for "make a quick bar chart."
Canvas. For long-form writing and code you edit side by side, fast answering keeps the loop tight. Turn reasoning up only when the *content itself* requires hard logic, like deriving an algorithm.
Custom GPTs and Projects. Your instructions and memory shape behavior either way, but a model thinking harder follows multi-part instructions more reliably because it can plan around them. If your Custom GPT keeps ignoring constraint #4 of 6, the reasoning level may be the bottleneck.
The ChatGPT agent and scheduled tasks. Autonomous work (browse, click, synthesize) leans on heavier reasoning by design, because each step depends on the last.
Choosing Between GPT and Reasoning Models
Cost and latency: the real tradeoff
Pricing details change, so reason qualitatively. The live numbers are on the pricing page.
- Reasoning costs more per task than the token rate suggests, because it generates invisible reasoning tokens on top of the visible answer. High effort on a hard problem can cost several times a fast answer on an easy one.
mini/nanovariants exist so you can run at scale without that cost exploding. For batch classification of 100k support tickets, aminimodel is almost always the right call over the flagship.- Latency tracks the same axis. High effort feels slow because the model is thinking, and that is expected behavior. Do not put it behind a UI that needs sub-second responses unless you set
efforttononeorlow.
A simple internal rule for teams: default to fast answering, allow high reasoning effort on an explicit allowlist of task types, and reserve the flagship at high or xhigh for low-volume, high-stakes work.
Knowledge check
1. What is the fundamental distinction between general GPT models and reasoning models?
2. According to the lesson, what single question best determines whether to route a task to a reasoning model?
3. What are 'reasoning tokens' as described in the lesson?
4. Select ALL tasks that are best suited to a general GPT model rather than a reasoning model.
Select all the correct answers.
5. Select ALL correct statements about the 'mini' and 'nano' variants.
Select all the correct answers.
Reasoning changes how you prompt
Once you turn reasoning up, change your promptingpromptingPrompt engineering is the practice of designing and refining text inputs to guide large language models toward accurate, relevant, and reliable outputs.View full definition → style too, or you waste its strength.
Stop hand-holding the steps. With fast answering you often add "think step by step." A model that is already reasoning does this on its own, and spelling out the steps can constrain it. State the goal, the constraints and the success criteria, then get out of the way.
Weak prompt when reasoning is high:
First list the clauses. Then compare them. Then apply section 12. Then conclude.
Stronger:
Resolve all renewal-term conflicts across these contracts. Success = every conflict identified with the controlling contract named and the section-12 rule that decides it. Flag anything ambiguous rather than guessing.
Give it room and a clear finish line. A reasoning model does best with a crisp definition of "done" and explicit instructions about uncertainty ("flag, don't guess"). It also handles structured outputs well, so pair it with a JSON schemaschemaA schema is the formal blueprint that defines how data is structured, named, typed, and related within a database, file, or message.View full definition → when the answer feeds another system.
schema = {
"name": "conflict_report",
"schema": {
"type": "object",
"properties": {
"conflicts": {
"type": "array",
"items": {
"type": "object",
"properties": {
"clause": {"type": "string"},
"winning_contract": {"type": "string"},
"rule": {"type": "string"},
},
"required": ["clause", "winning_contract", "rule"],
"additionalProperties": False,
},
}
},
"required": ["conflicts"],
"additionalProperties": False,
},
"strict": True,
}
resp = client.responses.create(
model="gpt-5.2",
reasoning={"effort": "high"},
input=contracts_text + "\n\nReturn the conflict report.",
text={"format": {"type": "json_schema", **schema}},
)strict: True makes the model return exactly that shape. This matters most when the output flows into downstream code.
Reasoning inside agents
When you build with the Agents SDK or wire up function calling, the tradeoff maps onto roles:
- The planner decides which tools to call and in what order. It benefits from high reasoning effort, because tool selection is exactly the kind of multi-step decision reasoning handles well.
- The workers do narrow, single-shot jobs: summarizing a fetched page, formatting a result, drafting a reply. They can run at
noneor on a cheaperminimodel.
This split keeps an agent smart and affordable: think hard about *what to do*, act cheaply on *each step*. A common anti-pattern is running the flagship at high effort for every tool call, which makes agents slow and expensive with no gain in accuracy.
A quick mental checklist
Before every non-trivial task, run this:
- Chain of dependent steps? Raise reasoning effort. Single transformation? Keep it fast.
- High volume or needs speed? Drop to
mini/nano. - Output feeds code or another tool? Add structured outputs.
- Reasoning turned up? State goal, constraints and "done," not the steps.
- Building an agent? Reason hard to plan, act fast to execute.
Key Takeaways
- Route by structure, not by hype. A single transformation should answer fast. A chain of dependent steps, where one mistake breaks the result, should reason harder. On the GPT-5 family that is the
reasoning.effortknob, not a separate model. - Effort values differ by model:
nonethroughhighon GPT-5.1 and later, plusxhighon GPT-5.2, while the original GPT-5 usedminimal. Check the docs before reusing code. - In ChatGPT, Auto routes for you. Instant, Thinking and Pro are manual overrides.
mini/nanovariants are your cost lever. For high-volume or latency-sensitive work, a smaller model at the right effort beats the flagship.- Reasoning costs more than the token rate implies because of invisible reasoning tokens. Prompt it with a goal, constraints and a definition of "done," and in agents keep high effort for planning only.
Frequently asked questions
What is the difference between a GPT model and a reasoning model at OpenAI?
A GPT model answers fast: you send a prompt and tokens stream back almost immediately, which suits writing, summarizing, classification and conversation. A reasoning model spends hidden compute before answering, generating internal reasoning tokens you pay for but never see, which buys accuracy on multi-step problems like math, debugging or planning. Since the GPT-5 family (August 2025), the two lineups have merged into one model whose thinking level you set yourself.
How do I know whether a task needs reasoning or a fast answer?
Ask one question: does the task have a chain of dependent steps where an early mistake ruins the outcome? If no (rewrites, tone changes, extraction, summarization, simple Q&A), answer fast. If yes (multi-constraint analysis, ambiguous bug hunts, multi-document synthesis with logic, planning a sequence of actions), raise the reasoning effort.
What values can I pass to reasoning.effort in the OpenAI API?
It depends on the model. GPT-5.1 and later accept none, low, medium and high; GPT-5.2 adds xhigh for the hardest problems; the original GPT-5 used minimal instead of none. Sending an unsupported value returns an error, so check the models documentation before copying code from one model to another.
When should I use a mini or nano model instead of the flagship?
Use mini or nano whenever the work is high-volume or latency-sensitive. They share the same general profile at lower cost and lower latency, with a bit less depth, and a mini model with reasoning turned up still thinks, just more cheaply. For batch classification of 100k support tickets, mini is almost always the right call over the flagship.
What do Auto, Instant, Thinking and Pro do in ChatGPT?
Auto is the default and decides internally whether to answer fast or think harder, which covers most daily work. Instant forces quick answers for drafting and rewrites, Thinking forces deliberate reasoning when fast answers come back shallow or subtly wrong, and Pro (on higher plans) spends the most compute for the hardest questions. A good habit is to start fast and escalate to Thinking only when you catch the model skipping logic, since Thinking is slower and draws on tighter usage limits.
Should I still write "think step by step" when reasoning effort is high?
No. A model already reasoning does this on its own, and spelling out the steps can constrain it. State the goal, the constraints and an explicit definition of "done", plus instructions on uncertainty such as "flag anything ambiguous rather than guessing". If the output feeds downstream code, pair it with a JSON schema in strict mode so the shape is guaranteed.
What to do, from this lesson
These actions are compiled in the role's Playbook.
- Route reasoning models to plan and cheap fast models to execute steps
- Prompt reasoning models with goal, constraints, and definition of done
- Cap reasoning effort and default to fast models, escalating deliberately
Related articles
Recent articles from the blog that build on this lesson.
- AIGoogle shipped a Gemini that never writes a sentence, and it changes how you pick a modelGoogle's Gemini Decision 1 only scores answers you write in advance, and OpenAI already sells the same kind of model, so asking "ChatGPT, Claude or Gemini?" no longer gets you far. This playbook shows how to pick a model for each job, test it on your own cases and price the whole task.
- AIReasoning models and when to use them: the hype is ahead of the practiceReasoning models like OpenAI's o3 and Google's Gemini 2.0 Flash Thinking have captured attention by visibly "thinking through" problems before answering. The consensus says to use them everywhere you need accuracy, but that prescription is wrong in ways that will cost you money and slow your teams down.
- AIReasoning models: a practical playbook for knowing when to use themNot every task benefits from a reasoning model, and using one indiscriminately wastes time, money, and attention. This playbook gives you a concrete decision process for matching the right model type to the right problem.