VibeFuse is a Fuse Intelligence product.

GROK BUILD

Grok Build: xAI's Terminal Agent on a Subscription Meter

Grok Build is xAI’s terminal coding agent — launched in early beta on May 14 2026 restricted to SuperGrok Heavy, then opened to every SuperGrok ($30/mo) and X Premium+ ($40/mo) subscriber on May 25. There is no standalone Grok Build plan: the agent rides an xAI subscription, with the highest limits on SuperGrok Heavy at $300/mo. The engineering pitch is real — up to 8 parallel subagents, each isolated in its own git worktree, plan-mode-by-default approval gates, headless -p mode for CI, ACP support, and out-of-the-box compatibility with the Claude Code ecosystem (AGENTS.md, skills, hooks, MCP servers). The model underneath is grok-build-0.1: 70.8% SWE-bench Verified at $1/$2 per 1M tokens — cheap and fast, but roughly 17 points behind the frontier leaders with a 256K context window. It runs natively on Windows via a one-line PowerShell install, and the Rust source went public in July 2026. This page is the corrected record — plus the free path: run it (and every other vendor CLI) as a widget in VibeFuse, the first free widget-based AI harness — no harness meter, ever.

Why developers search for Grok Build in 2026

One command, three platforms

macOS and Linux: curl -fsSL https://x.ai/cli/install.sh | bash. Windows gets a native installer — irm https://x.ai/cli/install.ps1 | iex — no WSL required, with config landing in %USERPROFILE%\.grok\config.toml. Interactive sessions authenticate through a browser; headless and CI set XAI_API_KEY. grok inspect shows which config sources, skills, plugins, hooks, and MCP servers the agent picked up in the current directory, and grok -p "task" --output-format streaming-json runs it inside scripts.

The worktree-isolation pitch

Grok Build’s signature design: large tasks fan out to up to 8 parallel subagents, each working in its own isolated git worktree, then the changes merge clean — dramatically less merge-conflict risk on multi-file refactors. Claude Code and Codex CLI spawn subagents per task but leave worktree management to you. Plan Mode is on by default: the agent proposes a numbered plan, you approve, comment, or rewrite it, and only then does anything touch your files — with every change surfacing as a clean diff.

Sold through social subscriptions

There is no Grok Build plan to buy — access is bundled: SuperGrok $30/mo, X Premium+ $40/mo (same AI plus X platform perks), SuperGrok Heavy $300/mo for the highest limits. At launch on May 14 2026 the only way in was SuperGrok Heavy; four days later xAI cut the entry price by roughly 90%. Third-party reviewers also reported a limited free tier of about 25 parallel agent runs per day (June 2026) — not documented on xAI’s own pages, so verify what your account shows. The API is the no-subscription alternative.

Open Rust, honest beta

The Rust source is public at xai-org/grok-build (mid-July 2026, roughly 4,500 stars in its first weeks), split into clean crates for the TUI, agent runtime, tools, and workspace layer. It reads your AGENTS.md, Claude Code skills/hooks, and MCP servers without changes — migration cost from a Claude Code setup is near zero. Caveats: Arena Mode (judge-ranked parallel outputs) is announced but not shipped, the 256K context is the smallest in the frontier-CLI field, and hands-on reviews call the beta rough around long-horizon builds.

What Grok Build costs now (September 2026)

Path Cost What you get Fine print
Via SuperGrok $30/mo Grok Build bundled with full Grok — standard agent limits The lowest-cost first-party terminal agent subscription in the field
Via X Premium+ $40/mo Same Grok Build access plus X platform perks Marginal cost is zero if you already pay for X Premium+
Via SuperGrok Heavy $300/mo Highest agent limits + Grok 4 Heavy + up to 16 parallel agents The only tier at launch (May 14–24 2026); no mid-tier exists between $40 and $300
Free tier $0 Reported ~25 parallel agent runs/day (third-party review, June 2026) Not documented on xAI’s own pages — verify in your account before counting on it
API: grok-build-0.1 $1 in / $2 out per 1M The same coding model, pay-as-you-go — cached input $0.20/M, 100+ tokens/sec 1,800 RPM / 10M TPM default; 256K context; formerly grok-code-fast-1
VibeFuse harness $0, forever Runs the Grok Build CLI — and Claude Code, Codex, Gemini CLI, Cursor — as widgets over your repos Your vendor billing, your model choice per task, no harness meter

Verified against xAI’s Grok Build announcement and API notes, the xAI docs, PCMag’s launch coverage, and independent pricing trackers (September 2026). Subscription prices moved twice in 2026 — re-verify before budgeting.

Grok Build vs Claude Code vs the harness shape

