Grok Build CLI – xAI Enters the Terminal Coding Agent Market

xAI has launched Grok Build, a terminal agent for programming, as a direct competitor to Claude Code. For now, it’s only available to SuperGrok Heavy plan subscribers, but a head-to-head battle with Anthropic is on the horizon…

Grok Build is a direct competitor to Claude Code and OpenAI Codex CLI. xAI has decided that instead of building its own ecosystem, it will copy Anthropic’s. Literally. Grok Build reads AGENTS.md, supports MCP servers, and loads plugins, hooks, and skills in exactly the format introduced by Claude Code. If you’re already developing with Claude Code and want to try Grok Build, all it takes is a single curl command, and all your conventions will continue to work. This isn’t a coincidence—it’s a strategy.

Let’s take a closer look, because behind the marketing facade, there are a few things worth discussing. Including the question of whether xAI has appropriated the work of its competitors. Just to be clear, I haven’t tried Grok Build myself, because I don’t have the Heavy plan, and spending 300$ just to write an article seemed a bit much to me. So I’m drawing my information primarily from official sources and from tests and feedback within the community.

What is Grok Build and how to get it

Grok Build is an agent-based CLI tool that runs directly in the terminal as a TUI (text-based user interface). Installation is trivial: one curl command to https://x.ai/cli/install.sh and logging in with a SuperGrok Heavy account. I was a bit surprised that xAI went the route of “downloading a script from the internet and running it via the shell”—that used to be a security anti-pattern, but today it’s the standard. Times are changing.

Functionally, it’s an assistant for programmers that can read and edit code in a repository, run commands in the shell, propose plans for implementing larger tasks, and delegate sub-tasks to subagents. It targets professional developers working on more complex projects where simple code completion is no longer enough—you want an agent that can plan the entire task, examine the codebase, and only then start writing.

Availability is currently limited to SuperGrok Heavy subscribers. This is xAI’s most expensive plan, costing roughly $300 per month. Bloomberg describes the launch as xAI’s attempt to catch up with Anthropic in the field of programming agents, and that’s accurate.

Anthropic has a lead of about a year in this category, and Claude Code has become the de facto standard among senior developers. xAI has to make up that year.

xAI hasn’t officially named the model under the hood, but several sources point to Grok 4.3 beta with a 16-agent Heavy architecture and a 2-million-word context window. These details come from third-party reports, not an official xAI statement, so take them with a grain of salt. What is certain: xAI itself says that “through this early beta version, we will improve the model and product based on feedback.” In other words, both the model and the tool are still a work in progress.

Compatibility Strategy - Why xAI Is Copying Anthropic

Here’s something worth noting. Grok Build explicitly supports Claude Code conventions: AGENTS.md as the project manifest, MCP (Model Context Protocol) servers, plugins, hooks, and skills—all in the exact Anthropic format. Skcd, an xAI developer, says in a thread on X that the transition should be as smooth as possible—so if you have something set up for Claude Code, it should work in Grok Build as well.

This is a well-thought-out move. Anthropic built an ecosystem in which developers invested time—writing their own skills, configuring MCP servers to connect to databases, GitHub, and internal wikis. These investments represent the cost of the transition. If xAI had built its own format, developers would have had to rewrite everything. By adopting Claude Code conventions, xAI reduces migration costs to practically zero. “Just one curl command and everything keeps working” is a marketing weapon, not a technical curiosity.

A second perspective: who benefits from this compatibility in the long term? In the short term, xAI, because it gains developers. In the long term, however, it’s Anthropic, which is thereby establishing its conventions as the de facto standard. MCP, which Anthropic released as an open protocol, has become the lingua franca for connecting LLMs with external tools over the past year. If xAI also supports MCP with Grok Build, the market unifies around a standard that Anthropic holds in its hands. But you can’t commercialize the protocol today; you can commercialize the implementation. Be the one setting the standards.

Key features that deserve a closer look

Grok Build has several features worth breaking down separately. It’s not a revolution, but a solid implementation of things that other tools also have—sometimes better, sometimes worse.

Plan mode is the main marketing differentiator. For more complex tasks, Grok Build switches to plan mode, proposes a structured plan of steps, and you, as the developer, can approve it, comment on individual steps inline, or rewrite them. Only then does the code start getting written. Changes are displayed as a clean diff, so you have full control. This is useful for tasks where a mistake can be costly—refactoring shared libraries, modifying production configurations, database migrations. Claude Code has a similar feature, but Grok Build’s plan mode is more interactive—it allows for inline comments on individual plan items.

