TL;DR: Grok Build ships a genuinely novel parallel-agent architecture — 8 subagents, isolated Git worktrees, plan-before-execute. The problem is grok-build-0.1’s 70.8% SWE-Bench score, which trails Codex CLI (88.7%) and Claude Code (87.6%) by 17 points. If you already pay SuperGrok or X Premium+, activate it immediately. Paying cold cash just for Grok Build doesn’t add up yet.

	Grok Build	Claude Code	Codex CLI
Best for	Parallel-heavy refactors, SuperGrok subscribers	Deep autonomous multi-file tasks	Fast task completion on big codebases
Entry price	$30/mo (SuperGrok)	$20/mo (Claude Pro)	$20/mo (ChatGPT Plus)
SWE-Bench Verified	70.8%	87.6%	88.7%
The catch	17-pt benchmark gap vs the leaders	Token costs climb fast at Max tiers	Hard usage caps on Plus tier

Honest take: Don’t pay $30/month just to access Grok Build — Codex CLI via ChatGPT Plus is cheaper and 18 points better on the benchmark that matters. If you’re already a SuperGrok or X Premium+ subscriber, it’s solid incremental value you’re leaving on the table.

What Grok Build actually is

xAI launched Grok Build on May 14, 2026 as its first terminal-native coding agent — a direct challenge to Claude Code, which has owned the agentic CLI niche since early 2025, and to OpenAI Codex CLI, which has been closing the gap all spring. The beta launched initially for SuperGrok Heavy subscribers only, then opened to all SuperGrok ($30/mo) and X Premium+ ($40/mo) accounts on May 25, 2026.

The model underneath is grok-build-0.1: 256K token context, 100+ tokens/second throughput, $1.00 per million input tokens and $2.00 per million output tokens through the xAI API. Cached prompts cost $0.20 per million input tokens. This is xAI’s first model trained specifically for agentic coding tasks — it’s not Grok 4 with a coding system prompt, it’s a separate fine-tune optimized for plan execution, tool calling, and multi-step code changes.

What makes Grok Build structurally different from both competitors is the parallel subagent layer. You get up to 8 agents, each running in its own isolated Git worktree. Claude Code and Codex CLI handle tasks sequentially by default. On the right workload — large migrations, test backfills, parallel feature branches — that parallelism translates to real wallclock savings, not benchmark numbers.

How the agent actually runs

Plan mode is the entry gate. Run grok-build "migrate all API endpoints to the v2 schema" and the agent writes a structured plan — file by file, step by step — before touching anything. You approve the full plan, comment on individual steps, or rewrite it entirely. Only after you sign off does execution begin. This is the same protect-before-act pattern Claude Code and Cursor’s Agent mode use, and it’s the right default for production codebases.

For tasks that parallelize cleanly, the multi-agent mode spawns up to 8 workers, each in a separate Git worktree — a full repo checkout on a separate branch. Agents can explore, write code, run tests, and modify files without interfering with each other. When they finish, you get a diff per agent. You pick what to keep, merge what fits, discard what doesn’t. For a task like “write unit tests for every exported function in this package,” that’s 8 agents covering ground simultaneously rather than a single agent running for twice as long.

Headless mode uses the -p flag — no interactive prompts, pipeline-friendly. Set GROK_CODE_XAI_API_KEY from console.x.ai and Grok Build runs inside any CI/CD job. MCP (Model Context Protocol) and ACP (Agent Client Protocol) both work identically in headless mode, so existing integrations for Claude Code carry over to Grok Build without rewiring. For the MCP ecosystem overview, see the 7 MCP servers worth installing in Cursor, Claude Code, and Windsurf in 2026.

Agent Dashboard and Plugin Marketplace (June 2026): xAI shipped an Agent Dashboard in June 2026 — a centralized interface for tracking multiple simultaneous Grok Build sessions, reviewing per-session logs, and terminating runaway agents without closing the terminal. For developers running Grok Build across multiple repos in parallel (the primary use case for the 8-agent mode), the dashboard eliminates manual session tracking across separate terminal windows. The same update added a /marketplace command, opening a plugin directory where community-contributed MCP servers can be browsed and installed in one step. As of the June 2026 release the marketplace is small — fewer than 50 plugins versus Claude Code’s hundreds of community MCP servers — but the infrastructure is now in place. If the plugin ecosystem scales, it narrows one of Grok Build’s remaining gaps against the more mature tools.

Installation is a single command: npm install -g grok-build.

The benchmark problem

70.8% on SWE-Bench Verified is not a failure for a 0.1 model. In absolute terms, an agent that autonomously resolves 70.8% of real-world production GitHub issues is an engineering achievement.

The issue is who you’re sharing a market with. OpenAI GPT-5.5, the model powering Codex CLI, sits at 88.7% on SWE-Bench Verified. Claude Opus 4.7, the Claude Code engine, is at 87.6%. Grok Build is 17 percentage points behind both leaders on the benchmark that most directly predicts real-world autonomous task completion.

