Grok Build Review 2026: xAI's Terminal Coding Agent vs Claude Code and Codex

xAI quietly slipped into the most crowded category in AI tooling this spring: the terminal-native coding agent. Grok Build, which entered early-access in May 2026 and opened up to all SuperGrok and X Premium+ subscribers on May 24, is xAI’s answer to Claude Code, Codex CLI, and the rapidly growing pile of CLIs vying to live in your repo.

Coming from xAI, the natural assumption was that Grok Build would be a Grok 4 wrapper with a fancy prompt. It is not. It is a from-scratch CLI built on grok-code-fast-1 — a model xAI trained specifically on programming content and real-world pull request data — with a worktree-based subagent architecture that is genuinely novel in this category, and Plan Mode turned on by default.

We have spent the past two weeks running Grok Build on the same kind of work we use to stress-test Cursor 3, Claude Code, and Codex CLI: multi-file refactors, dependency upgrades, test backfills, and long-horizon migrations across mid-size Python and TypeScript repositories. This review covers what is actually new, where it shines, where it stumbles, and whether it is worth swapping your daily driver.

The Short Version

Grok Build is the most architecturally interesting coding CLI to ship in 2026, but the model underneath is still beta-grade.

• SWE-Bench Verified 70.8% — solid, but trails Claude Code (Opus 4.8) by ~17–18 points and GPT-5.5 Codex by ~12 points.
• Up to 8 parallel subagents, each isolated in its own Git worktree — the most distinct design decision in the category.
• Plan Mode is on by default — Grok Build proposes, you approve, then it acts. Nothing touches your files unannounced.
• 256K context window — bigger than Codex CLI’s 128K, smaller than Claude Code’s effective 1M.
• Agent Client Protocol (ACP) support — Grok Build can be driven by any ACP-compliant client, making it embeddable in editors and CI systems.
• Pricing rolled into SuperGrok ($30/mo) and X Premium+ ($40/mo) — no per-token billing on the subscription tier.
• Privacy: code stays local. Repository contents are not transmitted off-device during a session.

If you already pay for SuperGrok or X Premium+, Grok Build is essentially a free upgrade and worth trying. If you do not, the case for paying $30/month only for the CLI is harder — Claude Code on Pro is a stronger primary tool today, and Codex is closer in raw capability.

What Is Grok Build?

Grok Build is xAI’s terminal-first agentic coding CLI. You install it, run grok build in a repo, describe what you want, and the agent reads files, runs commands, edits code, and iterates against your test suite — same general shape as Claude Code or Codex CLI.

What makes it different is how it does the work.

Grok Build treats your repository as the source of truth, then forks itself via Git worktrees whenever a task can be parallelized. Each subagent gets its own working directory, its own file mutations, and its own command shell. When the subagents finish, Grok Build reconciles their outputs and presents you with the merged result. This is the same insight that drives Claude Managed Agents and Dynamic Workflows in Opus 4.8, but Grok Build is the first general-purpose CLI to build the worktree primitive directly into the user-facing tool.

The second defining choice is Plan Mode by default. Most CLIs in this category will start editing the moment you describe a task. Grok Build first proposes a plan — a numbered list of steps, files to touch, and commands to run — and waits for you to approve, comment, or rewrite it. Only then does it begin. After two weeks of using it, the friction is real but the regret rate is dramatically lower than letting Codex CLI rip on a complex task.

Setup and First Run

Installation is a single command on macOS, Linux, or Windows (via WSL):

curl -fsSL https://grok.com/install | bash
grok auth

The auth flow opens a browser, links your X account, and drops a long-lived token into ~/.grok/config.toml. From there, grok build in any directory starts a session.

The first thing you see is the model picker. As of June 2026 there are three:

• grok-code-fast-1 — the default, fastest, recommended for day-to-day work.
• grok-code-1 — the heavier reasoning variant, slower, used when fast-1 punts.
• grok-4.3 — the general-purpose Grok model, available as a fallback.

Almost everything we tested ran on grok-code-fast-1. The model picker swap mid-session works, which is unusual — Claude Code requires a restart to change models.