Subagents running in parallel are the second key feature. For larger tasks, Grok Build delegates work to specialized subagents that run in parallel. Skcd in X thread notes that, unlike the competition (meaning mainly Claude Code), Grok Build displays the full trace of subagents, not just their titles. From a transparency standpoint, this is a valid argument—anyone who has ever debugged a Claude Code session with multiple subagents knows that the clarity of subagent execution is not CC’s strong suit. xAI claims they designed an overlay system in the TUI where the subagent’s trace is displayed above the main agent’s trace with the same controls. In practice, this means you can see exactly what each subagent is doing, not just “explore subsystem X”.

Worktrees and Hunk-Tracker are two lesser-known features that nevertheless reveal the team knows what it’s doing. Git worktrees are a way to create lightweight clones of a repository for parallel work—without a full clone, but with a separate working directory. Skcd reports that on xAI’s monorepo, they reduced worktree creation time from one minute and twenty seconds to roughly 20 to 30 seconds. This is a significant speedup that makes sense precisely for parallel work by subagents, since each can work in its own worktree without conflicts.

Hunk-Tracker is an internal mechanism for tracking changes at the hunk level (individual diff blocks) that enables rewind—returning to any point in the conversation. What’s interesting: Hunk-Tracker knows which files it can safely revert and which are “dirty” because they’ve been modified in the meantime by an external system (another editor, another process, or the developer themselves in the editor). This is something Claude Code doesn’t offer at this level of granularity, and it comes in handy when an agent messes something up.

ACP and headless mode extend usability beyond interactive work. ACP (Agent Coordination Protocol) is a protocol for orchestrating agents, allowing you to build custom bots and coordination applications on top of Grok Build. Headless (non-interactive) mode, enabled via the -p switch, allows you to run the agent in scripts and automations. This is important for CI/CD pipelines and other scenarios where you want to run the agent without interacting with the terminal.

Headless mode means that Grok Build runs without an interactive TUI interface in the terminal; it is launched with the -p switch and returns the result directly to standard output. It is primarily used in scripts, CI/CD pipelines, and automations where you do not want to (and cannot) manually confirm a plan or approve a diff.

Anchoring images in the terminal via the kitty protocol is a small feature, but it shows who the target audience is. The /imagine and /imagine-video commands allow you to generate images and videos using Grok Imagine models and display them directly in the terminal if you’re using a terminal that supports the kitty graphics protocol.

This is a professional optimization for developers who live in the terminal—no one else uses the kitty protocol.

Competitive Position

For better orientation, here’s a clear overview of where Grok Build stands against the competition:

What this means: Grok Build is technically competitive but the most expensive entry point to the market. $300 per month for SuperGrok Heavy is significantly more than $20 for Claude Pro or Gemini’s free tier. This limits the target audience to professionals who already have a subscription and want to try another tool, or to companies with a budget for experimentation. However, I would say this is a temporary limitation for testing purposes, and Grok will introduce more pricing tiers in the future.

What the official PR doesn’t say

In its official announcement, xAI does not specify exactly which model powers Grok Build. Third-party reports mention Grok 4.3 beta, but xAI itself does not confirm this. To me, this is an indicator that the model is under active development and xAI doesn’t want to publish specifications that may change. From a developer’s perspective, however, this is relevant information—results depend on the model, not the CLI wrapper.

The second thing missing: independent benchmarks. All information to date comes from xAI itself, its employees, or PR covering the launch. There are no independent tests on SWE-bench, Aider Polyglot, or any other established programming benchmark yet. It will take a few weeks before evaluations emerge from people who aren’t on xAI’s payroll or that of their PR partners.

Third point: security. xAI does not discuss agent isolation. Claude Code currently handles isolation via Cowork (its own agent infrastructure) and supports sandbox modes. According to available information, Grok Build runs directly in the user’s terminal with full file system privileges. This is standard, but for enterprise deployment, it means the agent can do anything in the repository.

If you’re dealing with a regulated environment, think very carefully about whether you can accept this approach.

Conclusion

Grok Build is a competently built tool entering a mature market with a clear strategy: not to try to build a greenfield ecosystem, but to adopt the standards established by Anthropic and compete on model quality and UX. That is a sensible approach. The question remains whether Grok 4.3 (if that is the model) can offer something that Claude Sonnet 4.6 or Opus 4.7 cannot. Without independent benchmarks, we don’t know that yet.

For developers with a SuperGrok Heavy subscription, this is an interesting addition. For everyone else, $300 a month for access to a beta version of a technology that has more mature competitors available for $20 is a tough sell. xAI knows this—which is why a new SuperHeavy tier is launching with an introductory price of $99 for six months. This signals that xAI wants as many developers as possible to try out the tool quickly. It makes sense: the more people use the tool, the faster issues will surface, and the faster the model will be fine-tuned.

For me, the most interesting thing about the entire launch is the meta-message: even Musk’s xAI acknowledges that Anthropic has set standards in this category that are worth emulating. This is a strategic win for Anthropic, even though xAI has just launched a competing product. In the long-term game of who will define the AI development stack, the winner is whoever sets the conventions. And Anthropic is setting those conventions.