SWE-Bench Verified uses actual GitHub issues from production open-source repositories — not synthetic prompts or cleaned-up toy tasks. The gap translates to this: on the hardest class of tasks (tricky bug fixes, multi-file refactors with hidden dependencies, test failures with non-obvious root causes), Grok Build fails more often, and those failures cost you recovery time. That time is the real cost.

The 256K context window adds a second constraint. Claude Code on Max plans gives you 1M+ token context. For medium-sized apps, 256K is fine. For a 300K-line service layer, or for legacy projects where loading full context matters for accurate suggestions, Grok Build will truncate — and it doesn’t always announce when it does. Silent truncation produces plausible-but-wrong suggestions that fail at review time.

Speed is genuinely good: 100+ tokens/second makes plan generation and iteration feel snappy compared to some heavier models. But throughput doesn’t cover accuracy on production code tasks.

Pricing: the four ways in, and two that make sense

SuperGrok — $30/month. This is the sweet spot. SuperGrok unlocks Grok Build alongside Grok 4 access across web, mobile, and API. If you already pay SuperGrok for Grok’s reasoning features or for X integration, Grok Build costs you nothing extra. This is the only scenario where Grok Build is unambiguously the right call today — the incremental value is real, the incremental cost is zero.

X Premium+ — $40/month. Same Grok Build access as SuperGrok, bundled with a full X platform subscription. Same logic: if you’re paying this for X anyway, activate Grok Build. You’re not paying for a coding agent; you’re getting one for free with your existing subscription.

xAI API — $1.00/M input, $2.00/M output. The API pricing is competitive for high-volume pipelines that can tolerate the accuracy gap. Claude claude-opus-4.7 API rates are substantially higher. If you’re running automated code generation or test writing pipelines at scale where the 17-point benchmark gap is an acceptable trade for cost, grok-build-0.1’s API pricing works in its favor.

SuperGrok Heavy — $300/month. Designed for maximum Grok throughput across the platform. Includes Grok Build, but if you’re spending $300/month primarily to access a coding agent, Codex CLI ships included with ChatGPT Plus at $20/month with a better SWE-Bench score. The math doesn’t hold.

For a current breakdown of Claude Code’s own plan tiers — Pro at $20/month, Max 5x at $100/month, Max 20x at $200/month — see the Claude Code review 2026.

Where Grok Build wins head-to-head

The parallel Git worktree architecture is the clearest structural differentiator in the agentic CLI market right now. Neither Claude Code nor Codex CLI offers 8-way parallelism with branch isolation as a native feature. For workloads that split cleanly — test generation, incremental migration, boilerplate creation across a large number of files — 8 simultaneous agents beat 1 sequential agent in wallclock time regardless of individual accuracy scores.

MCP compatibility is not a differentiator (Claude Code and Codex CLI both support it), but it means Grok Build slots into existing MCP infrastructure without rebuilding integrations. If your team has already wired up database MCP servers, git history tools, or browser automation for Claude Code, those connections work with Grok Build.

The API pricing is a genuine advantage for specific use cases. At $1.00/M input and $2.00/M output, grok-build-0.1 is among the most cost-effective options in the agentic coding model tier. For pipeline automation where budget matters more than maximizing single-task accuracy, that spread is real money at scale.

Where it breaks

Complex single-agent tasks. The 17-point SWE-Bench gap shows most clearly here. Debugging a subtle concurrency issue in a Go service, resolving a type error that propagates across a deep import chain, or making a non-obvious architectural refactor — these are exactly the tasks where the accuracy difference between 70.8% and 87.6% is decisive. You will fix more Grok Build outputs than Claude Code outputs on identical hard tasks. Budget that recovery time into your estimate.

Large codebases. A 256K context window fills up faster than expected in real projects. Grok Build will truncate context on larger repositories without always telling you. The result is suggestions that look right but miss a dependency introduced 50K tokens earlier in the codebase. On projects where full context loading is critical — legacy monorepos, large API surfaces with dense cross-references — the context limit is a hard ceiling.

Tasks requiring long background execution. Codex CLI’s cloud task infrastructure lets tasks run for hours in the background while you work on something else. Grok Build’s parallel agents are local-process based: your machine needs to stay online and active for the task duration. For overnight refactors or long-running analysis jobs, this is a practical constraint.

Codebase exploration without a clear task. Grok Build’s plan mode is built for defined tasks — “do X” — not for exploratory conversations about architecture or “explain what this service does before I change it.” Claude Code’s conversational depth and 1M+ context make it significantly better for understanding unfamiliar codebases before you start making changes.

For the direct benchmark comparison between Claude Code and Codex CLI — both of which currently beat Grok Build — see Claude Code vs OpenAI Codex CLI 2026.

Who should run Grok Build today

Yes, right now:

• You’re already paying SuperGrok ($30/mo) or X Premium+ ($40/mo) and haven’t activated Grok Build yet — it’s free value you’re leaving unused
• You have a specific parallel-heavy workload: test suite generation across a large file tree, incremental migration jobs that split cleanly, or simultaneous prototyping across 8 branches
• You’re running automated pipelines at scale where $1.00/$2.00 per million tokens undercuts your current API cost and the accuracy floor is acceptable for the task

Not yet:

• You’re spending new money just to access a CLI coding agent — Codex CLI via ChatGPT Plus is $10/month cheaper and 18 points better on the benchmark that predicts real-world task completion
• Your codebase is large enough that 256K context truncation will matter
• You need Claude Code’s long-horizon reasoning for architectural work or unfamiliar codebase exploration (Claude Code review 2026)

One note on the roadmap: xAI has confirmed Arena Mode — a planned feature where multiple agents compete on the same problem, with outputs ranked algorithmically before the developer reviews them. As of the May 2026 beta, Arena Mode is not live. The current parallel mode gives 8 simultaneous workers; Arena Mode would add automated output ranking on top. If it ships with meaningful accuracy improvements, the calculus changes. Plan based on what’s available today.

If you’re deep in the Claude ecosystem and want to push it further, the Claude Code Power User Kit covers CLAUDE.md setups, subagent orchestration, and token optimization strategies that apply whether you’re using Claude Code alone or alongside tools like Grok Build.

Frequently Asked Questions

Does Grok Build require an X/Twitter account? Yes. Grok Build access is bundled with SuperGrok ($30/month) and X Premium+ ($40/month), both of which require an X account. Developers who want API-only access can use grok-build-0.1 directly via the xAI API at console.x.ai — $1.00 per million input tokens, $2.00 per million output tokens — without a subscription.

How does Grok Build’s SWE-Bench score compare to Claude Code and Codex CLI? grok-build-0.1 scores 70.8% on SWE-Bench Verified. Claude Code (Claude Opus 4.7) scores 87.6%. OpenAI Codex CLI (GPT-5.5) scores 88.7%. The 17-point gap is meaningful on hard real-world tasks — autonomous completion rates will be noticeably lower on complex multi-file bugs or architectural changes.

Can Grok Build run in CI/CD pipelines? Yes. Use the -p flag for headless operation and set GROK_CODE_XAI_API_KEY from console.x.ai. MCP servers and ACP (Agent Client Protocol) work identically in headless mode. This makes Grok Build a drop-in option for pipeline automation where it was previously running Claude Code or Codex.

What does “8 parallel subagents in isolated Git worktrees” mean for a real project? Grok Build can spawn up to 8 agents, each checking out the repository into a separate Git worktree — a full copy of the repo on a separate branch. They work simultaneously without touching each other’s files. When they finish, you review each agent’s diff independently. The practical use case is parallelizing tasks that split cleanly: writing tests for 80 functions, migrating 8 service endpoints, or exploring 8 different implementation approaches before committing to one.

Is Arena Mode available now? Not in the May 2026 beta. Arena Mode — where multiple agents compete on the same task and a ranking layer evaluates their outputs before you see them — has been confirmed by xAI but has not shipped. Current parallel mode gives simultaneous execution; Arena Mode adds automated quality evaluation. Check the xAI release notes at docs.x.ai for availability.

Does Grok Build support local or self-hosted LLMs? No. As of June 2026, Grok Build requires the xAI API — there’s no option to route requests to a local model endpoint. The subscription tiers (SuperGrok, X Premium+) give you API credits for grok-build-0.1 specifically; you cannot substitute a self-hosted Qwen, Llama, or Mistral model the way you can with Claude Code (which supports Bedrock custom endpoints on enterprise plans) or with open-source CLI agents like OpenHands. Developers who want the parallel-agent worktree pattern with a self-hosted backend need to look at orchestrators like OpenHands with a local Ollama backend, or manually manage Claude Code worktrees against a local API. For developers evaluating the cost trade-off between cloud API costs and local GPU inference for coding workloads, runaihome.com’s GPU cost analysis has the breakeven math for several GPU tiers.

Sources

• Introducing Grok Build — xAI official announcement
• Grok Build 0.1 on API — xAI official announcement
• Pricing: Compare Grok Plans — xAI official pricing page
• xAI Launches grok-build-0.1 for Agentic Coding with a 256k Context Window — KuCoin News
• xAI Enters the Coding Agent Race With Grok Build — DevOps.com
• Codex vs Claude Code (May 2026): Benchmarks, Subagents & Limits Compared — MorphLLM
• Grok Build CLI: xAI Terminal Coding Agent with Plan Mode, Subagents, and Headless CI — Mervin Praison
• Grok Build: xAI’s First Coding Agent Has Eight Parallel Agents, a Privacy-First Architecture, and One Major Problem — sdd.sh
• Claude Code Pricing 2026: Plans, Token Costs, and Real Usage Estimates — Verdent Guides
• Codex rate card — OpenAI Help Center

Last updated May 29, 2026. Pricing and features change frequently; verify current state before purchasing.