Plan Mode in Practice

Here is what a Plan Mode interaction actually looks like. We pointed Grok Build at a mid-size FastAPI project and asked: “Migrate this codebase from SQLAlchemy 1.4 to 2.0, including the async session changes, and update the integration tests.”

Grok Build came back with a 14-step plan in roughly 25 seconds. Each step listed the files it intended to touch, the commands it would run, and — for non-trivial steps — a short rationale. We were able to:

1. Approve the whole plan with y.
2. Edit specific steps with e 7 to drop a step we knew was unnecessary.
3. Add a constraint (“do not modify alembic migrations”) via free-form text that Grok Build folded back into the plan.

After approval, execution kicked off and we watched the agent work through the steps in roughly the order proposed. When a test failed mid-plan, Grok Build paused and asked whether to debug the failure or skip the affected file — the kind of explicit checkpoint Claude Code only does when you set it up with hooks.

It is slower than just turning Claude Code loose. It is also dramatically harder to ruin your afternoon by accident.

Parallel Subagents and Worktrees

The headline feature is up to 8 parallel subagents, each isolated in its own Git worktree. We hit this hardest on a large test backfill: “Write missing pytest coverage for everything in src/services/ until coverage hits 85%.”

Grok Build planned, then split the work across 6 subagents, each assigned a sub-directory under src/services/. Each subagent ran in .grok/worktrees/agent-N/ — independent checkouts of the same branch. They wrote tests in parallel, ran them locally in their own worktrees, and only reported back to the main agent once their assigned slice passed.

Two things stood out:

• Conflict handling is surprisingly clean. When two subagents both touched conftest.py, the main agent presented the conflict, suggested a merge, and let us approve it. No silent overwrites.
• You see the parallelism in your filesystem. Worktrees are a real Git feature, so you can cd into .grok/worktrees/agent-3/ and look around if you want to understand what an agent did.

This is the kind of architectural choice that pays off as projects get larger. On a small refactor (3–5 files) you do not feel the benefit. On a coverage push across 200 files, the wall-clock difference vs. a single-threaded Claude Code session is roughly 4×.

Performance: The Benchmarks

xAI publishes Grok Build’s SWE-Bench Verified score as 70.8% on grok-code-fast-1. Independent runs from a few labs cluster between 68% and 71%, so it appears to be a real number, not a tuned one.

For context, here are the published numbers for the major coding agents we have reviewed in 2026:

Agent	Model	SWE-Bench Verified
Claude Code	Opus 4.8	88.6%
Codex CLI	GPT-5.5 Codex	~83%
Cursor 3 Agent	Composer / Opus 4.8	~85%
Grok Build	grok-code-fast-1	70.8%
GitHub Copilot Agent	Multi-model	~74%

That 17-point gap to Claude Code is not noise. In day-to-day use, you feel it on tasks that require holding many constraints in your head — large refactors, untangling implicit dependencies, fixing test failures that span layers. On simpler tasks (write this function, add this endpoint, generate these tests), the gap closes substantially and Grok Build’s speed advantage shows up.

Grok Build is fast. grok-code-fast-1 is, by xAI’s own framing, optimized for throughput. Token-for-token, our timing showed it roughly 1.5–2× faster than Claude Opus 4.8 in standard mode and ~1.2× faster than GPT-5.5 Codex.

The Agent Client Protocol

ACP is the under-the-radar interesting thing about Grok Build. Grok Build is the first major CLI to ship with native Agent Client Protocol support — a JSON-RPC over stdio standard that lets any ACP-aware host drive the agent.

What this means in practice:

• Editor integrations are trivial. Anyone can wrap Grok Build inside Zed, Neovim, or VS Code without xAI’s involvement.
• CI orchestration works out of the box. You can shell out to grok build --headless --plan-file plan.json from GitHub Actions, GitLab CI, or your in-house tooling.
• Multi-agent topologies are buildable. Because ACP is bidirectional, you can have a higher-level orchestrator drive Grok Build as one of its subagents.

This is the kind of decision that ages well. Claude Code uses an internal protocol that has been evolving, and Codex CLI’s headless mode is workable but not standardized. ACP support gives Grok Build a long tail of integration possibilities most competitors lack.

