by xAI · Grok Build family · best for cheap plan-mode coding agent with parallel sub-agents
xAI's pages no longer present Grok Build 0.1 as its latest coding model: the grok-build-latest alias now points to Grok 4.5 (released 2026-07-16), the models page recommends Grok 4.7 (released 2026-09-21) for code, and Grok 4.7 is the default model in the Grok Build agent; no xAI page names a successor to grok-build-0.1 itself, which stays listed on the API. Grok Build 0.1 is xAI's first dedicated agentic coding model and CLI, launched 2026-05-14 (API GA 2026-05-20, slug grok-build-0.1). It competes directly with Claude Code and OpenAI Codex CLI. Its defining traits: a CLI that runs on the developer's machine while the model runs on xAI's API (xAI's security FAQ says the CLI retains code data unless you turn code-data retention off in /privacy or /settings or enable team-wide Zero Data Retention), plan mode (an approval-gated plan before execution), up to 8 parallel sub-agents running in Git worktrees, native Model Context Protocol (MCP) support, and a low API price of $1.00 in / $2.00 out per 1M tokens. The single sentence a buyer needs: it is a credible, cheap coding agent whose 70.8% SWE-bench Verified trails Claude — a strong second tool for cost-sensitive teams (IP-sensitive teams should turn code-data retention off or enable Zero Data Retention first), not yet a top-tier-quality replacement. Provider: xAI. Released: 2026-05-20. Status: GA. Context: 256K tokens. Max output: 256K tokens. Modalities: text + image in, text out. Knowledge cutoff: November 2024. Headline price: $1.00 / $2.00 per 1M tokens.
/privacy or /settings or enable team-wide Zero Data Retention (then no trace or code data is retained); at first use the CLI asks whether xAI may retain data to improve the product and model.| Benchmark | Score | Source |
|---|---|---|
| SWE-bench Verified | 70.8% | xAI internal harness (inherited from grok-code-fast-1, which redirects to Grok Build 0.1)2026-05-20T00:00:00.000Z |
Six personas, six verdicts — the same panel that reviews every product on TopReviewed.
“Cheap, with retention controls that ease the IP objection — but code still reaches xAI, and at v0.1 it's a second tool, not a Claude Code replacement.”
Strategically, Grok Build 0.1 answers the top CTO objection to coding agents — shipping proprietary source to a cloud LLM — less fully than its launch coverage claimed: xAI's security FAQ says the CLI retains code data unless you turn code-data retention off in /privacy or /settings or enable team-wide Zero Data Retention, so code still reaches xAI. With those controls set it is usable for IP-sensitive work, but not for codebases that legally can't go to the cloud. The 70.8% SWE-bench Verified is competitive-not-leading, and v0.1 maturity means fewer integrations and rough edges. The sensible posture is "second tool in the belt": use it for cost-sensitive, well-scoped work, keep Claude Code as primary elsewhere. Vendor risk is the usual xAI profile (thin disclosure, SOC 2 as the only stated certification); lock-in is low via OpenAI-compatible API. The X-ecosystem angle does not meaningfully extend to coding.
“xAI is now competing across the full developer-tools surface — but its data-sovereignty wedge is thinner than launch coverage claimed; price is the real one.”
In dev-tools market terms, Grok Build signals xAI competing beyond chat into the coding-agent category Anthropic has led for a year. The claimed differentiation was local-first data sovereignty, but xAI's security FAQ says the CLI retains code data unless you turn code-data retention off in /privacy or /settings or enable team-wide Zero Data Retention, so the wedge is a set of retention controls rather than code that never leaves the machine. Native MCP support rides the open-tooling wave. Market timing is late (Claude Code and Codex are entrenched), and price is now the clearer wedge. The weakness is the v0.1 reality: a sharp positioning story needs the product maturity to back it, and right now the integrations and benchmark proof lag the narrative.
“At $1/$2 it's a fraction of Claude Sonnet or Opus per token — the catch is retries on hard tasks can eat the savings.”
The unit economics are strong. At $1.00 / $2.00 per 1M tokens, Grok Build is materially cheaper than Claude Sonnet 4.6 ($3/$15) and roughly 10x cheaper than Opus 4.7 per token — meaningful for coding agents that burn tens of millions of output tokens per project. The CLI bundled into SuperGrok ($30/mo) or X Premium+ ($40/mo) undercuts stacking Cursor + Claude Code subscriptions. The financial caveat: lower benchmark quality means more retries and more developer-supervision time on hard problems, which can quietly erode the per-token savings. For routine refactors and well-scoped tasks, the economics clearly favor Grok Build; for hard, novel problems, factor in the human-supervision overhead.
“Plan mode and 8 worktree sub-agents are a genuine win — the CLI just feels less polished than Claude Code, and 256K bites on big repos.”
For builders, the standout UX is plan mode (approve a step list before any mutation) and parallel sub-agents isolated in Git worktrees, which make multi-file refactors fast and reviewable. Native MCP support plugs into the growing tool ecosystem, and function calling / structured outputs are solid via the OpenAI-compatible interface. The friction: the CLI is less polished than Claude Code — fewer editor integrations and plugins — always-on reasoning means waiting on each action, and the 256K context forces manual context selection on real monorepos that a 1M-context tool avoids. For well-scoped tasks it's productive; for sprawling repos it asks more of the developer.
“As a daily coding driver it's serviceable and cheap, but I still reach for Claude Code on anything hard — and I feel the reasoning pause.”
For a developer living in the CLI day to day, Grok Build is serviceable and notably cheap, with plan mode adding a reassuring approval step before edits. On routine tasks it ships fine. But on hard problems the quality gap to Claude shows, the always-on reasoning pause on every action is noticeable, and the smaller context means more time spent curating what the agent sees. For proprietary code, turning off code-data retention in /privacy is worth doing on day one. As an everyday tool it earns a spot in the rotation; as the single tool for all coding, most heavy users will still keep Claude Code alongside it.
“One self-reported SWE-bench number on xAI's own harness, no other benchmarks, v0.1 — the local-first story doesn't hold, and the quality story is unproven.”
Adversarially, Grok Build 0.1's evidence base is thin even by xAI standards: a single headline benchmark (70.8% SWE-bench Verified) measured on xAI's own internal harness rather than an independent run, and aggregators showing zero sourced evals. The 70.8% also trails Claude Sonnet, so the one number on offer is not a winning one. v0.1 versioning is honest signaling that this is early. The local-first claim, once the strongest part of the pitch, does not survive xAI's own security FAQ: the CLI retains code data unless you turn that off or enable Zero Data Retention. But "credible Claude Code competitor" rests largely on positioning, not on independently verified coding quality, and the November 2024 cutoff is a real handicap for current frameworks.
/privacy) or with team-wide Zero Data Retention.The full research notes behind this review — verified against primary sources.
Base model internals are undisclosed (unknown), as with the rest of the Grok line. What's documented is the agent system: a 256K-token context (the smallest in the current Grok lineup), 256K max output, always-on reasoning, plan-mode execution gating, up to 8 parallel sub-agents isolated in Git worktrees, and native MCP tool support. The CLI runs on the developer's machine while the model runs on xAI's API, and xAI's security FAQ says the CLI retains code data unless you turn code-data retention off in /privacy or /settings or enable team-wide Zero Data Retention. The SWE-bench Verified number (70.8%) is inherited from grok-code-fast-1, which redirects to Grok Build 0.1 after the May 15 retirement.
/privacy, or team-wide Zero Data Retention) are concrete safety controls developers can rely on.| Benchmark | Score | vs Predecessor | vs Top Competitor | Source |
|---|---|---|---|---|
| SWE-bench Verified | 70.8% | First xAI dedicated coding model (via grok-code-fast-1 lineage) | Below Claude Sonnet 4.6 (72.7%); far below Claude Opus 4.7 (87.6%) | xAI internal harness, via coverage |
(HumanEval, LiveCodeBench, Aider Polyglot, and Terminal-bench were not available at verification time; BenchLM and benchmark aggregators show "0 sourced benchmarks" pending public evals for this v0.1 model. SWE-bench Verified is the only headline figure xAI has put forward, and it is from xAI's own harness rather than an independent run. Nothing invented to fill rows.)
Output throughput is not published, and always-on reasoning slows time-to-first-token (consistent with the rest of the Grok line). For an interactive coding CLI, the practical effect is that each agent action involves a reasoning pause before output — more reliable for multi-step tasks, but slower-feeling than a non-reasoning completion model. Latency tier: slow. Parallel sub-agents partly offset this on multi-file work by running concurrently.
| Surface | Cost | Notes |
|---|---|---|
| API input | $1.00 / 1M tok | docs.x.ai canonical (some trackers show $0.20) |
| API output | $2.00 / 1M tok | docs.x.ai canonical (some trackers show $1.50) |
| Cached input | $0.20 / 1M tok | 80% discount on cache reads |
| CLI (Grok Build) | bundled | Included in SuperGrok ($30/mo) and X Premium+ ($40/mo) |
| Heavy agentic tier | ~$300 / mo | SuperGrok Heavy / a separate SuperHeavy ($299/mo, ~$99/mo six-month intro promo reported) |
| Free tier | none | API and subscription only |
| Rate limits | tiered by spend/plan | Per docs.x.ai |
Pricing note (v1 discrepancy retained): some third-party listings show $0.20 in / $1.50 out for Grok Build 0.1; xAI's docs.x.ai card is canonical at $1.00 / $2.00 / $0.20 cached. Use the docs figures.
Proprietary model, cloud-hosted for inference, with a locally-running CLI; xAI's security FAQ says the CLI retains code data unless you turn code-data retention off in /privacy or /settings or enable team-wide Zero Data Retention. No open weights, no self-hosting of the model itself. Available via the x.ai API (OpenAI/Anthropic-SDK compatible), resold on OpenRouter, and usable inside third-party coding surfaces such as Kilo Code. Not a confirmed Azure AI Foundry SKU. Rate limits are spend/plan-tiered.
The headline governance controls are data settings: xAI's security FAQ says the CLI retains code data unless you turn code-data retention off in /privacy or /settings or enable team-wide Zero Data Retention (then no trace or code data is retained), and at first use the CLI asks whether xAI may retain data to improve the product and model. xAI states it never trains on API inputs or outputs without explicit permission, hence trains_on_inputs: false with data_optout_available: true. Plan mode adds an explicit approval gate before any file mutation, a concrete control against runaway autonomous edits. Beyond these, the family posture applies: no published safety framework, governance via Acceptable Use Policy, and SOC 2 Type 2 as the only certification xAI states (no HIPAA or ISO certification). Those retention settings mean code data does reach xAI; requests follow the standard xAI API data terms.
Python/TypeScript SDKs plus OpenAI/Anthropic-SDK compatibility; native MCP; resold on OpenRouter and usable in Kilo Code. Primary surface is the Grok Build CLI. Popularity is niche — a v0.1 entrant in a category led by Claude Code and Codex, with price as its clearest differentiator.
$1.00 in / $2.00 out per 1M tokens (cached $0.20) on the API; the CLI is bundled into SuperGrok ($30/mo) or X Premium+ ($40/mo), with heavy tiers around $300/mo. Some trackers show $0.20/$1.50 — trust docs.x.ai.
Yes, for inference on xAI's API. xAI's security FAQ says the CLI retains code data unless you turn code-data retention off in /privacy or /settings or enable team-wide Zero Data Retention; with Zero Data Retention no trace or code data is retained. At first use the CLI also asks whether xAI may retain data to improve the product and model.
Lower. SWE-bench Verified 70.8% trails Claude Sonnet 4.6 (72.7%) and is far below Opus 4.7 (87.6%). Strong for scoped tasks, not for top-tier ceilings.
The agent proposes a step list and waits for your approval before mutating files — a safety gate against runaway edits.
With effort. 256K context is the smallest in the Grok lineup, so monorepos need disciplined context selection; a 1M-context tool is easier there.
Native MCP support, the x.ai API (OpenAI/Anthropic-SDK compatible), OpenRouter, and third-party surfaces like Kilo Code. Editor-plugin coverage is thinner than Claude Code at v0.1.
It was retired 2026-05-15 and now redirects to Grok Build 0.1; the 70.8% SWE-bench figure traces to that lineage.
Higher SWE-bench ceiling (72.7% / 87.6%) and a more mature CLI/integrations; pricier.
Broad IDE integration and disclosure; pricier.
Open-source, bring-your-own-model CLI; no bundled agent model.
Primary references used to verify this review.
Does not train on API inputs by default
Last verified 2026-09-21