Grok 4.20 Multi-Agent is xAI's multi-agent variant of Grok 4.20, which orchestrates several internal agents behind a single model id. It carries the same 1,000,000 token context, 30,000 token output, and $1.25 / $2.5 per Mtok pricing as the other 4.20 checkpoints. Inside Atlas, the interesting property is that its internal fan-out stacks with Atlas's own parallel subagents, giving you two levels of parallel exploration. The cost of that is predictability: token consumption per request is harder to forecast than the single-agent 4.20 variants.
What does two levels of fan-out mean in Atlas?
Grok 4.20 Multi-Agent runs internal multi-agent orchestration behind one id, which stacks with Atlas's own parallel subagents for two levels of fan-out. Atlas fans out work to subagents that can run in the foreground or in parallel background sessions, and each of those subagents is itself a multi-agent model.
Picture the shape concretely. Atlas splits a broad task into several subagents and runs them in parallel background sessions. Each subagent calls Grok 4.20 Multi-Agent, which then orchestrates several internal agents of its own behind a single model id. The result is a wide search over a problem space, executed in one wall-clock stretch. For exploratory work, mapping how a pattern is used across a large repository, finding every place an assumption is violated, that width is genuinely useful. Atlas searches code with hybrid semantic and keyword retrieval fused by reciprocal rank fusion, so each of those parallel branches gets high-quality retrieved code to work from rather than grepping blindly.
Why is Grok 4.20 Multi-Agent spend hard to predict?
Grok 4.20 Multi-Agent's internal agent fan-out means token consumption per request is harder to predict than the single-agent 4.20 variants. The per-token price is identical at $1.25 per Mtok input and $2.5 per Mtok output, but the number of tokens a single request consumes is not fixed.
With a single-agent checkpoint, a turn's token count is roughly the prompt plus the completion. With Grok 4.20 Multi-Agent, one request may spawn several internal agents whose work all bills back to that request. The unit price does not change. The unit count does. Atlas's documented advice is behavioral rather than configurational: watch the session token counter closely on the first few runs since fan-out spend is less predictable. Do that on a task you understand, get a feel for the multiplier on your kind of work, and only then let Grok 4.20 Multi-Agent loose on something open ended. The 1,000,000 token context makes the ceiling on any one branch high.
How do you stop Atlas subagents from running at multi-agent cost?
Set "small_model" to something cheap so Atlas's own subagents do not also run at multi-agent cost. Without that, Atlas's parallel subagent fan-out multiplies against Grok 4.20 Multi-Agent's internal fan-out, and every background call inherits the $1.25 per Mtok input rate plus unpredictable internal agent spend.
The two levels of fan-out that make Grok 4.20 Multi-Agent powerful are also the reason a naive configuration gets expensive. Atlas exposes "model" and "small_model" as separate slots precisely so you can put the expensive orchestrator on the main loop and something cheap on the background traffic. Pin "model": "xai/grok-4.20-multi-agent-0309" in atlas.json for exploratory, wide-search tasks, then set "small_model" to something cheap so Atlas's titles, summaries, and background subagent calls do not inherit the multi-agent bill. That single split is the difference between a controlled experiment and a surprising invoice, and it takes one line of atlas.json.
How does the Responses API help a multi-agent run?
Grok 4.20 Multi-Agent is reached through the xAI Responses API in Atlas, so reasoning state survives across the many tool calls a multi-agent run generates. A wide fan-out produces far more tool calls than a single-agent turn, which is exactly the condition where rebuilt state gets expensive.
Grok 4.20 Multi-Agent is reasoning enabled, and a multi-agent exploration generates a long, branching sequence of tool calls against Atlas: reads, greps, git status checks, MCP tool invocations. If reasoning state were rebuilt at each of those boundaries, the cost of the fan-out would compound on top of itself. Because Atlas reaches xAI through the Responses API, that state persists instead. Every Atlas tool call is still permission-gated against allow, ask, and deny rules before it runs, so a wide multi-agent exploration cannot quietly do more than you allowed it to, no matter how many internal agents xAI spun up behind the single model id.
When should you pick a different Grok 4.20 checkpoint?
Pick a different Grok 4.20 checkpoint when the task is narrow. Grok 4.20 Multi-Agent costs the same $1.25 per Mtok input as the plain reasoning checkpoint but consumes an unpredictable number of tokens per request, so a well-scoped edit gains nothing from internal fan-out.
Grok 4.20 Multi-Agent earns its unpredictability on exploratory, wide-search tasks and nowhere else. For a known change to known files, the plain reasoning checkpoint gives you the same 1,000,000 token context and reasoning at the same $1.25 per Mtok input with a token count you can forecast. Also note the 30,000 token output ceiling still applies, so a wide multi-agent exploration must still summarize into a narrow response. The model can look at a great deal and can only tell you a limited amount about it. Atlas lets you switch the active model and provider on the fly with favorites and recents, so use Grok 4.20 Multi-Agent to explore, then flip to a single-agent checkpoint to execute.
Setup
- 01Export XAI_API_KEY from the xAI console.
- 02Run `atlas models xai` and confirm grok-4.20-multi-agent-0309 appears.
- 03Pin "model": "xai/grok-4.20-multi-agent-0309" in atlas.json for exploratory, wide-search tasks.
- 04Set "small_model" to something cheap so Atlas's own subagents do not also run at multi-agent cost.
- 05Watch the session token counter closely on the first few runs since fan-out spend is less predictable.
Frequently asked questions
- what is Grok 4.20 Multi-Agent
- Grok 4.20 Multi-Agent is xAI's multi-agent variant of Grok 4.20, which orchestrates several internal agents behind a single model id. It keeps the 1,000,000 token context and $1.25 / $2.5 per Mtok pricing.
- how much does Grok 4.20 Multi-Agent cost
- Grok 4.20 Multi-Agent is priced at $1.25 per Mtok input and $2.5 per Mtok output, the same as the other 4.20 checkpoints. Token consumption per request, however, is harder to predict.
- how do I configure Grok 4.20 Multi-Agent in Atlas
- Export XAI_API_KEY, run `atlas models xai` and confirm grok-4.20-multi-agent-0309 appears, then pin "model": "xai/grok-4.20-multi-agent-0309" in atlas.json for exploratory, wide-search tasks.
- why is my Grok 4.20 Multi-Agent bill unpredictable
- Internal agent fan-out means token consumption per request is harder to predict than the single-agent 4.20 variants. Watch the session token counter closely on the first few runs.
- can you nest multi-agent models inside a coding agent's subagents
- Yes. Grok 4.20 Multi-Agent's internal orchestration stacks with Atlas's own parallel subagents for two levels of fan-out. Set "small_model" cheap so subagents do not also run at multi-agent cost.
- does Grok 4.20 Multi-Agent have a bigger output limit
- No. The 30,000 token output ceiling still applies to Grok 4.20 Multi-Agent, so a wide multi-agent exploration must still summarize into a narrow response.
- Grok 4.20 Multi-Agent vs plain reasoning checkpoint
- Both are reasoning enabled with a 1,000,000 token context at $1.25 per Mtok input. Multi-Agent adds internal fan-out for wide-search tasks, at the cost of predictable token consumption.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Atlas for PHP in 2026
Atlas, the terminal-native AI coding agent, empowers PHP developers in 2026 with intelligent code understanding, secure workflows, and direct integration for Composer and PSR standards.
Atlas for C in 2026
Atlas is a terminal-native AI coding agent for C in 2026. Run it in a project with a Makefile, have it find memory leaks or add Unity tests, and review the diff.
Atlas vs Gemini CLI: A Developer's Guide to Terminal AI Agents in 2026
Atlas vs Gemini CLI in 2026: Compare terminal AI coding agents. Atlas offers permission-gated tool calls and diff-based approvals. Gemini CLI provides a million-plus token context and a free tier.
Atlas vs Cursor: terminal AI coding agents compared (2026)
A grounded 2026 comparison of Atlas and Cursor across workflow, change review, extensibility, and pricing for developers choosing an AI coding agent.
Atlas vs. Goose: Choosing Your AI Coding Agent in 2026
Compare Atlas and Goose for 2026. Atlas offers terminal-native TUI and code-specialized features. Goose provides shareable Recipes and 70+ MCP extensions for general agentic workflows.
Self-Review Your Working Diff Before Committing with Atlas (2026 Workflow)
How to self-review your working diff before committing with Atlas in 2026: bash produces the diff, read checks each file, grep finds leftovers, session revert undoes bad edits.
Run Atlas Headless in CI with Atlas (2026 Workflow)
How to run Atlas headless in CI in 2026: atlas run sends one prompt and exits when the session goes idle, with --format json, --command, and --continue for pipeline steps.
Atlas vs Pieces for Developers: AI Tools for Developers in 2026
Comparing Atlas, a terminal-native AI coding agent, with Pieces for Developers, an OS-level memory layer, for developers in 2026. Evaluate code generation, safety, and context management.