What matters Grok Build CLI Claude Code VibeFuse
License Rust source public (xai-org/grok-build, July 2026); the service is account-tied Proprietary Free download, free license key
Platforms Native Windows installer (PowerShell), macOS, Linux Native Windows (PowerShell/WinGet), macOS, Linux Windows-first harness
Pricing shape Subscription-bundled ($30/$40/$300) or API meter ($1/$2 per 1M) Pro $20/mo subscription with 5-hour windows; Max $100–$200 $0 — your vendor accounts set the volume
Default model grok-build-0.1 (70.8% SWE-bench Verified, 256K context) Claude Opus/Sonnet only Whatever agent widget you run — mixable per task
Benchmarks 70.8% SWE-bench Verified — ~17 points behind the Claude/Codex leaders Frontier lead on public verified suites (87–89%) N/A — the harness runs the same agents you would benchmark
Agent architecture Up to 8 parallel subagents, each in its own git worktree; plan mode default Subagents spawned per task; worktrees manual Canvas of official vendor CLIs — each keeps its own architecture
Ecosystem carry-over AGENTS.md, skills, hooks, MCP servers load unchanged; ACP for editors The ecosystem everyone else copies Runs the official CLIs — your existing setup carries over intact
Economy Subscription meter or token meter Subscription or API Open-source marketplace: sell widgets, skills, styling packs for revenue share

Be honest: where Grok Build still trails

Credit first where due: worktree isolation is the most distinct architecture decision in the category — eight parallel subagents that never collide, with plan-mode approval gates before anything touches your files, and near-zero migration cost from a Claude Code setup. The honest gaps: grok-build-0.1’s 70.8% SWE-bench Verified trails the frontier leaders (Claude Code at 87–89%, GPT-5.5 Codex around 83) by roughly 17 points, and hands-on reviews consistently describe it as the value pick for scaffolding and bulk generation — not the reliability pick for long autonomous builds. The 256K context window is the smallest in the frontier-CLI field (Claude Code stretches to an effective 1M; Grok 4 itself carries 2M — the coding model traded context for cost and latency). Arena Mode — the judge-ranked parallel-output feature from the launch pitch — was still unshipped months into the beta. And the subscription bundling cuts both ways: there is no way to buy Grok Build alone, so the $30 floor is also a floor, and the free tier (if your account shows one) is undocumented. If you want verified frontier quality on complex refactors, Claude Code remains the safer premium default; if you want the cheapest first-party parallel agent and already pay for X or Grok, Grok Build is free upside — and inside VibeFuse it runs next to every other vendor’s official CLI, so one vendor’s rate limit never stops the canvas.

Cheap parallel scaffolding

Eight worktree-isolated subagents make Grok Build the strongest first-party pick for bulk generation: scaffolding new modules, sweeping independent files, A/B-testing approaches. The three-stage plan-search-build flow plus plan-mode approval keeps the blast radius small. For read-heavy audits and codebase summaries it is fast and, on the API, pennies.

Mind the context and the meter

256K context fills fast on large repositories — split big refactors into per-directory tasks instead of feeding the whole tree. On subscriptions, usage counts against your SuperGrok/X weekly pool, so parallel agent runs burn allowance quickly; on the API, enable prompt caching ($0.20/M cached input) since agent loops re-send large prompts every turn. grok inspect before a session tells you exactly which skills, hooks, and MCP servers will run.

When to pick which

Cheapest first-party parallel agent, already on X or SuperGrok: Grok Build. Verified frontier quality on long-horizon builds: Claude Code. Free MIT tooling pointed anywhere: Kimi Code. Refusal to marry any one meter: run them all as widgets in VibeFuse — Grok for cheap parallel scaffolding, Claude for the high-stakes builds, on one free canvas. They are different meters for different jobs, not rivals for one.

Also compare the Muse Code record, the Qwen Code record, the Kimi Code record, the Codex CLI vs Claude Code breakdown, the Cursor CLI alternative, the Copilot CLI alternative, the AI agent harness guide, and the best vibe coding tools.

Grok Build FAQ

What is Grok Build?

Grok Build is xAI's terminal coding agent, launched in early beta on May 14 2026 for SuperGrok Heavy subscribers and opened to all SuperGrok (\$30/mo) and X Premium+ (\$40/mo) subscribers on May 25 2026. You install it with one command (curl -fsSL https://x.ai/cli/install.sh | bash on macOS/Linux, irm https://x.ai/cli/install.ps1 | iex on Windows), run grok in a project directory, and it plans, edits, and validates multi-file changes. Its distinguishing features are up to 8 parallel subagents each isolated in its own git worktree, plan mode on by default (nothing touches your files until you approve the plan), headless -p mode for scripts and CI with streaming JSON output, Agent Client Protocol support for editors, and out-of-the-box compatibility with the Claude Code ecosystem - AGENTS.md, skills, hooks, and MCP servers load unchanged. The Rust source is public at xai-org/grok-build (July 2026).

Is Grok Build free?

