by xAI · Grok 4 family · best for single-call parallel deep research with live X data
Grok 4.20 Multi-Agent is a structurally distinct variant of Grok 4.20 (API slug grok-4.20-multi-agent-0309, GA 2026-03-31) that orchestrates 4 to 16 parallel sub-agents inside a single API call. Each agent independently searches, analyzes, and cross-references before a coordinator synthesizes one final answer. It retains a 2,000,000-token context and supports up to ~2M output tokens, making it a book-length-research workhorse with live X data baked into every agent. The single sentence a buyer needs: it replaces a hand-rolled agent framework with one API call for deep, multi-source research — at the cost of minutes-not-seconds latency and a token bill multiplied by the active agent count. Provider: xAI. Released: 2026-03-31. Status: GA. Context: 2M tokens. Max output: ~2M tokens. Modalities: text + image in, text out. Knowledge cutoff: November 2024. Headline price: $1.25 / $2.50 per 1M tokens, billed per active agent.
| Benchmark | Score | Source |
|---|---|---|
| MATH-500 | 87.3% | inherits Grok 4.20 base (xAI launch / secondary)2026-03-10T00:00:00.000Z |
| LMArena Elo | 1505 | NextBigFuture (estimated 1505-1535 range at launch; not an official LMArena posting)2026-03-31T00:00:00.000Z |
| GPQA Diamond | 78.5% | inherits Grok 4.20 base (xAI launch / secondary)2026-03-10T00:00:00.000Z |
Six personas, six verdicts — the same panel that reviews every product on TopReviewed.
“It moves orchestration into the model — fewer moving parts, but a real lock-in I have to weigh against building it myself.”
Strategically, this variant trades control for convenience: orchestration lives in xAI's model layer instead of your codebase. For teams without an agent framework, it's a low-floor way to get parallel research; for teams already invested in one, adopting it means giving up that control. The lock-in is the standout risk — unlike the rest of the SDK-compatible Grok line, the multi-agent semantics have no drop-in equivalent, so exit means rebuilding orchestration. The X-search-in-every-agent moat is genuine and defensible. As a niche addition for research-heavy workloads, it's a reasonable bet if you accept the lock-in.
“xAI is annexing the agent-framework category from inside the model — a distinct positioning bet that widens its surface without firing at rivals directly.”
Positionally, Grok 4.20 Multi-Agent stakes out territory between foundation models and orchestration frameworks. By making parallel research a native model feature with live X data in every agent, xAI differentiates on a shape competitors deliver as separate products (OpenAI Deep Research, Perplexity). The market-timing logic is to capture research workflows before rivals bundle them natively. Differentiation is strong on the live-data-per-agent angle. The weakness is that it's a niche, not a mass-market play — and the lock-in that helps retention also limits adoption by framework-committed teams. A clever, narrow strategic move.
“Price it as 4-16 calls, not one — then compare against the engineer-hours a manual multi-search-and-merge would cost.”
The economics are entirely workload-dependent. At $1.25 / $2.50 per agent, a 16-agent high-effort run costs 10-20x a single Grok 4.3 call on the same input. That's only justified when the alternative is real: running a model many times and paying a human to merge and cite. On that comparison, deep-research runs often pencil out, especially versus analyst hours. For anything chat-shaped, the cost case collapses completely. Predictability is poor because cost scales with the effort dial, so finance should cap agent count per use case and model worst-case (16-agent) bills.
“One call, no LangChain, a 2M-token report comes out — but when a 16-agent run goes wrong, good luck finding which agent broke.”
For builders, this is the fastest path to a parallel research agent: one API call, no orchestration code, structured output on the final synthesis, and a 2M output ceiling that returns long reports in a single response. Function calling works on the merge step. The pain is observability — when a 16-agent run yields a bad answer, isolating the culprit agent is harder than in a custom framework where every step is logged; agent-tracing tooling still lags. Docs are improving but thinner than peers. For the right shape of task, the productivity win is large; for debuggable production pipelines, the opacity is a genuine cost.
“Most people never call it directly — but behind SuperGrok Heavy's Deep Research, the parallel pass genuinely beats a single answer.”
This is an API-tier product, not a default on grok.com, so most everyday users meet it only indirectly via SuperGrok Heavy "Deep Research" flows. When they do, output quality on research-heavy questions is noticeably better than a single-model pass — broader sourcing, more cross-checking, a contrarian angle. The cost is latency: minutes, not seconds, which would feel broken in chat. As a behind-the-scenes research engine it delivers; as a conversational daily driver it would frustrate. For the power user who specifically wants depth over speed, it's worth the wait.
“Top agentic index, sure — but there's no standard Intelligence Index, no SWE-bench, and the LMArena number is a launch estimate, not a posting.”
Adversarially, the multi-agent variant leans hardest on the thinnest evidence in the lineup. The headline is one number — AA's agentic index of 68.7 — and the LMArena figure floating around (~1505-1535) is an estimate from a launch write-up, not an official LMArena posting; I have marked it as such. There's no standard Intelligence Index posted, no SWE-bench, no architecture. "16 agents collaborating" is great marketing, but more agents also means more cost and more opacity, and the gains are asserted on agentic benchmarks that few can independently reproduce. The live-data-per-agent capability is real and genuinely useful; the quantified superiority claims are largely unverifiable.
The full research notes behind this review — verified against primary sources.
The base model is undisclosed like the rest of the Grok line; what is distinctive is the orchestration layer bolted on top. Rather than a single inference pass, a request spawns multiple sub-agents that work concurrently — each with its own tool access (web, X search) — before a coordinator agent merges their findings into one synthesized response. The agent count is controlled by reasoning effort (4 at low/medium, 16 at high/extra-high). Secondary sources describe a role-specialized team (coordinator, researcher, logic/code, creative-contrarian), which means the "contrarian" agent is a deliberate design choice to stress-test consensus before the final answer. Parameter counts, base architecture, and training details remain null/unknown. This is the one Grok variant whose multi-agent semantics have no direct OpenAI/Anthropic-SDK equivalent, which raises migration cost.
| Benchmark | Score | vs Predecessor | vs Top Competitor | Source |
|---|---|---|---|---|
| Artificial Analysis Agentic Index | 68.7 | Above single-pass 4.20 | Among highest agentic indices available | Verdent guide |
| GPQA Diamond (inherited) | ~78.5% | Same as base 4.20 | Behind Opus 4.7 / GPT-5.5 | Launch coverage |
| MATH-500 (inherited) | ~87.3% | Same as base 4.20 | Competitive | Launch coverage |
| LMArena Elo (estimated) | ~1505-1535 | Estimate at launch | Top-5 band if confirmed | NextBigFuture (estimate) |
(Per-agent benchmark scores are not separately published, and standard single-turn evals understate a multi-agent design. The standard Artificial Analysis Intelligence Index is not posted for this variant — AA tracks it on an agentic index instead. The LMArena number is a launch-time estimate, not an official posting. Rows left null where no verifiable figure exists; nothing invented.)
Latency is the defining trade-off: multi-agent passes take minutes, not seconds, because the system fans out, runs parallel searches and reasoning, then synthesizes. A single output_speed_tps figure is not meaningful for a fan-out architecture, so it is null. Latency tier: slow. This is acceptable for asynchronous deep-research jobs and entirely wrong for chat-style or interactive use.
| Surface | Cost | Notes |
|---|---|---|
| API input | $1.25 / 1M tok | Multiplied by active agent count (4-16) |
| API output | $2.50 / 1M tok | Multiplied by active agent count |
| Cached input | $0.20 / 1M tok | 84% discount on cache reads |
| Direct UI | n/a directly | Surfaces via SuperGrok Heavy "Deep Research" flows |
| SuperGrok Heavy | $300 / mo | Where most consumer multi-agent usage happens |
| Rate limits | tighter than single-agent slugs | Fan-out cost forces lower limits |
Cost reality: the headline $1.25 / $2.50 is per-agent. A high-effort 16-agent run can burn roughly 10-20x what a single Grok 4.3 call costs on the same input. The right comparison is not "Grok 4.3 once" but "running a model 4-16 times and paying an engineer to merge the results" — on that basis the economics can win for genuine research; for chat they collapse. (Same docs-vs-aggregator pricing caveat as the rest of the 4.x line: docs.x.ai is canonical.)
Proprietary, API-only, no open weights, not self-hostable. Resold on OpenRouter. Not a confirmed Azure AI Foundry SKU. The key deployment caveat: the multi-agent semantics have no drop-in OpenAI/Anthropic-SDK equivalent, so unlike the rest of the Grok line, migrating off xAI would mean rebuilding the orchestration yourself — a real, if moderate, lock-in. Rate limits are tighter than single-agent slugs because each request fans out.
Inherits the Grok 4.20 base posture: no published safety framework, governance via Acceptable Use Policy, moderation tightened January 2026, best-in-class non-hallucination at the base model's release. Training-on-inputs: API opt-in (irreversible) / X consumer default with no opt-out. A novel governance wrinkle is the built-in "contrarian" agent (Lucas), which deliberately challenges the emerging consensus before synthesis — a mild internal red-team, not a substitute for external safety controls. No verified compliance certs.
Python/TypeScript SDKs; LangChain integration; resold on OpenRouter. Primary surface for consumers is SuperGrok Heavy's Deep Research. Popularity is niche — a specialist tool for research-heavy workloads rather than a general model.
$1.25 / $2.50 per 1M tokens, multiplied by the number of active agents (4 at low/medium effort, 16 at high/extra-high). Budget for the worst case.
4 to 16 in parallel. Secondary sources describe roles: a coordinator, a researcher (live X), a logic/math/code agent, and a creative-contrarian agent that challenges consensus before synthesis.
For deep, multi-source research and long-form synthesis where breadth of parallel search matters. For chat, coding, or low-latency work, use a single-pass model.
Minutes, not seconds — it fans out, searches, reasons, then synthesizes. Treat it as an async job.
Yes, more than the rest of the Grok line: the multi-agent semantics have no SDK-compatible equivalent, so migrating off means rebuilding orchestration.
Not as a confirmed Azure AI Foundry SKU; it's a direct x.ai API product (also on OpenRouter).
Same base model without orchestration; far cheaper per run, single-pass; loses the parallel-research breadth.
Comparable research workflow on the OpenAI stack with broader tooling and disclosure; lacks native live-X access per agent.
Agent control stays in the developer's hands (more observability, more code); different shape, no built-in fan-out.
Primary references used to verify this review.
Last verified 2026-05-27