xAI releases Grok Build 0.1: Coding model speeds up to 100 tokens/s

xAI This Time Focuses on Speed, Not Parameters

At the end of May, xAI quietly launched grok-build-0.1 for public API beta testing. This is the first time the Grok series has split off a dedicated programming model, separate from the general-purpose Grok 4.3, with a very clear positioning — for coding Agents, not chatbots.

If you only look at the official brief release note, you might think this is just another standard "we also have a programming model" update. But when you look at its price, speed, context window, and the set of agentic tools it integrates with, you’ll see xAI’s strategy is quite deliberate — they didn’t go after Claude Sonnet’s high score on SWE-bench, nor did they clash head-on with GPT’s general capabilities, but directly targeted two pain points developers care most about: cost and speed.

Three Numbers Essentially Explain Its Purpose

Let’s lay out the hard metrics:

• Inference Speed: 100+ tokens/sec
• Context Window: 256K
• Pricing: $1 per million input tokens, $2 per million output tokens

Individually, these numbers aren’t jaw-dropping, but combined they point directly to a very specific use case: multi-step, long-chain, trial-and-error-heavy Agent programming.

Here’s one way to understand it — Claude Sonnet 4.5 outputs at about 60-80 tokens/sec, priced at $3 per million input tokens and $15 per million output tokens. For the same refactoring task in Cursor that touches over a dozen files, you might wait 30 seconds and spend $0.20 with Sonnet; with grok-build-0.1, it’s theoretically just over ten seconds and two or three cents. This difference is immediately felt in interactive programming, especially when running long-chain ReAct loops where the Agent frequently does “think → tool_call → observe → think.”

xAI didn’t give any specific benchmark scores — which is actually unusual. Normally, releasing a programming model without a few bar charts is almost unheard of. My take is they likely know they can’t beat Claude 4.5/GPT-5 Codex on SWE-bench Verified, Aider polyglot, and similar leaderboards, so they simply changed the narrative: "I’m not the smartest one, but I’m the easiest for an Agent to use."

xAI Takes “Agentic Coding” Seriously This Time

The release doc repeatedly uses the term agentic harness — literally “Agent suite.” xAI explicitly recommends pairing it with the following tools:

• Grok Build CLI (their own product, similar to Claude Code, Codex CLI)
• Cursor
• Hermes Agent
• OpenClaw
• Kilo Code
• OpenCode

This list covers about half of the open-source Coding Agent landscape. Kilo Code and OpenCode have quickly risen in the open-source community as replacements for Cline, and OpenClaw is a new MCP-native Agent. Bundling the model into recommended configs for these tools shows xAI’s strategy is to bypass IDE giants and build reputation via open-source Agents.

One thing worth highlighting is MCP support. grok-build-0.1 natively supports Anthropic’s Model Context Protocol, meaning you can let it handle existing MCP servers — such as local file system access, GitHub ops, and database queries — without writing an adaptation layer. This is a practical choice, since MCP has effectively become a universal socket for Agent tools over the past year.

Multimodal, Tool Calling, Structured Output — All Included

In terms of capabilities, grok-build-0.1 offers a full set:

• Text + image input (debugging from screenshots, reading UI design drafts — no problem)
• Tool calling / Function calling
• Structured output (JSON Schema)
• Reasoning ability
• 256K context, no hard output length limit

Image input is increasingly important for programming Agents. In front-end dev scenarios, tossing an Agent a Figma screenshot to implement is already standard practice in tools like Cursor and v0. grok-build-0.1 hasn’t missed out on this.

The reasoning ability is vaguely described — “with reasoning thinking capability.” From community feedback, it doesn’t have explicit thinking budget control like o3 or Claude 4.5, but seems to have internalized chain-of-thought into the regular generation process. This design reduces latency but can lose out on complex logic problems — which matches its “fast” positioning.

Its Relationship with Grok 4.3 Is Subtle

One easily overlooked detail: xAI’s official API page still promotes Grok 4.3 as the flagship model, while grok-build-0.1 is placed in the “use case” table under “programming.”

This suggests xAI’s internal model matrix plan is:

1. Grok 4.3 for general flagship use, competing with GPT-5 and Claude 4.5
2. Grok Build 0.1 for the programming vertical, competing with Claude Code and Codex for developer share
3. More suffix-based specialized models in the future (Grok Research, Grok Vision, etc.)

