Grok 4.5: change Coding and Knowledge Work with Cursor Training

Training a coding model alongside a live AI editor — not against synthetic benchmarks, but inside the actual loops a developer runs all day — is the genuinely interesting part of Grok 4.5. The 4.2× output-token efficiency on SWE Bench Pro is the part that lands on the invoice. Together they're the most concrete training-and-cost story a frontier model has shipped in a while.

What does Grok 4.5 actually do?

Grok 4.5 is a general-purpose model tuned for real engineering work — coding, science, engineering, and math. SpaceXAI trained it on datasets spanning those domains, then scaled reinforcement learning across hundreds of thousands of tasks, most of them multi-step software engineering. The research team describes its reasoning as both intelligent and efficient. It also scored #1 on Harvey's Legal Agent Benchmark, which is a stronger signal for office work than the "coding model" framing suggests. Read those two facts together and you have a model pitched as a coding specialist that benchmarks better than its peers on legal reasoning — that's a different kind of breadth.

The practical implication: don't treat this as only a code model. If you're shipping an agent that has to read a contract, summarize a deposition, or draft a regulatory filing, it's competitive on that surface too. Harvey's benchmark evaluates legal reasoning across real lawyer workflows — case analysis, document review, drafting — so #1 there means the model isn't brittle when the prompt isn't a coding problem.

How does the Cursor training change the model?

Most coding models are trained on GitHub dumps, StackOverflow corpora, or synthetic problems generated by a previous model. Grok 4.5 was trained alongside Cursor, the AI coding editor — meaning the model's behavior was shaped by real editor sessions. Actual tab completions, actual chat refactors, actual multi-file edits inside a live IDE, not static text. You can feel this in the output: prompts land, completions don't drift into invented APIs, and long agentic loops stay coherent. That's a different training signal than "here's a million LeetCode problems."

The Cursor angle also matters because Cursor is already shipping into developer workflows. A model pressure-tested against Cursor's editor patterns should compose well with the rest of the Cursor ecosystem. There's a nice meta-symmetry: Cursor the editor trained with the model, the model lands back in Cursor's picker. You're testing the same model in the same shell that shaped it.

How did SpaceXAI scale the training run?

The pre-training run spanned tens of thousands of NVIDIA GB300 GPUs. The interesting work wasn't the GPU count, it was the curation pipeline underneath: deduplication, quality scoring, domain-focused selection, and per-token intelligence scaling during RL. Grading combined automated and model-based methods, and the stack supports highly asynchronous training — agentic rollouts can run for many hours while learning continues.

"Asynchronous" is the part that matters. Synchronous RL trains on short prompts that finish in seconds. Asynchronous RL trains on long-horizon tasks — multi-file refactors, test-writing passes, debug-and-fix loops that take 20 minutes of model time. That's the same shape as the work you actually want the agent to do at inference. Training and inference are running the same loop, just at different speeds.

How does Grok 4.5 perform against the field?

SpaceXAI published scores across four coding benchmarks. Their prose says Grok 4.5 exceeds comparable leading models. The chart is more mixed: Fable (max) posts the top score on all four. Grok 4.5 stays closest on Terminal Bench 2.1. That's not a knockout.

What the chart doesn't show is the cost side, which is where Grok 4.5 wins. About 4.2× fewer output tokens than Opus 4.8 (max) on SWE Bench Pro. Same problem, four times less compute burned getting there. For a benchmark that prices itself by the token, that's a real gap — and it's the part SpaceXAI's headline leans on.

The honest read: if you only care about raw pass-rate on coding benchmarks, Fable (max) is still on top. If you care about cost-per-resolved-task, Grok 4.5 is in the conversation.

What does it cost and how fast is it?

$2/M input, $6/M output, served at 80 TPS. 80 TPS means the model streams fast enough that long agentic loops don't feel like watching paint dry. For a coding agent that lives or dies on token churn during long sessions, 4.2× fewer output tokens on a hard benchmark combined with sub-$10/M combined pricing is the real tailwind.

The throughput matters more than it sounds. A model at 20 TPS that takes 30 seconds to emit a 600-token completion feels broken during an interactive loop. A model at 80 TPS that takes 7.5 seconds for the same 600 tokens feels conversational. The 80 TPS figure means a long agentic debug session stays legible to the human watching it.

Concretely: a refactor session that emits ~50k output tokens costs roughly $0.30 in output on Grok 4.5 at list price ($6/M). The 4.2× efficiency claim means the same workload on Opus 4.8 (max) burns 4.2× more output tokens — exactly where the cost gap lives.

How do I use Grok 4.5 today?

It's already the default model in Grok Build. Outside that surface, the practical path is direct API access or a standard chat-completions client. Pull the base URL and signup flow from the release:

export GROK_API_KEY="<your-key>"
export GROK_BASE_URL="<from-the-spacexai-release>"

curl "$GROK_BASE_URL/chat/completions" \
  -H "Authorization: Bearer $GROK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.5",
    "messages": [{"role": "user", "content": "Refactor this file to use the new hook pattern"}]
  }'

Drop it into any standard client:

const res = await client.chat.completions.create({
  model: "grok-4.5",
  messages,
});

For an editor loop, pick it in Cursor's model picker (the same Cursor whose editor sessions shaped the training data) or wire it into Claude Code as a custom provider. Use it for the workloads it actually wins on: long agentic loops, multi-file refactors, and the legal-and-code crossover tasks where the Harvey #1 matters.

What's the part that doesn't change when the model does?

Grok 4.5 makes long agentic coding loops cheap. That's a real win for the multi-file refactors, the test-writing passes, and the "go fix the failing test suite" workflows that burn through millions of tokens in a single afternoon. The Harvey Legal Agent #1 also broadens the surface — this isn't only a code model, it's a knowledge-work model that happens to be good at code.

The part that doesn't change when the model does is the durable layer underneath: the component primitives, the cross-platform output, the auth and data plumbing that turns "agent generated this code" into "this code is shipping in a web app and an iOS app and an Android app, and it looks the same in all three." Swap the model when a better one lands; the output layer stays. That's the bit worth investing in — the layer that doesn't burn when the next frontier model ships.

Grok 4.5 is the first release in a while whose training story I'd call genuinely interesting — the Cursor collaboration is real signal, not marketing copy, and the 4.2× token efficiency is a measurable cost win. Run it on a real refactor, watch the token count, and keep the parts of your stack that don't care which model is on top.