Grok 4.5 Explained: Architecture, Benchmarks and Deployment (2026)
For eighteen months the frontier-model story was a simple arms race: bigger context windows, higher benchmark scores, more parameters. Grok 4.5 breaks that script. xAI’s flagship, shipped on 8 July 2026, is the first model from a major lab that deliberately trades peak benchmark rank for something a working engineer feels every day — it does the same job with a quarter of the output tokens, at a third of the sticker price, and it is tuned on real developer sessions rather than synthetic puzzles. It is not the smartest model you can buy this quarter. It may be the one you actually ship on.
That trade-off is the whole point, and it is the reason Grok 4.5 deserves a careful read rather than a benchmark screenshot. This post is a durable reference: what the model is, how it is built, what the numbers really say, what it costs to run, and where it will let you down.
What this covers: Grok 4.5’s lineage and place in the Grok family; its mixture-of-experts architecture and 500K-token context window; the Cursor-driven training pipeline; sourced benchmark results with their caveats; API pricing and deployment paths; and an honest accounting of its limitations before a head-to-head comparison with its main rivals.
Lineage and Context: Where Grok 4.5 Sits
Grok 4.5 is the latest node on a fast-moving family tree. xAI has iterated Grok on a punishing cadence: the Grok 4 series established the lab as a genuine frontier player in 2025, Grok 4 Heavy became the first model to cross 50% on Humanity’s Last Exam, and the point-releases that followed — Grok 4.3 and the interim Grok 4.20 — pushed context length and tool use forward in quick succession. Grok 4.5 is the first public model built on xAI’s new “V9” foundation, a from-scratch base rather than a fine-tune of the previous generation.
The framing matters because Grok 4.5 is a narrowing, not a widening. Grok 4.3 shipped a headline 1-million-token context window; Grok 4.5 deliberately shrinks that to 500K tokens. Where earlier Groks chased general-purpose maximalism, 4.5 is aimed squarely at two workloads: agentic coding and office knowledge work. The three words xAI leads its own launch material with — agentic tool calling, minimal hallucinations, and configurable reasoning — tell you exactly who the model is for. This is a build tool, not a debating partner.
That focus is a direct response to how the market actually consumes frontier models in 2026. Most production spend now flows through coding agents and retrieval pipelines, not chat. If you have followed our running series on the Grok line — the Grok 4.20 architecture deep-dive traces the immediate predecessor — you will recognise the pattern: each release trims generality in exchange for a sharper economic profile on the workloads that pay the bills. Independent trackers such as Artificial Analysis confirm the direction of travel, placing Grok 4.5 fourth on raw intelligence but first on agentic tool use.
Elon Musk framed the release, in a 28 June post, as part of a stated intent to ship new from-scratch models monthly through the remainder of 2026. Treat that as a reported roadmap claim, not a shipped fact — no lab has sustained a genuine monthly from-scratch cadence, and the industry has learned to discount pre-announcements. What is verifiable is that Grok 4.5 exists, is in the public API, and behaves as advertised on the axes that xAI chose to emphasise.
Inside the Architecture: MoE, Attention and the 500K Window
Grok 4.5 is a sparse mixture-of-experts (MoE) transformer with a reported ~1.5 trillion total parameters, a 500K-token context window, and a runtime “configurable reasoning” control that lets callers dial inference-time compute up or down. xAI has not disclosed the exact expert layout — how many experts, how many activate per token, or the active-parameter count — so anyone quoting a precise “active parameters” figure for Grok 4.5 is guessing.
Figure 1: A schematic of the Grok 4.5 inference path — tokens flow through the V9 transformer stack, a per-layer MoE router selects sparse experts alongside a shared dense path, long-context attention integrates up to 500K tokens, and a configurable reasoning controller governs how much inference-time compute is spent before emitting output.
The diagram compresses a lot of undisclosed detail into a defensible skeleton. Input arrives as up to 500K tokens, is embedded, and passes through the V9 transformer stack. Inside each transformer block, a router network scores the token and dispatches it to a small subset of expert feed-forward networks; a shared dense path runs in parallel so that common patterns do not depend on routing luck. Attention layers integrate information across the long context, and a reasoning controller decides how many internal steps to spend before the model commits to an answer. The output streams at a reported throughput near 80 tokens per second.
Why mixture-of-experts is the whole economic story
MoE is the mechanism behind Grok 4.5’s headline efficiency. In a dense model, every parameter participates in every token — a 1.5T dense model would be ruinously expensive to serve. In an MoE model, only a fraction of the network activates per token, so you get the knowledge capacity of a very large model at the compute cost of a much smaller one. That is how xAI can plausibly claim “Opus-class” quality at a fraction of Opus-class pricing.
The trade is not free. MoE models are harder to train stably, the router can under-utilise experts, and serving them efficiently requires careful expert-parallel sharding across accelerators. If you want the mechanics in depth, our mixture-of-experts architecture explainer walks through routing, load balancing, and the capacity-factor tuning that separates a well-served MoE from one that thrashes. For Grok 4.5, the relevant point is that xAI has evidently invested heavily in the serving side: the token-efficiency numbers only translate to real cost savings if the sparse compute is realised in production, not just in theory.
The context window shrank on purpose
A 500K-token window is roughly 375,000 words — enough to hold a mid-sized codebase, a full requirements corpus, or dozens of long documents in a single call. The decision to halve it from Grok 4.3’s 1M is instructive. Ultra-long contexts are expensive to serve and, past a few hundred thousand tokens, most models degrade badly on retrieval-in-the-middle tasks. By capping at 500K, xAI keeps attention quality high across the window it does offer, and it aligns the ceiling with the agentic-coding use case, where 500K comfortably covers the working set of a large repository plus tool output.
Configurable reasoning as a first-class control
The “configurable reasoning” knob is the third architectural pillar and the least discussed. Rather than a fixed chain-of-thought budget, Grok 4.5 exposes a control over how much inference-time compute it spends. Low settings favour latency and cost for straightforward calls; high settings unlock deeper multi-step reasoning for hard problems. In practice this is the lever that lets a single model span cheap high-volume tool calls and expensive frontier reasoning without you switching model IDs — a meaningful operational simplification for agent builders.
Tokenizer, vocab and modalities
xAI has not published Grok 4.5’s tokenizer or vocabulary size, so treat any specific vocab number you see as unverified. What matters practically is that the model is optimised for the code-and-English mixture its Cursor training implies — tokenizers tuned on code handle whitespace, identifiers and punctuation more efficiently, which compounds the output-token savings on coding tasks. On modalities, Grok 4.5’s public positioning is text-first: agentic coding, tool calling and knowledge work. xAI has not made bold multimodal claims for this release the way it has for consumer-facing Grok features, so if your workload is vision-heavy, do not assume parity with the multimodal flagships until you have tested it. The safe reading is that Grok 4.5 is a text-and-code specialist that happens to be very good at the economics of that specialisation.
How Grok 4.5 Was Trained: The Cursor Flywheel
The most distinctive thing about Grok 4.5 is not its architecture — it is its training data. xAI reports co-training the model with real developer session data supplied through a partnership with the AI code editor Cursor. That “data flywheel” is the model’s competitive moat, and it explains the coding-and-agents positioning better than any parameter count.
Figure 2: The reported Grok 4.5 training pipeline — a from-scratch V9 pretraining run over a web and code corpus produces the 1.5T MoE base, which is then given supplemental training on real Cursor developer sessions before instruction tuning, reinforcement learning from human feedback, and a dedicated agentic tool-use RL stage.
Treat the stage labels as directionally reported rather than officially specified in detail. xAI has confirmed the V9 base, the ~1.5T MoE scale, and the Cursor supplemental data; it has not published the full training-data composition, the exact compute budget, or the precise post-training recipe. What follows is the defensible reconstruction.
Pretraining and the from-scratch V9 base
Grok 4.5 is built on a new foundation model rather than a continued-pretraining fine-tune of the Grok 4 series. That is significant: from-scratch pretraining is where a lab bakes in its core reasoning and world knowledge, and doing it again — rather than patching the old base — is expensive. It is consistent with Musk’s stated (and again, reported) intent to ship fresh foundations frequently. The pretraining corpus is the usual web-plus-code mixture; xAI has not disclosed its size or the code-to-text ratio, so no token count should be quoted as fact.
The Cursor data flywheel
The supplemental Cursor stage is the differentiator. Coding agents fail in characteristic ways — they misread repository structure, call the wrong tool, or loop on a failing test — and the richest signal for fixing those failures is a real developer’s trajectory: the edits they made, the commands they ran, the corrections they applied. By training on that trajectory data, Grok 4.5 learns the shape of a productive coding session, not just the syntax of correct code. This is why the model’s strongest independent results are on agentic and terminal benchmarks rather than pure single-turn code generation.
Post-training: SFT, RLHF and agentic RL
After the base and the coding supplement, Grok 4.5 goes through a conventional-looking alignment stack: supervised fine-tuning on instruction data, reinforcement learning from human feedback to shape helpfulness and reduce hallucination, and — critically — a dedicated reinforcement-learning stage on agentic tool use. That last stage is what produces the model’s top-ranked agentic-tool-use result. The emphasis on “minimal hallucinations” as a launch pillar suggests the RLHF stage was tuned aggressively toward calibrated refusals and citation over confident guessing, which is the right bias for a knowledge-work model.
The agentic-RL stage deserves a closer look because it is where the token-efficiency advantage is most plausibly manufactured. In reinforcement learning with verifiable rewards — running a tool, executing a test, checking whether a patch actually compiles — the reward signal is objective, and a model can be optimised not just to reach the right answer but to reach it cheaply. A model that is rewarded for resolving a failing test in fewer steps learns to stop second-guessing itself, to avoid redundant tool calls, and to commit to a plan. That behavioural economy is exactly what shows up as ~15,954 output tokens per task instead of ~67,020. It is not a quirk of the architecture; it is very likely a trained-in disposition, and it is the single most transferable lesson from Grok 4.5’s recipe.
Capabilities and Benchmarks: What the Numbers Actually Say
Grok 4.5 scores 54 on the independent Artificial Analysis Intelligence Index, ranking fourth overall behind Claude Fable 5, GPT-5.5, and Claude Opus 4.8 — while taking the top spot on agentic tool use. That one sentence captures the entire strategic picture: not the smartest model, but the best-behaved agent, and by a wide margin the most token-efficient.
Figure 3: Where Grok 4.5 lands versus its main rivals. On the Artificial Analysis Intelligence Index it sits fourth at 54, behind Fable 5, GPT-5.5 and Opus 4.8. On SWE-bench Pro it reports 64.7%, third of four — ahead of GPT-5.5 (58.6%) but behind Opus 4.8 (69.2%) and Fable 5 (80.4%).
Here are the sourced results, with the numbers stated exactly or not at all:
| Benchmark | Grok 4.5 | Notes and rivals |
|---|---|---|
| Artificial Analysis Intelligence Index | 54 (#4) | Behind Fable 5, GPT-5.5, Opus 4.8; up ~16 points vs Grok 4.3 |
| Agentic tool use (AA) | #1 | Top-ranked axis for the model |
| SWE-bench Pro | 64.7% | 3rd of 4; Fable 5 80.4%, Opus 4.8 69.2%, GPT-5.5 58.6% |
| Terminal-Bench 2.1 | 83.3% | Reported by xAI |
| AA Coding Agent Index | 76 (in Grok Build) | On par with GPT-5.5 Codex; below Fable 5 |
| Output tokens per SWE-bench Pro task | ~15,954 | vs ~67,020 for Opus 4.8 in max mode |
| Throughput | ~80 tokens/sec | Reported |
The token-efficiency line is the one to internalise. On a matched SWE-bench Pro task, Grok 4.5 reportedly resolves the issue using ~15,954 output tokens against ~67,020 for Claude Opus 4.8 in its maximum-effort mode — roughly a 4x reduction. Artificial Analysis independently supports the direction with a per-task figure around 14,000 output tokens on its Intelligence Index runs. On the Coding Agent Index, xAI’s own Grok Build harness reportedly completes the task suite for about $2.49 per task, versus $11.80 for Fable 5 (Claude Code) and $5.07 for GPT-5.5 (Codex). That is the economic case in one number.
Methodology caveats you should not skip
Read these scores with three caveats. First, some of the strongest numbers — Terminal-Bench 2.1, the Grok Build Coding Agent result — are vendor-reported, run in xAI’s own harness. Vendor benchmarks are not fraudulent, but they are optimised, and independent replication typically lands lower. Second, the SWE-bench Pro ranking of third-of-four is a genuine, unflattering data point that the token-efficiency story tends to bury: on raw problem-solving, two rivals beat it. Third, benchmark contamination is a live risk for any coding eval; a model trained on real developer sessions may have seen adjacent problems, and no public dataset fully rules that out.
Note also a naming wrinkle in the coverage: because of xAI’s reported corporate consolidation, some outlets label the model “SpaceXAI” and attribute results to that entity. It is the same model and the same numbers; treat the branding as cosmetic. And to be precise about one widely-cited figure — the 50.7% Humanity’s Last Exam score belongs to Grok 4 Heavy, the predecessor, not to Grok 4.5. As of publication, no independent lab had scored Grok 4.5 on HLE, so no HLE number should be attributed to it.
What token efficiency buys you, in dollars
It is worth turning the efficiency claim into a concrete figure, because per-token pricing hides the real gap. Imagine an agent that resolves 10,000 coding tasks a month. At Grok 4.5’s reported ~15,954 output tokens per task and $6 per million output tokens, output alone costs roughly $0.096 per task, or about $957 a month. Run the same 10,000 tasks on a rival that consumes ~67,020 output tokens per task at $25 per million — a plausible Opus-class profile — and output alone is about $1.68 per task, or roughly $16,800 a month. That is a ~17x swing on output cost before you even count the cheaper input and cached-input rates. The numbers are illustrative, built from the reported per-task token figures and list prices rather than a controlled measurement, but they show why the efficiency story dominates the sticker-price story: on a high-volume agent, the token count per task matters more than the price per token.
Beyond coding: knowledge-work capability
Grok 4.5’s second stated target is office knowledge work, and this is the axis with the least independent data. The “minimal hallucinations” pillar is aimed here — summarisation, drafting, research synthesis and structured extraction, where a confidently wrong answer is expensive. The 500K window supports long-document workflows, and the low input and cached-input pricing makes it attractive for retrieval-augmented pipelines that re-send large stable contexts. What is missing is a strong, independent knowledge-work benchmark result to match the coding numbers; the Intelligence Index score of 54 is a general proxy, not a knowledge-work-specific one. Treat Grok 4.5 as a well-priced, well-calibrated knowledge-work model that you should validate on your own documents rather than one with a published knowledge-work crown.
Access, Pricing and Deployment
Grok 4.5 is an API-and-product model, not an open-weights release. You reach it through xAI’s REST API, through the Grok consumer apps and the SuperGrok subscription tier, and — fittingly — natively inside Cursor. There are no published open weights, so self-hosting, local quantisation, and on-prem deployment are off the table; if data residency or air-gapping is a hard requirement, Grok 4.5 is not your model.
Figure 4: The Grok 4.5 access surface. Developers and users reach the same grok-4.5 model through the xAI REST API, the Grok app and SuperGrok, or directly inside the Cursor IDE. Every path exposes configurable reasoning, agentic tool calling, and the 500K context window — and none of them ships open weights.
Pricing is the headline. Grok 4.5 lists at $2.00 per million input tokens and $6.00 per million output tokens, with cached input at $0.50 per million — a steep discount for the repeated-context patterns that dominate agentic and RAG workloads. Set that against Claude Opus 4.8 at a reported $5 input / $25 output, and the sticker gap is already 2.5x on input and roughly 4x on output. Fold in the ~4x token-efficiency advantage on completed tasks, and the effective cost-per-outcome gap widens further. For a high-volume coding agent, that is the difference between a viable unit economic and a subsidised one.
What deployment actually looks like
Because there are no weights to host, “deployment” here means integration, not infrastructure. The practical decisions are: which access path (API for custom agents, Cursor for in-editor coding, SuperGrok for interactive knowledge work); what reasoning setting to default to (low for high-volume tool calls, high for hard reasoning); and how aggressively to exploit prompt caching, since the $0.50 cached-input rate rewards stable system prompts and pinned repository context. Latency is governed by the ~80 tokens/sec throughput and by your reasoning setting — a high-reasoning call will feel slow relative to a low-reasoning one, which is the expected trade.
Because the context window is 500K rather than 1M, teams migrating from an ultra-long-context model should audit their chunking: a pipeline that assumed a million-token budget needs a retrieval layer to fit the working set into 500K. In practice that is rarely a real constraint for code — 500K comfortably holds a large repository — but it can bite document-heavy pipelines that were leaning on brute-force context stuffing.
Limitations, Safety and Failure Modes
The honest limitations of Grok 4.5 follow directly from its design choices, and a durable reference has to state them plainly.
It is not the raw-intelligence leader. Fourth on the Intelligence Index and third on SWE-bench Pro are respectable but not dominant. For the hardest frontier reasoning — novel mathematics, deep research synthesis, the problems where you want the single strongest model regardless of cost — Fable 5, GPT-5.5 and Opus 4.8 each have a claim ahead of it. Choosing Grok 4.5 for those tasks trades a measurable amount of capability for economics.
Closed weights, single vendor. No open weights means no self-hosting, no fine-tuning on your own data, no protection against price changes or deprecation, and full dependence on xAI’s availability and moderation policies. For regulated environments with data-residency mandates, that is disqualifying on its own.
Reported numbers are vendor-flavoured. Several of the most impressive results are from xAI’s own harness. The independent scores — the ones that survive third-party runs — are the fourth-place Intelligence Index and the third-place SWE-bench Pro. Weight the vendor claims accordingly, especially Terminal-Bench and the Grok Build cost figures.
Long-context degradation still applies. A 500K window is not a promise of uniform recall across 500K tokens. Like every long-context model, Grok 4.5 will retrieve less reliably from the middle of a very full context than from its ends. Build retrieval and re-ranking rather than trusting brute-force context stuffing.
Hallucination is reduced, not eliminated. “Minimal hallucinations” is a launch pillar and a tuning bias, not a guarantee. On knowledge-work tasks the model still fabricates occasionally, and the failure is more dangerous precisely because the model is well-calibrated most of the time — a confident, well-formatted wrong answer is harder to catch than an obviously shaky one. Keep verification in the loop for anything consequential.
Brand and moderation risk. Grok’s consumer-facing history includes well-publicised moderation controversies. For enterprise buyers, the reputational and policy posture of the vendor is part of the risk calculus, independent of model quality. On the flip side, xAI has published relatively little formal safety documentation compared with some peers, so red-team and system-card detail is thinner than you might want for a high-stakes deployment.
How Grok 4.5 Compares
The right way to choose is by workload, not by leaderboard. Here is a decision matrix against the three models it is most often weighed against, for the use cases where the choice actually turns.
| Use case | Grok 4.5 | Claude Opus 4.8 | GPT-5.5 | Fable 5 |
|---|---|---|---|---|
| High-volume agentic coding | Best value; top agentic-tool-use, ~4x cheaper per task | Strong but costly per task | Strong, mid-cost | Highest quality, highest cost |
| Hardest single-turn reasoning | Adequate (#4 index) | Excellent | Excellent | Best |
| Cost-sensitive RAG / knowledge work | Excellent — cheap cached input, low hallucination bias | Overkill on price | Solid | Overkill on price |
| Regulated / self-hosted / on-prem | Not possible (closed weights) | Closed weights | Closed weights | Closed weights |
Read the matrix as a spend-allocation guide. If your workload is a coding or tool-using agent running at volume, Grok 4.5 is very likely the correct default — you would need a specific quality gap to justify paying 3–4x per task for a rival. If your workload is a small number of extremely hard reasoning calls where cost is noise, pick the raw-intelligence leader instead. And if you have a hard on-prem requirement, none of these closed models qualify; you are shopping in the open-weights market, and our coverage of models like Kimi K3 is the better starting point. For a sense of where the closed frontier’s ceiling sits, the Claude Opus 5 deep-dive makes a useful upper-bound reference point.
Against its own predecessor the story is cleaner still. Grok 4.5 vs Grok 4.20 is a trade of context length (down from the 1M-class window) for a ~16-point intelligence jump, a from-scratch V9 base, and a step-change in agentic behaviour and token economics. For almost every coding and agent workload, 4.5 is the upgrade; the only reason to stay on the older line is a pipeline that genuinely depends on the larger context.
Practical Recommendations
If you are evaluating Grok 4.5 this quarter, run the decision through economics and workload fit rather than leaderboard position. The model rewards teams that measure cost-per-completed-task, not cost-per-token, and that have the discipline to keep verification in the loop.
A practical checklist:
- Benchmark on your own tasks. Public scores rank models; only your workload ranks them for you. Replicate the token-efficiency claim on a sample of your real issues before trusting the 4x figure.
- Default to low reasoning, escalate deliberately. Use the configurable-reasoning knob to keep high-volume calls cheap and reserve high settings for genuinely hard problems.
- Exploit prompt caching. Stabilise system prompts and pinned context to capture the $0.50 cached-input rate — for RAG and agents this is often the single biggest cost lever.
- Right-size context to 500K. If you are migrating from a million-token pipeline, add a retrieval layer rather than assuming the window will absorb everything.
- Keep a fallback for the hardest 5%. Route the small fraction of frontier-reasoning tasks to a stronger, costlier model; let Grok 4.5 carry the volume.
- Do not deploy where you need self-hosting. Closed weights are a hard stop for data-residency and air-gapped requirements.
Frequently Asked Questions
What is Grok 4.5 and who made it?
Grok 4.5 is xAI’s flagship large language model, released on 8 July 2026. It is a mixture-of-experts model with a reported ~1.5 trillion total parameters and a 500K-token context window, built on xAI’s from-scratch “V9” foundation and tuned specifically for agentic coding and knowledge work. Its defining feature is training on real developer sessions supplied through a partnership with the Cursor code editor, which gives it a top-ranked result on agentic tool use.
How much does Grok 4.5 cost to use?
Grok 4.5 is priced at $2.00 per million input tokens and $6.00 per million output tokens, with cached input at $0.50 per million. That is markedly cheaper than rivals such as Claude Opus 4.8 (reported $5 input / $25 output), and the gap widens once token efficiency is counted: Grok 4.5 reportedly resolves a SWE-bench Pro task in roughly 15,954 output tokens versus about 67,020 for Opus 4.8 in max mode.
What is the Grok 4.5 context window?
Grok 4.5 has a 500K-token context window, about 375,000 words. Notably, that is smaller than the 1-million-token window of the earlier Grok 4.3 — xAI deliberately reduced it to keep attention quality high and to align the ceiling with agentic coding, where 500K comfortably covers a large repository plus tool output. As with all long-context models, retrieval reliability still drops toward the middle of a very full context.
How does Grok 4.5 compare with Grok 4.20?
Grok 4.5 is a from-scratch V9-based model, where Grok 4.20 was a point-release on the older line. The upgrade trades context length (down from a 1M-class window to 500K) for roughly a 16-point jump on the Artificial Analysis Intelligence Index and a step-change in agentic behaviour and token economics. For nearly all coding and agent workloads, 4.5 is the clear upgrade; the exception is a pipeline that genuinely needs the larger context window.
Is Grok 4.5 open source or self-hostable?
No. Grok 4.5 is a closed-weights model available only through xAI’s API, the Grok apps, SuperGrok, and Cursor. There are no published weights, so you cannot self-host, fine-tune on your own data, or run it in an air-gapped or on-prem environment. If those are hard requirements, you should evaluate open-weights alternatives instead.
Is Grok 4.5 the best AI model right now?
No, and it does not try to be. On the Artificial Analysis Intelligence Index it ranks fourth, behind Fable 5, GPT-5.5 and Opus 4.8, and it places third of four on SWE-bench Pro. Its claim is economic: top-ranked agentic tool use, roughly 4x better token efficiency on completed coding tasks, and a fraction of the price. For high-volume coding and agent workloads it is often the best value, even though it is not the highest-scoring model.
Further Reading
- Grok 4.20 Explained: Architecture and Benchmarks — the immediate predecessor in this series, and the baseline Grok 4.5 upgrades from.
- Claude Opus 5 Explained: Architecture and Benchmarks — a reference point for the top of the closed frontier.
- Kimi K3 Explained: Reasoning Model Architecture and Benchmarks — the open-weights alternative for teams that need self-hosting.
- Mixture-of-Experts (MoE) LLM Architecture — the mechanism behind Grok 4.5’s efficiency, explained end to end.
- Artificial Analysis: Grok 4.5 model page — independent intelligence, price and performance tracking.
- Artificial Analysis: Grok 4.5 brings SpaceXAI to the intelligence frontier — the independent analysis behind the headline scores.
By Riju — about