This is somewhat like OpenAI’s segmentation into GPT-5, o3, and Codex — but xAI is more aggressive: giving the programming model its own namespace (build- series) instead of treating it as a variant of the main model.

Invocation Method: Compatible with OpenAI Format

xAI is continuing its usual practice — the API is fully compatible with OpenAI SDK format, making migration cost near zero. Here’s a minimal working example:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.openai-hub.com/v1",
    api_key="your-key"
)

response = client.chat.completions.create(
    model="grok-build-0.1",
    messages=[
        {"role": "system", "content": "You are a coding agent."},
        {"role": "user", "content": "Help me use FastAPI to write an API with SSE streaming output, requiring an authentication middleware."}
    ],
    tools=[
        {
            "type": "function",
            "function": {
                "name": "write_file",
                "description": "Write content to a file",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "path": {"type": "string"},
                        "content": {"type": "string"}
                    },
                    "required": ["path", "content"]
                }
            }
        }
    ],
    stream=True
)

for chunk in response:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

For domestic developers, OpenAI Hub has already added grok-build-0.1 to the model list — just change the base_url to invoke it, avoiding the need for an xAI account and cross-border payment processing. Using one key to run Grok, Claude, and GPT for comparison tests is also convenient.

Side-by-Side with Mainstream Programming Models

Let’s put the main competitors together:

| Model | Input Price | Output Price | Context | Output Speed | |------|-------------|--------------|---------|--------------| | grok-build-0.1 | $1/M | $2/M | 256K | 100+ tok/s | | Claude Sonnet 4.5 | $3/M | $15/M | 200K | 60-80 tok/s | | GPT-5 Codex | $2.5/M | $10/M | 400K | 50-70 tok/s | | Gemini 2.5 Pro | $1.25/M | $10/M | 1M | 80-100 tok/s | | DeepSeek V3.2 | $0.27/M | $1.1/M | 128K | 40-60 tok/s |

You can see grok-build-0.1 is strategically positioned — much cheaper than the closed-source big players, more expensive than DeepSeek but much faster, and with twice DeepSeek’s context window.

Who would find this most attractive? I’d say two groups:

1. Startup teams building Coding Agent products: Sonnet’s per-inference cost is too high, and token bills skyrocket as user volume grows; DeepSeek is cheap but slow and short-context — unsuitable for large project refactoring. Grok Build hits a sweet spot in between.
2. Heavy CLI Agent users among individual developers: Those who use Claude Code daily know monthly bills can easily exceed $100. If Grok Build CLI matches Sonnet’s experience, they may switch.

Its Weaknesses Should Also Be Clear

Don’t get carried away by low cost and high speed. grok-build-0.1 currently has some clear drawbacks:

• No public benchmark: No numbers for SWE-bench, Aider, LiveCodeBench — this restraint could mean it’s not competitive or is a strategic dodge, but either way developers should be aware when choosing.
• The “0.1” version number is honest: In public beta, behavior may change, and details like tool call stability and long-context memory still need polish. If integrating into production, build in fail-safes.
• Ecosystem not yet mature: Behind Claude Code is over a year of Anthropic polishing a CLI product, with mature prompt engineering, agent frameworks, and community recipes. Grok Build CLI has just debuted, so developers still need to explore on their own.
• Training data recency unknown: xAI hasn’t disclosed cutoff date — its familiarity with libraries and APIs released in 2025 requires testing.

In Conclusion

Competition among large models has shifted from “who’s smarter” to “who’s more suited for specific scenarios.” grok-build-0.1 isn’t about topping leaderboards over Claude — it’s aiming at a very specific niche: a programming model for Agents that’s fast and affordable. This positioning is inherently sharper than some safe “fully match SOTA” releases.

By naming an independent “build-” series, xAI is signaling that programming is no longer just something general models handle incidentally — it’s a direction worth dedicated optimization and iteration. From GitHub Copilot’s single-point assistance, to Cursor’s full IDE interaction, to Claude Code and Grok Build CLI’s end-to-end Agent workflows, the programming paradigm has already shifted. It’s inevitable for models to follow suit.

Whether this flame catches will depend on two things: SWE-bench Verified’s real scores (the community will surely test), and whether Grok Build CLI’s product polish can keep pace with Claude Code. 0.1 is just the beginning.

References

• Grok-build-0.1 API release discussion - linux.do — First-hand discussion and feedback from the domestic developer community