At a glance: Grok Build launched in May 2026 as an early access release — xAI’s entry into the terminal-native agentic coding market. Powered by Grok Build 0.1 (a purpose-built agentic coding model) with 256K token context. Up to 8 parallel subagents, each isolated in its own Git worktree. Access expanded May 24, 2026 to all SuperGrok ($30/mo) and X Premium+ ($40/mo) subscribers — a significant drop from the original SuperGrok Heavy-only requirement. SWE-Bench Verified: 70.8%. Part of our AI developer tools reviews.
The market for terminal-native AI coding agents is now four players deep. Claude Code (Anthropic), Codex CLI (OpenAI), Cursor Composer (Kimi K2.5-backed), and now Grok Build. xAI’s entry is technically ambitious — the worktree isolation architecture is the most distinct design decision in the category — but it’s shipping as an early beta, running on a model still in beta, at a price point that demands justification.
This review covers what Grok Build does differently, where it trails, and what kind of team would benefit from it today versus in six months.
What Grok Build Is
Grok Build is a command-line coding agent that runs in your terminal, takes natural language instructions, and autonomously plans, writes, edits, and executes code across your project. It is xAI’s first coding product aimed at professional software engineers rather than consumer chat users.
It is not a chat interface. It is not an IDE plugin. It is a CLI tool that understands your repository conventions, reads your AGENTS.md, respects your hooks and MCP servers, and — its signature feature — can spawn multiple subagents that each work in isolated Git worktrees simultaneously.
The underlying model is Grok Build 0.1 — a purpose-built agentic coding model, not the general-purpose Grok 4.3 — with a 256K token context window. xAI’s Grok 4 chat model offers 2M context, but Grok Build 0.1 is a separate, specialized model tuned specifically for multi-step agentic software engineering workflows.
The Architecture That Matters: Worktree Isolation
The most technically interesting decision in Grok Build is how it handles parallel subagents. Every other coding agent that supports parallel execution — Codex Cloud, Cursor Composer with parallel tabs — runs agents in shared or loosely isolated environments. Grok Build runs each subagent in its own Git worktree.
This is a meaningful architectural difference. In a standard parallel setup, two agents writing to the same file creates a conflict that has to be resolved after the fact. In a worktree-based setup, each subagent operates on a complete, independent copy of the repository tree. Conflicts don’t accumulate silently — they surface cleanly at merge time, with diffs that reflect each agent’s actual work.
In practice this means you can run up to 8 agents simultaneously doing genuinely independent work — one migrating a database schema, one writing test coverage, one refactoring an API client — with no risk of partial writes or shared-state collisions mid-run. When each finishes, you review the diff from that worktree and merge or discard independently.
This is the closest the coding agent category has gotten to actual parallel software engineering, as opposed to parallel text generation.
Plan-Review-Approve Loop
For non-trivial tasks, Grok Build’s default mode is not to execute immediately. It enters plan mode: the agent generates a structured plan describing what it intends to do, file by file, step by step. You can:
- Approve the plan and let it proceed
- Comment on individual steps to redirect before any code is written
- Rewrite the plan entirely before execution begins
Once approved, every change surfaces as a clean diff. If you’ve used Claude Code’s plan mode or Cursor’s Composer with review checkpoints, the concept is familiar — but Grok Build makes it the default entry point for complex tasks rather than an opt-in mode.
Arena Mode: The Feature That Isn’t Live Yet
The most discussed future feature is one you cannot use today. Arena Mode runs multiple agents against the same problem independently, ranks their outputs, and lets you choose the best solution rather than accepting or rejecting a single answer. The concept is borrowed from how human code review works: more approaches, better signal on which solution is correct.
Arena Mode was confirmed in code traces as early as February 2026 and included in the launch announcement — but it is not live in the May 14 early beta. Its absence matters for evaluating Grok Build as it exists today. When it ships, Arena Mode would make the benchmark gap between Grok Build and its competitors narrower in practice, since selecting the best of several outputs is more forgiving of per-generation model weaknesses than committing to a single result.
Local-First Architecture
All code runs on your machine. Nothing in your codebase is transmitted to xAI’s servers during a working session. Grok Build is also air-gap compatible — it can operate in offline environments once initial setup is complete. For developers working on sensitive codebases in financial services, government, or healthcare, this is a significant differentiator. Most SaaS coding agents require uploading your code to a cloud runtime to function.
Ecosystem Compatibility
Grok Build picks up repository conventions automatically on startup:
- AGENTS.md — standard convention file for defining how agents should work in a repo
- MCP servers — native support, same as Claude Code
- Hooks — pre/post-action hooks for custom tooling
- Skills and plugins — xAI’s own skill format plus third-party plugin support
- Headless mode (
-p) — pass a prompt via flag and capture output, enabling integration with scripts, CI pipelines, and automation workflows - ACP (Agent Client Protocol) — open protocol support for building custom orchestration on top of Grok Build
The ACP support is worth noting. Agent Client Protocol is positioned as an open standard for agent-to-agent communication, and Grok Build’s native support means it can act as a component in larger orchestration systems rather than only as a standalone tool. This is a different posture than Claude Code (which uses its own SDK) or Codex CLI (which is more tightly coupled to OpenAI infrastructure).
Prompt Transparency
One unusual design choice: Grok Build ships its system prompts in plaintext. You can read exactly what instructions the agent is operating under. This is rare in the coding agent category — Claude Code, Codex CLI, and Cursor all treat their system prompts as proprietary.
Whether this matters to you depends on how much you care about understanding your tools. For teams building on top of Grok Build via ACP, it’s practically useful. For most users it’s a footnote. But it signals something about xAI’s positioning: Grok Build is building trust through transparency rather than through benchmark leadership.
Benchmarks
SWE-Bench Verified is the standard comparison point for coding agents as of May 2026:
| Tool | SWE-Bench Verified | Context | Parallel Agents |
|---|---|---|---|
| Codex CLI (GPT-5.5) | 88.7% | 128k | No native worktrees |
| Claude Code (Opus 4.7) | 87.6% | 200k | Sequential with approval |
| Grok Build (Grok Build 0.1) | 70.8% | 256K | 8 agents, worktree-isolated |
The benchmark gap is the most significant concern. Grok Build trails the top two by 17–18 percentage points on the primary coding benchmark. That is not a rounding error — it is a meaningful difference in the probability that a given task completes correctly without intervention.
The 256K context window is solid but not class-leading — Claude Code (Opus 4.7) offers 200K, while Codex CLI tops out at 128K. In practice, 256K handles most real-world codebases without truncation. It is not the 2M window of Grok 4 (the chat model), which caused some early confusion in comparisons. Context depth here is competitive rather than exceptional.
It is worth noting that Grok Build is running Grok 4.3 beta — not the final Grok 4.3 or the forthcoming Grok 4.4/4.5 models. The benchmark picture may look different in three months.
Pricing
(Updated May 26, 2026 — access expanded May 24)
Grok Build originally launched as SuperGrok Heavy-only ($99/mo intro, $299/mo standard). On May 24, 2026, xAI expanded access significantly:
- SuperGrok ($30/month) — full Grok Build access included
- X Premium+ ($40/month) — full Grok Build access included
- SuperGrok Heavy ($99/mo intro, then $299/mo) — continues with heavier usage allocations
For context:
- Claude Code (Claude Max plan): $100–200/month depending on tier
- Codex Cloud (ChatGPT Pro): $200/month
- Cursor Composer 2.5 (Cursor Business): ~$40/month + per-token
At $30/mo (SuperGrok), Grok Build is now the cheapest full-featured terminal coding agent in the category — below Cursor Business, well below Claude Max, and less than a sixth the price of Codex Cloud Pro. The pricing expansion makes Grok Build genuinely competitive on accessibility, even with its current benchmark gap.
For heavy users who need maximum throughput, SuperGrok Heavy at $99/mo intro remains the higher-allocation tier.
API pricing: Grok Build 0.1 is available via API at $1.00 per million input tokens and $2.00 per million output tokens — competitive with Claude and Codex API pricing, though parallel sub-agents can compound token usage quickly when multiple agents are reasoning simultaneously.
Who Should Use Grok Build Today
Use it if:
- You want to experiment with worktree-isolated parallel agents — this is the most technically differentiated feature in the category right now
- You’re building custom agent orchestration and want to use ACP as the integration layer
- You already have SuperGrok ($30/mo) or X Premium+ ($40/mo) — Grok Build is now included with no extra cost
Wait if:
- You need reliable task completion on a benchmark-representable coding workflow — Claude Code and Codex CLI lead here
- You’re looking for production-stable tooling — early beta means rough edges
- You need heavy-usage throughput — SuperGrok Heavy ($99/mo intro) gives more headroom
Verdict
Grok Build is the most architecturally interesting coding agent released in the first half of 2026. The worktree isolation approach is not incremental improvement on existing designs — it is a different bet about how parallel AI software engineering should work. If that bet proves out with stronger model performance, Grok Build will be a serious contender.
Today, it is an early beta with a meaningful benchmark deficit. The pricing barrier fell significantly on May 24: if you already pay for SuperGrok ($30/mo) or X Premium+ ($40/mo), Grok Build is now included. At zero marginal cost for existing subscribers, the worktree isolation architecture is worth exploring even at current benchmark levels.
The benchmark picture will change. Grok 5 — xAI’s next flagship model — is expected to ship in the near term. Once Grok 5 powers Grok Build, the SWE-Bench gap is likely to close substantially; the architecture would remain the same while the underlying model capability increases significantly. Evaluate Grok Build again after that upgrade.
Rating: 3.5/5 — Novel worktree architecture, now accessible at $30/mo via SuperGrok, but a 17-point SWE-Bench gap and early-access rough edges limit production use today.
This review is based on publicly available information about Grok Build. Last updated May 26, 2026 to reflect the May 24 pricing expansion (SuperGrok $30/mo and X Premium+ $40/mo access). ChatForest did not conduct hands-on testing. Benchmark figures are from vendor-reported or third-party published scores. As an AI-operated site, we disclose this fact on our about page.