A working review of Grok Build 0.1, xAI's agentic coding model. What it nails on speed and cost, where its scope stops, and who it actually fits.
Grok Build 0.1 is a fast, well-priced agentic coding model from xAI — the engine behind the Grok Build CLI, built for whole-project software engineering with plan-first execution, parallel sub-agents, and native MCP. Judged as what it is, a coding agent, it is a credible entrant against Claude Code and Codex, with strong throughput and a 256k context at $1/$2 per million tokens. It generates no media and publishes nothing, so score it on engineering, not content. As a version 0.1 its benchmarks are early and moving.
Most coverage of Grok Build 0.1 is some version of "xAI has a coding agent now," pasted over a pricing line. This review is not that. We build a content engine and we read model listings for a living, so the goal is to tell you what Grok Build is genuinely good at, where its scope honestly stops, and — because people arrive sideways — whether a coding model has any place in a creator's or founder's stack.
Short version up top: Grok Build 0.1 is a serious agentic coding model. It is xAI's coding-specific model, the engine behind the Grok Build CLI, and xAI opened it to developers via the API (slug grok-build-0.1) in public beta in late May 2026. It carries a 256k-token context window, accepts text and image input, and on Artificial Analysis's independent test of the June 2026 snapshot runs at roughly 104 output tokens per second with a sub-second time-to-first-token and an Intelligence Index of 40 — above the median for its price tier. API pricing is $1.00 per million input tokens and $2.00 per million output, with an 80% cache discount. For a fast coding agent, that is a strong package.
The honest catch is scope, and it is a category fact rather than a flaw. Grok Build is a coding model. It writes, edits, and debugs software; it generates no images, video, or audio, writes no brand copy, and publishes nothing. It is also early — a 0.1 release — so some circulating benchmark figures (a SWE-Bench Verified score in the low 70s, for instance) are reported by third parties rather than confirmed by xAI, and numbers at this stage move fast.
This review covers what Grok Build actually is in 2026, how its coding, speed, and cost hold up, where it is honestly the wrong tool, and who should use it versus who should keep looking.
Grok Build 0.1 is a proprietary coding model from xAI, trained specifically for agentic software engineering rather than general chat. It is the model that powers the Grok Build CLI — xAI's terminal coding agent — and is also exposed to developers through the xAI API under the slug grok-build-0.1. It accepts text and image input (so it can read a mockup or a screenshot as context), returns text, and carries a 256k-token context window large enough to hold a substantial codebase in view. Its weights are closed and its parameter count is undisclosed. What sets it apart in its category is speed and price: roughly 104 output tokens per second with a low time-to-first-token, at $1.00/$2.00 per million tokens with cached input billed 80% cheaper. The Grok Build CLI around it uses the now-standard agentic patterns — plan-first execution (it proposes a plan before editing files), parallel sub-agents that can each run in an isolated Git worktree, and native Model Context Protocol support for calling external tools. What it does not do is anything beyond engineering: no media generation, no captioning or design, no scheduler, and no publishing. It is a developer tool, in the same lane as Claude Code and OpenAI's Codex CLI.
The clearest fit is anyone whose output is software: developers and founders who want a fast, lower-cost terminal coding agent to write features, debug, and refactor across a real project; builders wiring custom automations or webhooks via MCP; and teams comparing CLI coding agents who want a credible, cheaper option to test against Claude Code and Codex. It is also a sensible reasoning layer for the analytical, code-shaped parts of a workflow. It is the wrong tool for someone whose actual output is published content — video, images, carousels, social posts — because producing and distributing that content is entirely outside what the model does. Non-technical creators who want a hosted, log-in-and-go experience should also look elsewhere; this is a CLI and an API.
| Dimension | Score | Why |
|---|---|---|
| Agentic coding (whole-project work) | 4.2 / 5 | Built for it, with plan-first execution and parallel sub-agents in Git worktrees. A credible CLI coding agent on the early evidence. |
| Speed / throughput | 4.6 / 5 | ~104 output tokens/sec with a sub-second time-to-first-token — fast for a reasoning-style coding model. |
| Context window | 4.3 / 5 | 256k tokens, enough to hold a large codebase or long files in view during a task. |
| Pricing / value (for coding) | 4.4 / 5 | $1/$2 per million tokens with an 80% cache discount is competitive for an agentic coding model. |
| Tooling / ecosystem (CLI, MCP) | 4.0 / 5 | Native MCP and a capable CLI, plus integrations across third-party coding tools. Young but well-shaped. |
| Openness / transparency | 2.5 / 5 | Closed weights, undisclosed parameter count, and as a 0.1 release some benchmarks are reported rather than xAI-confirmed. |
| Content / social media production | 1.0 / 5 | Not the product. No image, video, audio, captions, copywriting focus, or design output. |
| Multi-platform publishing | 1.0 / 5 | Grok Build produces code; it does not post. No scheduler, no platform integration. |
For what it is — an agentic coding model — Grok Build 0.1 is priced to compete. $1.00 per million input tokens and $2.00 per million output sits comfortably below the top-tier frontier coders, and the 80% cache discount on repeated input matters a lot for coding agents, which re-send large amounts of unchanged context (the same files, the same instructions) on every turn. Pair that with ~104 tokens/sec throughput and the cost-per-task for day-to-day engineering looks attractive.
The catch is the familiar one for any model: "cheap tokens" is not "cheap outcome." The price buys code generation. Turning that into anything user-facing — a launched product, and then the marketing around it — is work and tooling you supply. For a developer, that math is fine; the model is an input to a process you already run. For someone hoping a coding model is a content shortcut, the token price is the wrong line item entirely, because no amount of coding budget adds writing voice, media rendering, or publishing.
The honest framing on value: Grok Build is priced like efficient coding infrastructure, and on those terms it is a good deal. Judge it against other CLI coding agents, not against a content tool.
| Use case | Fit | Why |
|---|---|---|
| Writing, editing, and debugging software across a project | Strong | This is the model's entire purpose, and the agentic CLI patterns (plan-first, sub-agents, MCP) are built for exactly it. |
| A fast, lower-cost terminal coding agent | Strong | Its throughput and $1/$2 pricing make it a credible, cheaper alternative to test against Claude Code and Codex. |
| Building custom automations and webhooks | Strong | Native MCP and API access let it wire integrations — including the glue that feeds a content pipeline. |
| Reasoning over code-shaped or analytical problems | OK | It is a reasoning-style model, so it can help with logic-heavy analysis, though it is tuned for code specifically. |
| Writing on-brand copy, captions, or scripts | Weak | A coding model is not built for voice, and content has no single right answer to optimize toward. |
| Producing video, images, or carousels for social | Weak | No media generation of any kind. Entirely outside Grok Build's scope. |
| Scheduling and publishing across platforms | Weak | No publishing layer and no scheduler. It produces code, not posts. |
| A hosted, no-code tool for non-technical creators | Weak | It is a CLI and an API meant for engineers, not a log-in-and-go product. |
If you arrived at this review wondering whether Grok Build 0.1 can run your content operation, the honest answer is no — and that is a category point, not a criticism. Grok Build is a coding model: fast, well-priced, and built for agentic software engineering. It has no writing-voice layer, no renderer, no design system, and no scheduler, because it was never meant to be a content tool. Scoring it as a content engine would be unfair to a model that looks genuinely strong at its actual job.
Kompozy sits at a different part of the workflow, and for a builder the two are complementary rather than rival. Where Grok Build stops at shipped code, Kompozy turns an idea — or a release — into 18 content formats: persona and avatar video, carousels, quote cards, infographics, blogs, newsletters, and platform-native posts, held to one brand voice through a Persona Brief and scheduled across nine platforms plus email and blog. It runs that generation on managed Claude and OpenAI models, which are the right tools for open-ended writing, so there is nothing to operate. A practical pairing: let Grok Build ship the product and even the webhook that pipes your changelog into your pipeline, then let Kompozy produce and publish the marketing that release deserves. Use Grok Build for the engineering it is built for, and a content engine for the content.
Grok Build 0.1 is xAI's coding model, trained for agentic software engineering and serving as the engine behind the Grok Build CLI. It is available to developers via the xAI API under the slug grok-build-0.1, with a 256k-token context window and text plus image input.
For a fast, lower-cost agentic coding agent — yes, it is a credible entrant to test against Claude Code and Codex, with strong throughput and competitive pricing. It is not worth adopting for content production, because it generates no media, is not tuned for writing voice, and publishes nothing; for that you need a content engine on top.
Via the xAI API it is $1.00 per million input tokens and $2.00 per million output, with cached input at $0.20 per million — an 80% discount. Using it inside the Grok Build CLI may also be available through xAI subscription tiers.
No. It is a coding model and produces no images, video, audio, or social copy. To turn anything you build into published content you pair it with a content engine like Kompozy.
All three are terminal-native agentic coding agents. Grok Build is positioned as fast and lower-cost, with plan-first execution, parallel sub-agents in Git worktrees, and native MCP. The right pick depends on your stack and your own benchmarks; as a 0.1 release, treat head-to-head numbers as fast-moving snapshots.
Treat them carefully. Artificial Analysis publishes an independent Intelligence Index (40 for the June 2026 snapshot), but some widely cited figures like a SWE-Bench Verified score are reported by third parties rather than confirmed by xAI, and a 0.1 model's numbers can change between snapshots.
Kompozy, without question. Grok Build writes software; Kompozy generates video, images, carousels, blogs, and newsletters and publishes them across platforms. Use Grok Build to build the product — even the automation that feeds your pipeline — and Kompozy to produce and ship the content around it.