Grok Build vs Codex: Reading the Coding-Agent Index for Skill Authors

If you build coding skills, the line from Grok 4.5's launch is the one that matters most: on the Coding-Agent Index, it scores on par with GPT-5.5 and Codex — in xAI's "Grok Build" harness — at much lower cost. Read fast, that's a buy signal. Read carefully, it's a claim you have to unpack before you let it change your backend.

The unpacking hinges on one distinction that most launch-day coverage flattens: a Coding-Agent Index measures a harness, not a model. The harness is the whole apparatus — the scaffolding, the tool loop, the retries, the prompt engineering — wrapped around the model. "Grok Build" is xAI's own harness. So "on par with Codex" is really "xAI's agent, running Grok 4.5, scores like OpenAI's agent running its model." That's a useful fact. It is not the same fact as "the Grok 4.5 model is as good at coding as the model behind Codex," and if you're choosing a backend for a skill you ship, the difference is the whole decision.

This is a skill author's read of the coding numbers: what the harness score tells you, what it hides, and how to pick a coding backend without being sold by a bar chart. As of July 2026 the coding claims here are largely xAI first-party and not yet independently reproduced — so we lean on what's independently measured and flag the rest.

Key Takeaways

• A Coding-Agent Index scores a harness, not a raw model. "Grok Build on par with Codex" compares two agents — model plus scaffolding — not two model brains in isolation.
• Your harness is not xAI's harness. The score was set in "Grok Build." Drop the raw grok-4.5 model into your skill's scaffolding and you inherit your own loop's quality, not theirs.
• Cost is the real edge, and it's partly independent. Grok 4.5's price is >60% below Opus 4.8 and GPT-5.5, and it used ~4.2× fewer output tokens than Opus 4.8 on SWE-Bench Pro (~15,954 vs ~67,020) — that token efficiency compounds in agentic loops.
• The honest split matters. On xAI's own four coding evals vs Opus 4.8, Grok 4.5 wins two and loses two — and Fable 5 leads all four. It's frontier-class at coding, not the coding leader.
• There's a dedicated code model. grok-build (~256K context per the docs) is a separate coding-focused option — confirm the ID at docs.x.ai and test it against grok-4.5 for your workload.

Harness vs model: the distinction that decides your backend

Picture two teams handed the same engine and told to build a car. One team's car wins the race. Did the engine win, or did the team? A Coding-Agent Index result is that race. The "engine" is the model; the "car" is the harness — the retry logic, the tool-calling loop, the context management, the system prompts, the error recovery. Grok 4.5 scored on par with Codex in the car xAI built.

Here's why that matters when you pick a backend. When you drop grok-4.5 into your own coding skill, you are not getting xAI's car. You're getting the raw engine, and you're bolting it into your scaffolding. Your tool loop, your retries, your prompts. The benchmark quality was set by their harness plus their model; your quality will be set by your harness plus their model. Those can differ substantially — a great model in a mediocre loop underperforms a good model in an excellent one.

So the correct inference from "on par with Codex in Grok Build" is narrow and real: the underlying model is capable enough that a well-built harness gets Codex-class results out of it. The incorrect inference is broad and seductive: swap in the model and my skill becomes Codex-class. The model is necessary, not sufficient. Your harness does at least half the work.

What's independent, and what's a claim

Sort the coding story into two piles before you trust it.

Independently measured (state plainly):

• Grok 4.5 sits at #4 on Artificial Analysis's Intelligence Index (Index 54, of ~170 models), behind Fable 5, GPT-5.5, and Opus 4.8. That's general intelligence, not coding-specific, but it's a real third-party anchor.
• Its headline price is >60% below Opus 4.8 and GPT-5.5 — the cost claim is the most trustworthy part of the pitch.
• Throughput ~91 tokens/sec, ~17s time-to-first-token, 500K context — all measured.

xAI first-party (label as claims, pending external validation):

