Grok 4.5: What Happens When You Train a 1.5T MoE Model on Real Developer Workflows

xAI released Grok 4.5 on July 8, 2026 — a 1.5-trillion-parameter Mixture-of-Experts model built on the company's V9 foundation architecture. The headline numbers are notable, but the more interesting story is how the model was trained: using trillions of tokens of real developer interaction data from the Cursor IDE, including multi-file diffs, debugger sessions, and user corrections. That design choice shapes both what Grok 4.5 is good at and where it falls short.

The V9 Architecture and MoE Design

Grok 4.5 uses a Mixture-of-Experts architecture, which means only a fraction of its 1.5 trillion parameters are active during any given inference pass. This is the same general approach used by models like Mixtral and DeepSeek-V3, where routing logic selects a subset of "expert" sub-networks per token rather than running the full model.

The practical benefit is throughput: xAI reports serving speeds of 80–91 tokens per second, which matters for agentic workloads where a single task might involve dozens of sequential model calls. The model was trained across tens of thousands of NVIDIA GB300 GPUs on xAI's Colossus cluster.

One notable regression from its predecessor: Grok 4.5 has a 500K-token context window, down from the 1M-token window in Grok 4.3. xAI hasn't explained this reduction publicly. There's also a pricing inflection point at 200K tokens — requests that exceed that threshold are billed at higher long-context rates for the entire request, not just the overflow.

The Cursor Data Flywheel

The most distinctive aspect of Grok 4.5's training is its use of Cursor IDE session data. Cursor, the AI-native code editor, provided trillions of tokens of real developer workflows: how engineers navigate large codebases, how they respond to model suggestions, how they debug across multiple files, and how they correct model mistakes.

This is different from training on static code repositories. Static code tells you what correct programs look like. Cursor session data tells you how developers interact with AI assistance — which suggestions they accept, which they reject, and what they do when the model gets something wrong. That behavioral signal is harder to synthesize and potentially more useful for training models that need to work alongside humans in agentic loops.

xAI also deliberately broadened the training mix beyond pure coding. The dataset includes high-quality STEM tasks, research papers, and other knowledge-work domains — a deliberate move away from the narrow coding specialization of earlier models like Composer 2.5.

There's a complication worth noting: Cursor disclosed that an earlier snapshot of its own codebase was accidentally included in the training data. This inflated Grok 4.5's scores on CursorBench-derived evaluations. Third-party benchmarks like DeepSWE and SWE-Bench Pro use independent infrastructure and weren't affected, but it's a reminder that benchmark contamination remains a persistent problem in model evaluation.

Reinforcement Learning at Scale

Beyond the data mix, xAI scaled reinforcement learning with a focus on what they call "per-token intelligence." The RL process covered hundreds of thousands of software engineering and technical tasks, with agentic rollouts evaluated through automated and model-based grading.

The training stack was built for asynchronous operation — agentic rollouts can run for hours without halting the learning process across the GPU cluster. This is a meaningful engineering challenge: standard synchronous RL requires waiting for each rollout to complete before updating model weights, which becomes a bottleneck when rollouts involve multi-step tool use and long-horizon planning.

Benchmark Performance: Provider vs. Neutral Harnesses

The benchmark picture for Grok 4.5 is mixed, and the gap between provider-controlled and neutral evaluations is worth examining carefully.

On xAI's own DeepSWE 1.0 benchmark, Grok 4.5 scores 62.0%, beating Claude Opus 4.8 at 55.75%. On the neutral DeepSWE 1.1 harness, the picture reverses: Grok 4.5 scores 53%, trailing Opus 4.8 (59%) and GPT-5.5 (67%). On SWE-Bench Pro, Grok 4.5 resolves 64.7% of tasks, behind Fable 5 (80.4%) and Opus 4.8 (69.2%). Terminal Bench 2.1 is more competitive at 83.3%, nearly matching GPT-5.5's 83.4%.

This pattern — strong on provider-controlled evals, weaker on neutral ones — isn't unique to Grok 4.5, but it's a useful reminder to weight independent benchmarks more heavily when comparing models.

Token Efficiency as a Real Advantage

Where Grok 4.5 does appear to have a genuine edge is token efficiency. On SWE-Bench Pro, xAI reports an average of ~15,954 output tokens per resolved task. Claude Opus 4.8 averages ~67,020 output tokens for the same tasks — roughly 4.2× more.

For agentic workloads, this matters in two ways. First, it directly reduces cost: fewer output tokens means lower per-task pricing. Second, it affects latency in multi-step pipelines where each model call feeds into the next. A model that reaches the same answer in fewer tokens is faster to work with in practice, even if raw throughput (tokens per second) is similar.

Whether this efficiency reflects genuinely more concise reasoning or simply shorter (and sometimes less thorough) responses is harder to assess from benchmark numbers alone. But for high-volume agentic deployments where cost is a constraint, it's a meaningful data point.

Availability and Pricing

Grok 4.5 is available via the xAI API, Cursor (all plans), and Microsoft Office add-ins. Pricing is $2 per million input tokens and $6 per million output tokens for standard usage, with a "fast" variant available within Cursor at $4/$18. The 200K-token context threshold triggers higher long-context rates ($4/M input, $12/M output) for the entire request.

EU availability was delayed at launch, with xAI targeting mid-July 2026 for that region.

What This Means for Practitioners

Grok 4.5 is a reasonable choice for agentic coding workflows where token efficiency and throughput matter more than raw benchmark scores. The Cursor data integration gives it a practical grounding in how developers actually work, which may translate to better behavior in real-world coding agents even when it doesn't show up cleanly in standardized benchmarks.

The context window reduction to 500K tokens is a real limitation for tasks that require holding large codebases in context simultaneously. Teams working with very large repositories may find this constraining compared to models that maintain 1M-token windows.

The broader lesson from Grok 4.5's training approach is that behavioral data from real human-AI interactions may be as valuable as raw code volume for training coding assistants. As more AI-native development tools accumulate this kind of interaction data, the models trained on it are likely to diverge meaningfully from those trained on static corpora alone.