Pricing

Here is where Grok Build genuinely changes the math for some teams:

• SuperGrok ($30/month) — full Grok Build access, all models, generous usage limits.
• X Premium+ ($40/month) — same as SuperGrok plus the rest of the X Premium+ stack.
• SuperGrok Heavy ($300/month) — higher rate limits, priority queue, extended subagent caps.

There is no separate per-token billing on these tiers. If you already pay for SuperGrok for chat, Grok Build is included.

Compare to:

• Claude Code Pro: $20/month plus pay-per-use on heavy days (effectively $20–$200/mo for serious use)
• Codex CLI: API-billed at standard GPT-5.5 rates, no flat subscription
• Cursor Pro: $20/month, separate from any CLI usage

For an individual developer who would otherwise burn $80–$150/month on Claude Code or Codex, switching to Grok Build can roughly halve the monthly bill. The trade is the 17-point SWE-Bench gap.

Privacy, Security, and What It Sees

Grok Build runs the agent loop on your local machine and only sends model-bound payloads (your prompt, relevant context, tool-call results) to xAI’s inference endpoints. The repository itself is not uploaded.

This matches Claude Code and Codex CLI in posture. It is meaningfully better than cloud-only agents like the various web “build me an app” tools we covered in best AI app builders, where your entire codebase lives on someone else’s server.

There is a --no-network mode that restricts the agent to only running pre-approved commands and disables web fetches. Useful for working on regulated code, less useful for tasks that need to look up library docs.

Where Grok Build Falls Short

After two weeks, the rough edges:

1. The model is the bottleneck. Plan Mode and subagent isolation are excellent, but grok-code-fast-1 is still beta and noticeably worse than Opus 4.8 at sustained reasoning. On a complex task — say, “rewrite this state machine and make sure the new transitions preserve all invariants” — Grok Build will sometimes confidently propose a plan that misses an invariant. Claude Code, in our experience, catches it more often.

2. Tool ecosystem is thin. Claude Code has a maturing ecosystem of community skills, hooks, and integrations (see our Claude Managed Agents guide). Grok Build is new. The ACP support means the ecosystem could close fast, but right now there is not much to extend it with.

3. Worktrees confuse some Git GUIs. If you use a Git client that does not understand worktrees (older versions of SourceTree, some IDE Git panels), the .grok/worktrees/ directories show up as orphan checkouts. Cosmetic, but jarring.

4. Plan Mode is overhead on tiny tasks. Asking Grok Build to rename a variable is comically over-engineered. There is a --no-plan flag, but you have to remember to use it.

Grok Build vs Claude Code vs Codex CLI

For most readers, the decision is between Grok Build, Claude Code, and Codex CLI. Quick guide:

• Choose Claude Code if: the task is the work. You need the highest hit rate on complex, multi-file changes and you do not mind the higher monthly cost.
• Choose Codex CLI if: you live inside the OpenAI ecosystem, your team already standardized on the OpenAI API for everything, and you want a powerful CLI without subscribing to anything new.
• Choose Grok Build if: you already pay for SuperGrok, you value Plan Mode’s safety, your workload parallelizes well (lots of small tasks), and you can tolerate a model that is good-but-not-great on hard problems.

For most teams we work with, the practical answer is both. Use Grok Build as a cheap second-opinion CLI for exploratory work and parallelizable chores; reach for Claude Code when the task is high-stakes or genuinely complex. The CLI category is no longer a one-tool game.

The Verdict

Grok Build is not the best terminal coding agent on the market today. That title still belongs to Claude Code. But it is the most interesting one — worktree-based subagents and ACP support are real architectural advances that the rest of the category will likely copy within a year.

If you are already in the X ecosystem, install it today. If you are not, it is worth a 30-day SuperGrok subscription to see how Plan Mode and parallel subagents fit your workflow. Just do not expect it to replace Claude Code on the hardest jobs — at least not until grok-code-fast-1 graduates from beta and the gap on SWE-Bench narrows.

xAI shipped late to this party, but they did not show up empty-handed.