Claude vs Gemini vs ChatGPT and Codex explained
If you've used Claude Code, you've probably seen it: a little spinner cycling through words like "Reticulating…", "Herding…", "Schlepping…" while it works. They look like they might mean something — different modes of thinking, maybe, each with its own cost. They don't. They're part of a set of roughly 187 randomized, purely cosmetic loading words the CLI cycles through while a response generates. There's no "Reticulating" tier of billing. But the question underneath that one is real and worth answering: when an AI model "thinks" before it answers, what does that actually cost, and how does it differ across Claude, Gemini, ChatGPT, and Codex?
What a 'thinking' token actually is
Modern "reasoning" models generate text before their visible answer — working through a problem step by step, checking alternatives, planning a multi-step task — and that intermediate text is made of real, generated tokens. Every major provider now bills those tokens the same way: as output tokens, at the output rate, whether or not you ever see them. Hiding the reasoning from the response doesn't make it free — it just makes it invisible.
At a glance: how each platform handles it
| Platform | Reasoning control | Billed as | Visible by default? | Flagship reasoning price (in / out per 1M tokens) |
|---|---|---|---|---|
| Claude (Anthropic) | Effort: low / medium / high / xhigh / max | Output tokens | No — summarized or omitted | Opus 5.5: $4 / $20 |
| Gemini (Google) | Thinking budget (token count or dynamic) | Output tokens, same rate | No, unless you request a thought summary | Gemini 4 Argon: $2 / $10 |
| ChatGPT (OpenAI) | reasoning.effort: minimal / low / medium / high / xhigh / max | Output tokens (reported separately) | No — opt-in summary, may need org verification | GPT-6 Astra: $10 / $50 |
| Codex (OpenAI) | Same reasoning.effort mechanics, via GPT-6.1 Sol / gpt-5.3-codex | Output tokens, same as ChatGPT | No | GPT-6.1 Sol: $2 / $10 |
Claude: effort levels replaced fixed token budgets
Claude used to let you set a hard thinking-token ceiling directly (budget_tokens). On current models that's gone, replaced by an effort setting — low, medium, high, xhigh, or max — that controls how much the model reasons before answering, and Anthropic's own documentation is explicit that this isn't just a display toggle: thinking happens and is billed the same under every visibility setting. Whether you set the response to show a summarized version of the reasoning or hide it entirely, the tokens it took to get there are generated and charged either way. Claude's current flagship, Opus 5.5, prices at $4 per million input tokens and $20 per million output tokens — thinking tokens included in that output figure.
Thinking happens and is billed the same under every display setting — hiding it from you doesn't make it free.
low / medium / high / xhigh / max control depth, not a flat multiplier — a harder problem at the same level can still generate far more reasoning tokens than an easy one.
You pay for Claude's reasoning whether or not you ever read it — effort level is your main lever over how much gets generated.
Gemini: a 'thinking budget' billed at the output rate
Google's Gemini models use a thinking budget — either a specific token ceiling or a dynamic setting that lets the model decide how much reasoning a prompt needs. Google's own pricing page states this plainly: output prices are listed as including thinking tokens, with no separate rate for them. Gemini's current flagship, Gemini 4 Argon, prices at $2 per million input tokens and $10 per million output tokens; mid-tier models like Gemini 3.1 Pro step up to $4/$18 per million past a 200K-token prompt.
Output pricing is explicitly labeled as including thinking tokens — there's no separate meter for reasoning on Gemini.
Long-context requests (over roughly 200K input tokens on Pro-tier models) jump to a higher rate on both input and output, reasoning included.
Simplest mental model of the four — thinking tokens are just output tokens, full stop.
ChatGPT: hidden reasoning tokens with their own line item
OpenAI's reasoning models (the GPT-5 and GPT-6 families, and the older o-series) take a reasoning.effort parameter — values range from none or minimal up through low, medium, high, xhigh, and max, though not every model supports every level. Reasoning tokens are billed as output tokens and count against the context window, but they're invisible by default: OpenAI's docs note you can hit a max-output-tokens cutoff and get billed for reasoning without ever receiving a visible answer. The current flagship, GPT-6 Astra, is priced at $10 per million input tokens and $50 per million output — the most expensive of the four platforms compared here — while smaller models in the same family (GPT-6 Sol-tier, GPT-6 Luna) run far cheaper.
Tracked separately in the API response as output_tokens_details.reasoning_tokens, but still billed as ordinary output tokens.
A response can end as 'incomplete' after spending its whole token budget on hidden reasoning — you can pay for thinking and still get no answer.
The most expensive flagship per token here, and the one where it's easiest to burn budget on reasoning you never see.
Codex: the same reasoning engine, spread across a whole session
Codex, OpenAI's coding agent, isn't a separate pricing model — it runs on the same reasoning-token mechanics as the ChatGPT API, currently built on GPT-6.1 Sol (priced the same as its ChatGPT counterpart, $2/$10 per million, with an additional 'Ultrafast' speed mode), with gpt-5.3-codex ($1.75/$14) still available as a selectable model. The practical difference isn't the billing rule — it's the shape of the session. A single chat answer reasons once; an agentic coding run reasons repeatedly across every tool call, file read, and edit in a long session, so the hidden reasoning-token cost compounds turn by turn rather than showing up as one number.
Identical mechanics to the ChatGPT API — reasoning tokens billed as output, hidden by default — just accumulated across many turns instead of one.
A long autonomous coding session can rack up reasoning-token cost well past what a single prompt-and-response exchange would suggest.
Same rules as ChatGPT, applied many times per session — the cost adds up in the number of turns, not a special per-turn rate.
What actually drives your bill
None of this is about a "type" of thinking costing more than another — it comes down to three things: which effort or budget level you (or the app you're using) select, how long and complex the task actually is, and whether you're paying per-token API rates at all. If you're on a flat consumer subscription — ChatGPT Plus, a Claude plan, Gemini's app tiers — none of this per-token math applies directly to you; the provider is absorbing reasoning cost behind a flat monthly price. It only becomes a line-item concern once you're calling these models through an API and watching the meter run.
Do Claude Code's playful status words like 'Reticulating' or 'Herding' mean something different token-wise?
No — those are just a set of roughly 187 randomized loading-spinner verbs Claude Code cycles through while a response generates. They're cosmetic, not a cost or reasoning-type indicator.
If reasoning tokens are hidden, how would I even know how many I used?
API responses report them separately — Claude's usage object, OpenAI's output_tokens_details.reasoning_tokens field, and Gemini's thinking-token counts all break this out in the billing data, even though the reasoning text itself usually isn't shown to you.