• The Coding-Agent Index "on par with Codex in Grok Build" result.
• The head-to-head coding evals vs Opus 4.8. On xAI's launch page, across four benchmarks: Grok 4.5 wins DeepSWE 1.0 (62.0% vs 55.75%) and Terminal-Bench 2.1 (83.3% vs 78.9%), and loses DeepSWE 1.1 (53% vs 59%) and SWE-Bench Pro (64.7% vs 69.2%). Net: two of four vs Opus 4.8, with Fable 5 leading all four.

That split is the honest version of the story, and it's a better guide than any single number. Grok 4.5 is frontier-class at coding — it trades wins with Opus 4.8 and isn't embarrassed — but it is not the coding leader, and its own maker's numbers say so. Build your expectations on the split, not the headline.

The cost edge is the durable advantage

Strip away the harness ambiguity and one thing survives intact: coding agents are token-hungry, and Grok 4.5 is cheap in two compounding ways.

First, per-token price: >60% below the top of the frontier. Second, tokens per task: on SWE-Bench Pro, Grok 4.5 used roughly 15,954 average output tokens against Opus 4.8's ~67,020 — about 4.2× fewer. Coding agents loop — read, edit, test, re-read, re-edit — and every loop spends output tokens. A model that's both cheaper per token and more frugal with tokens has a cost advantage that multiplies over a long agentic run, not just adds.

For a skill author shipping a coding tool that runs at volume, that's the number that changes the P&L. You might reach for Fable 5 or Opus 4.8 on the genuinely hardest tasks — and you should, per the split above — but the everyday, high-frequency coding work is exactly where a frontier-class-but-cheaper model pays for itself. That's the argument to route bulk coding work down and reserve the top of the frontier for the hard cases, which is what a model router does automatically.

Trained alongside Cursor — a real signal

One corroborated data point cuts through the first-party fog: Grok 4.5 was trained alongside Cursor, and Cursor's own blog corroborates it. That's meaningful because it means the model was tuned against a real, heavily-used coding harness rather than only against benchmark suites. A model shaped by a production coding agent is more likely to behave well inside your coding agent — it's seen the shape of real tool loops, not just eval prompts.

It's a signal, not a guarantee. Cursor's harness still isn't your harness. But "co-trained with a shipping coding product" is a more credible coding-quality indicator than a launch-page bar, because it's about how the model behaves in a loop rather than how it scores on a static test.

How to pick a coding backend without getting sold

A short protocol for skill authors:

1. Ignore the harness score as an absolute. Read "on par with Codex in Grok Build" as "the model is capable enough for a good harness to reach that bar" — then test it in your harness.
2. Benchmark on your own tasks. Take ten representative tasks your skill actually handles and run them through your scaffolding on each candidate model. Your eval beats their eval for your decision, every time.
3. Measure tokens per task, not just pass rate. In a loop, a model that passes at 4× the token cost can lose on economics. Log output tokens per completed task and price it out.
4. Test the dedicated code model too. grok-build (~256K context, per docs — confirm at docs.x.ai) is purpose-built for code and may beat grok-4.5 on your workload. Don't assume the flagship is the right coding pick.
5. Route, don't marry. Reserve the top of the frontier (Fable 5 leads the coding evals) for your hardest tasks; send the high-volume everyday coding work to the cheaper frontier-class option.

The takeaway

"On par with GPT-5.5 and Codex in the Grok Build harness at lower cost" is true and useful — as long as you hear every word, including "in the Grok Build harness." That clause moves the claim from the model is Codex-class to xAI's agent running this model is Codex-class, and the gap between those is filled by scaffolding you'll have to build yourself.

What you can bank on is the cost story: frontier-class coding capability at >60% lower price and ~4.2× fewer output tokens per task, from a model co-trained with a real coding product. Test it in your own harness, measure tokens-per-task, and route the hard cases up. For the wider skeptic's frame on launch numbers, see First-Party Benchmarks Are Marketing, and browse the coding-agent building blocks already in the ecosystem at /agents and /browse.