Grok Build 0.1: xAI's $1/M agentic coding API and what it costs in production

Most coding models are still priced and marketed like chat completions. xAI's grok-build-0.1 is priced like an agent that never stops iterating.

It landed in public beta on the xAI API in late May 2026 at $1 per million input tokens and $2 per million output tokens, with cached reads at $0.20 per million. That is a different conversation than "which model writes the prettiest function body."

I route models for client agent loops every week. This post is how Grok Build fits next to the stacks I already document in agentic coding model routing.

Built for agent loops, not one-shot chat

Grok Build 0.1 is the same engine behind xAI's Grok Build CLI. The API exposure matters because it lets you embed that behavior in your own harness instead of wrapping a terminal UI.

AI/TLDR's model card lists the capabilities that actually change agent design:

The model accepts vision input. That sounds like a checkbox until you watch an agent misread a stack trace because it never saw the screenshot. Grok Build was trained with image inputs in the loop, not bolted on after the fact.

Pricing that rewards cached context

List price is only half the story for agent economics. Agents re-read the same files dozens of times per task. Cached input pricing is where Grok Build gets interesting.

Vercel AI Gateway notes the cached rate explicitly: reusing a long codebase prefix across many agent steps drops input cost by 80% on cache hits.

That is the same economic lever Anthropic and OpenAI use, but at a lower headline number. For a harness that keeps a stable system prompt plus repo snapshot in context, cached reads compound fast.

When the 200K threshold bites

xAI bills the entire request at the higher tier once prompt tokens reach 200K. If you are loading entire monorepos verbatim, watch that cliff.

Practical mitigations I use on client projects:

• Index + retrieve instead of dumping every file into context
• Stable prefix caching for architecture docs and style guides
• Route large-context spikes to models where your harness already handles tiered billing

256K is generous. It is not infinite. Treat it like RAM, not disk.

Where to plug it in

Grok Build 0.1 is available through multiple gateways:

• xAI API (grok-build-0.1, aliases include grok-code-fast-1)
• OpenRouter
• Vercel AI Gateway

Rate limits on the xAI API start around 1,800 requests per minute and 10 million tokens per minute in us-east-1 and eu-west-1. That is enough headroom for a small team's agent fleet, not a public SaaS at scale without sharding.

For IDE users, the digest coverage mentions Cursor, Kilo Code, and OpenCode as compatible surfaces. The integration path is the same as any custom endpoint: point your agent harness at the xAI responses API and pass tool schemas.

How it compares to the routing stack I already run

I am not swapping every loop to Grok Build tomorrow. I am adding it as a third independent provider for cost and capacity spreading.

The AIML API breakdown frames the positioning correctly: most models answer programming questions. Grok Build is trained to plan, execute, debug, and integrate with tools across multi-step tasks without constant hand-holding.

That is the same product shape as Devin-style agents and Cursor's longest agent sessions. The difference is you own the harness and the bill.

What I would test before production routing

Headline pricing is cheap. Production routing needs evals on your repo and your tool graph.

A short checklist I run for any new coding model:

1. Tool call reliability on your MCP servers and shell wrappers
2. Edit quality on your largest modules (not toy repos)
3. Retry behavior when tests fail (does it loop sensibly or spiral?)
4. Vision tasks if your workflow feeds screenshots
5. Cost per finished task measured in dollars, not tokens

Grok Build's always-on reasoning means every turn pays for thinking tokens. That can be good (fewer dumb tool calls) or expensive (verbose chains on simple grep tasks). Measure finished tasks, not vibes.

The bigger picture: three providers for agentic coding

For two years, agentic coding economics were mostly a Claude vs GPT conversation. A credible third API at $1/$2 with 256K context and vision changes procurement math.

Teams can:

• Spread rate-limit risk across providers
• Negotiate from a real alternative quote
• Route by task type without religious model loyalty

None of that removes the need for eval harnesses and routing logic. It just means the router has more than two doors.

If you are building a multi-model agent stack and want help sizing cost per task for your actual codebase, book a free discovery call. The benchmark that matters is your bill at the end of the sprint, not the launch tweet.