There is no standalone Grok Build plan - access is bundled with xAI subscriptions: SuperGrok at \$30/mo, X Premium+ at \$40/mo, or SuperGrok Heavy at \$300/mo for the highest limits. If you already pay for SuperGrok or X Premium+, the agent is free upside on a plan you have. Third-party reviewers also reported a limited free tier of about 25 parallel agent runs per day (June 2026) - it is not documented on xAI's own pages, so verify what your account actually shows. The no-subscription path is the API: grok-build-0.1 at \$1 per 1M input and \$2 per 1M output, pay as you go.

How much does Grok Build cost per month?

The cheapest bundled path is SuperGrok at \$30/mo - the lowest first-party terminal-agent subscription in the field. X Premium+ costs \$40/mo with the same agent access plus X platform perks, and SuperGrok Heavy costs \$300/mo with the highest limits. There is no mid-tier between \$40 and \$300, so if SuperGrok's limits are not enough the next step is steep. Compare Claude Code Pro at \$20/mo and Codex included with ChatGPT Plus at \$20. On the API, budget math: agent loops re-send large prompts every turn, so cached input at \$0.20 per 1M is where the real savings live; below roughly 85 agent turns per day, metered API billing beats the \$30 subscription.

What is the grok-build-0.1 model?

grok-build-0.1 is the coding model that powers the Grok Build CLI, released on the xAI API in public beta on May 29 2026 (formerly grok-code-fast-1). It scored 70.8% on SWE-bench Verified - solid but roughly 17 points behind the Claude Code and Codex frontier leaders - and trades context for cost and latency: 256K tokens of context (the smallest in the frontier-CLI field; Grok 4 itself carries 2M), 100+ output tokens per second, and pricing of \$1 per 1M input / \$2 per 1M output / \$0.20 per 1M cached input. Default rate limits are 1,800 requests per minute and 10M tokens per minute. The same model also runs in Cursor, Kilo Code, OpenCode, and any OpenAI-compatible agent harness.

How do the worktree subagents work?

For larger tasks Grok Build delegates work to up to 8 specialized subagents that run in parallel, each inside its own isolated git worktree, so parallel edits never collide and changes merge clean - the most distinct architecture decision in the terminal-agent category, and something Claude Code and Codex CLI do not ship (their subagents spawn per task with worktree management left to you). Each subagent follows a three-stage plan-search-build flow. Plan mode is on by default: Grok Build proposes a numbered plan, you approve, comment, or rewrite it, and only then does execution begin - every change surfaces as a clean diff. Deep worktree integration also lets you launch subagents in worktrees you choose.

Does Grok Build work on Windows?

Yes, natively - no WSL required. Windows installs with one PowerShell command (irm https://x.ai/cli/install.ps1 | iex) and config lands in %USERPROFILE%\.grok\config.toml; macOS and Linux use the curl installer. Interactive sessions authenticate through a browser, and headless or CI usage sets XAI_API_KEY. One caveat for contributors rather than users: the open Rust tree's Windows builds are best-effort and not tested by the maintainers - the shipped installer is the supported Windows path. Run grok inspect after setup to confirm which config sources, skills, plugins, hooks, and MCP servers the agent discovered in your project.

Grok Build vs Claude Code - which should you pick?

They are different meters for different jobs. Quality: grok-build-0.1 scores 70.8% on SWE-bench Verified against roughly 87-89% for Claude Code - about 17 points behind, and hands-on reviews consistently call Grok Build the value pick for scaffolding and bulk generation rather than the reliability pick for long autonomous builds. Price: \$30/mo via SuperGrok vs Claude Code Pro at \$20/mo (or Max at \$100-\$200). Context: 256K vs an effective 1M. Architecture: Grok Build's 8 worktree-isolated parallel subagents and default plan mode vs Claude Code's per-task subagents. Ecosystem: both read AGENTS.md and MCP servers, so migration is cheap either way. Frontier quality on complex refactors: Claude Code. Cheapest first-party parallel agent, especially if you already pay for X or SuperGrok: Grok Build.

Can I run Grok Build inside VibeFuse?

Yes. VibeFuse is the first free widget-based AI harness: it runs the official Grok Build CLI - alongside Claude Code, Codex CLI, Gemini CLI, Cursor, and any Model-API agent - as widgets over your real repositories on Windows. The harness costs \$0 with no usage meter: your xAI subscription or API key does the billing, and you switch models or vendors per task instead of being locked to one meter. When a quota wall or rate limit hits one widget, route the task to another vendor's CLI on the same canvas. VibeFuse also runs an open-source marketplace where creators sell widgets, skills, and styling packs for revenue share - pair it with VocalFuse for local voice dictation while you build.

Run Grok Build — and everything else — on one free canvas

Download VibeFuse free, register for a free license key, and run Grok Build, Claude Code, Codex CLI, Gemini CLI, Cursor — and any Model-API agent — as widgets over your repositories on Windows. $0 harness, no usage meter, your vendor accounts, code stays local. Pair it with VocalFuse voice if you dictate while you build.

Explore related guides