Grok 4.20 (Reasoning) is the reasoning-enabled checkpoint of xAI's Grok 4.20, shipped March 2026. Inside Atlas it is a superb reader and a deliberately terse writer: a 1,000,000 token context paired with only a 30,000 token output ceiling, an unusually lopsided ratio. Pricing is $1.25 per Mtok input and $2.5 per Mtok output, which means output costs only 2x input, unlike Gemini 3 Pro where output costs 6x input. Grok 4.20 (Reasoning) is the model to pick when planning across an entire service matters more than emitting a giant diff.
Why does the 1M token context matter for Grok 4.20 (Reasoning) in Atlas?
Grok 4.20 (Reasoning) carries a 1,000,000 token context, which lets Atlas load an entire service before planning a change. For a reasoning model, seeing the whole system before it thinks is the difference between a plan that survives contact with the codebase and one that does not.
Atlas searches code with hybrid semantic and keyword retrieval fused by reciprocal rank fusion, and Atlas indexes code by AST declarations using tree-sitter, not blind line windows. Those retrieval mechanics exist because most models cannot see everything and must be shown the right things. Grok 4.20 (Reasoning), with 1,000,000 tokens, relaxes that constraint: you can hand it a service in full and let its reasoning path find the coupling you did not know to search for. That capability is the whole reason to pay $1.25 per Mtok input on this checkpoint rather than a cheaper one, and it is why Grok 4.20 (Reasoning) belongs on planning tasks specifically.
How does Grok 4.20 (Reasoning) pricing compare on output?
Grok 4.20 (Reasoning) prices output at just 2x input, $2.5 versus $1.25 per Mtok, unlike Gemini 3 Pro where output costs 6x input. For a reasoning model that bills thinking tokens as output, a 2x ratio materially changes what a hard debugging session costs.
Reasoning models charge you for tokens you never read. On a checkpoint where output is priced at 6x input, that hidden thinking is where the bill actually lives. Grok 4.20 (Reasoning) at $2.5 per Mtok output against $1.25 per Mtok input keeps the multiplier at 2x, so a long chain of reasoning is expensive in proportion to reading rather than dramatically worse than it. The counterweight is on the input side: the 1,000,000 token context is only useful if you actually pay to fill it, and a full read is over a dollar per turn at $1.25 per Mtok. Fill it deliberately, on the turns where a whole-service view earns its keep, not on every turn.
What does the Responses API give Atlas on Grok 4.20 (Reasoning)?
Atlas calls xAI through the Responses API (sdk.responses), so reasoning state persists across tool calls instead of being rebuilt each turn. For Grok 4.20 (Reasoning), where the reasoning path is the product, carrying that state through a long tool sequence is what makes the model coherent across a task.
An Atlas session is a chain of tool calls. Atlas connects to Model Context Protocol servers and exposes their tools to the agent, Atlas reads git branches, status, and diffs, and every read, edit, grep, and bash step is another call. If a reasoning model rebuilds its thinking from scratch at each of those boundaries, you pay for reasoning repeatedly and get less continuity for it. Because Atlas calls xAI through the Responses API (sdk.responses), reasoning state on Grok 4.20 (Reasoning) survives across tool calls. The model that inspected the failing test still remembers why it was inspecting it three tool calls later, which is exactly the property multi step debugging requires.
How do you work around the 30,000 token output ceiling?
Grok 4.20 (Reasoning) has a 30,000 token output ceiling, tiny next to Grok 4.5's 500,000, so very large generated diffs get cut off. The Atlas workaround is structural: keep individual edits small, and spend the model's reasoning on strategy rather than bulk generation.
Atlas's documented pattern for Grok 4.20 (Reasoning) is to use Atlas's plan agent first so the model's reasoning is spent on strategy, then let the build agent make the edits. Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent, which fits the model's shape precisely: a 1,000,000 token read window feeds the plan, and the 30,000 token output ceiling constrains each build step. Keep individual edits small because the model can only emit 30,000 output tokens per response. Atlas computes a unified diff for every file edit and surfaces it for approval before writing, so a sequence of small edits stays reviewable, and Atlas snapshots file changes as git patches so any of them can be rolled back.
When should you pick a different model than Grok 4.20 (Reasoning)?
Pick a different model than Grok 4.20 (Reasoning) when you need to emit a very large diff, or when you will not fill the 1,000,000 token context. The 30,000 token output ceiling is tiny next to Grok 4.5's 500,000, and a full context read costs over a dollar per turn.
Two honest disqualifiers. First, if your task is generating a large amount of code in one response, Grok 4.20 (Reasoning)'s 30,000 token output is the wall, and Grok 4.5's 500,000 token output exists for exactly that. Second, if your tasks are mechanical and shallow, you are paying $1.25 per Mtok input for a reasoning path you are not using, and the non-reasoning Grok 4.20 checkpoint gives you the same 1,000,000 token context with lower latency and no thinking tokens. Atlas lets you switch the active model and provider on the fly with favorites and recents, so pinning both checkpoints and flipping when a task turns hard is the intended workflow, not a workaround.
Setup
- 01Create an xAI API key and export it as XAI_API_KEY, or run `atlas login` and select xAI.
- 02Run `atlas models xai` and confirm grok-4.20-0309-reasoning resolved from the registry.
- 03Pin "model": "xai/grok-4.20-0309-reasoning" in atlas.json.
- 04Use Atlas's plan agent first so the model's reasoning is spent on strategy, then let the build agent make the edits.
- 05Keep individual edits small because the model can only emit 30,000 output tokens per response.
Frequently asked questions
- what is Grok 4.20 Reasoning's context window
- Grok 4.20 (Reasoning) has a 1,000,000 token context window paired with only a 30,000 token output ceiling, an unusually lopsided ratio that makes it a strong reader and a terse writer.
- how much does Grok 4.20 Reasoning cost
- Grok 4.20 (Reasoning) costs $1.25 per Mtok input and $2.5 per Mtok output. Output is priced at just 2x input, unlike Gemini 3 Pro where output costs 6x input.
- how do I run Grok 4.20 Reasoning in Atlas
- Export XAI_API_KEY or run `atlas login` and select xAI, run `atlas models xai` to confirm grok-4.20-0309-reasoning resolved, then pin "model": "xai/grok-4.20-0309-reasoning" in atlas.json.
- why does Grok 4.20 cut off my large refactor
- Grok 4.20 (Reasoning) has a 30,000 token output ceiling, tiny next to Grok 4.5's 500,000, so very large generated diffs get cut off. Keep individual edits small.
- is a 1 million token context worth it for coding
- Only if you fill it. Grok 4.20 (Reasoning)'s 1,000,000 token context lets Atlas load an entire service before planning a change, but a full read is over a dollar per turn at $1.25 per Mtok.
- does Grok reasoning state persist across tool calls
- Yes in Atlas. Atlas calls xAI through the Responses API (sdk.responses), so reasoning state persists across tool calls instead of being rebuilt each turn.
- Grok 4.20 Reasoning vs Non-Reasoning for coding
- Both share the 1,000,000 token context, 30,000 token output, and $1.25 / $2.5 per Mtok pricing. The reasoning checkpoint is stronger on multi step debugging and cross-file refactors.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Atlas for TensorFlow: Terminal-Native AI Coding for Keras 3 and tf.data in 2026
Atlas is a terminal-native AI coding agent for TensorFlow and Keras 3 in 2026, where tf.function graph tracing and tf.data pipelines are what make training fast.
Atlas for OCaml: A Terminal-Native AI Coding Agent for dune and opam Projects in 2026
Atlas is a terminal-native AI coding agent for OCaml in 2026. It reads dune stanzas and .mli signatures, runs dune runtest behind a prompt, and finishes with ocamlformat.
Atlas vs Warp: Choosing Your AI Coding Agent in 2026
Compare Atlas, the terminal-native AI coding agent, with Warp, a smart terminal with AI Agent Mode, for developers in 2026. Evaluate features, privacy, and workflow.
Atlas vs v0: A Developer's Guide for 2026
Comparing Atlas and v0 in 2026: Atlas offers terminal-native AI coding with explicit diffs and BYO model keys, while v0 provides a visual editor for React/Next.js apps.
Atlas vs Kilo Code: Terminal AI Coding Agents in 2026
Atlas and Kilo Code in 2026: Compare terminal-native TUI vs VS Code/JetBrains agents. Evaluate pricing, code safety, deployment, and model routing for AI coding.
Atlas for Fastify in 2026
Atlas is a terminal-native AI coding agent for Fastify in 2026. It reads plugin encapsulation and JSON schemas, then runs node --test behind a permission prompt.
Atlas for Deno: Terminal-Native AI Coding in 2026
Atlas is a terminal-native AI coding agent for Deno. Tighten --allow-all down to real permission scopes, add JSR deps, and run deno test and deno check in 2026.
Atlas for Zig: A Terminal-Native AI Coding Agent for build.zig Projects in 2026
Atlas is a terminal-native AI coding agent for Zig in 2026. It reads build.zig and comptime blocks, tracks your allocators, runs zig build test behind a prompt, and runs zig fmt.