Grok 4.5 Review: Frontier Coding Power Without the Frontier Price
We spent two days testing the claims around Grok 4.5. It is fast, strong at coding, and unusually token-efficient. It is also easier to misunderstand than the launch headlines suggest.
Grok 4.5 arrives with a simple promise. Opus-class engineering performance at a lower price. Faster output. Fewer tokens. Better economics for agents that may work for hours.
The promise is not empty. Grok 4.5 is close to the leading coding models on several difficult benchmarks. It is served at about 80 tokens per second. Its API price is far below the most expensive frontier systems. On some engineering tests it finishes with dramatically fewer tokens.
But this is not a story about a model winning every chart. Grok 4.5 loses some tests. Its context window is smaller than Grok 4.3. The 500K figure does not mean a 500K output. And one independent knowledge benchmark found that its higher accuracy came with more confident wrong answers.
What is Grok 4.5?
SpaceXAI launched Grok 4.5 on July 8, 2026. The company describes it as its smartest model for coding, agentic tasks, and knowledge work. It was trained alongside Cursor and became the default model in Grok Build at launch. The official release focuses heavily on real engineering rather than ordinary chat.
The training story follows that focus. SpaceXAI says Grok 4.5 was trained across tens of thousands of NVIDIA GB300 GPUs. Its data covers code, science, engineering, and mathematics. Reinforcement learning included hundreds of thousands of multi-step software engineering and technical tasks.
This matters because a coding agent needs more than syntax. It has to inspect a repository, choose tools, recover from failures, edit files, run tests, and decide whether the result is actually finished. Grok 4.5 is designed around that longer loop.
| Model ID | grok-4.5 |
|---|---|
| Input | Text and images |
| Output | Text |
| Context window | 500,000 tokens |
| Reasoning | Low, medium, or high. High is default |
| Tools | Function calling, web search, X search, code execution, file and collection search |
| Headline speed | About 80 output tokens per second |
| API price | $2 input, $0.50 cached input, $6 output per 1M tokens |
The model supports the Responses API and Chat Completions. SpaceXAI also exposes aliases including grok-4.5-latest and grok-build-latest.
The live model page contains the current technical details.
The benchmark reality
Grok 4.5 is strong enough to compete at the frontier. It is not the clear winner across every test. The official launch page actually shows a more useful picture than a single headline score.
| Benchmark | Grok 4.5 | GPT-5.5 xhigh | Fable max | Opus 4.8 max |
|---|---|---|---|---|
| DeepSWE 1.0 | 62.0% | 64.31% | 66.1% | 55.75% |
| DeepSWE 1.1 | 53.0% | 67.0% | 70.0% | 59.0% |
| SWE Marathon | 29.0% | — | 24.0% | 26.0% |
| Terminal-Bench 2.1 | 83.3% | 83.4% | 84.3% | 78.9% |
| SWE-Bench Pro | 64.7% | 58.6% | 80.4% | 69.2% |
The conclusion is clear. Grok 4.5 is excellent at terminal work and long engineering trajectories. It leads the listed models on SWE Marathon. It beats GPT-5.5 on SWE-Bench Pro. It falls behind Fable and GPT-5.5 on DeepSWE 1.1.
Benchmark harnesses also matter. A model running inside Grok Build is not directly equivalent to another model running in Codex or Claude Code. Tools, prompts, retry logic, context management, and verification can change the final score.
Artificial Analysis gave Grok 4.5 a score of 54 on its Intelligence Index. That placed it fourth at launch behind Fable 5, GPT-5.5, and Opus 4.8. The score was still a 16-point jump over Grok 4.3. The independent analysis places Grok 4.5 on the cost-performance frontier.
Coding, Grok Build, and Cursor
The most convincing Grok 4.5 use case is coding. This model was not merely attached to a code editor after training. SpaceXAI says it was trained alongside Cursor and optimized for long engineering tasks.
Grok 4.5 is the default model in Grok Build. It is available in Cursor on all plans. It also runs through the SpaceXAI API, the Grok Build CLI, and several model gateways.
The official examples range from Rust and C++ work to complete applications created from a single prompt. One-prompt demonstrations should never be confused with production evidence. They do show the intended workflow. The model is expected to move from an outcome to a working artefact rather than stop at an explanation.

On the Artificial Analysis Coding Agent Index, Grok 4.5 in Grok Build scored 76. That was roughly level with GPT-5.5 in Codex and below Fable 5 in Claude Code. The more interesting result was cost. Artificial Analysis estimated about $2.50 per task for Grok 4.5 compared with $5.07 for GPT-5.5 and $11.80 for Fable 5 in their respective agent environments.
Grok 4.5 does not need to be the smartest model on every prompt. It needs to finish enough verified work to win on cost per task.
Reasoning effort changes the economics
Grok 4.5 supports three reasoning levels. Low, medium, and high. High is the default. Reasoning cannot be disabled. SpaceXAI documents the behaviour of each setting.
| Setting | Use it for | Tradeoff |
|---|---|---|
| Low | Simple tool calls, small code changes, latency-sensitive agents | Less exploration and checking |
| Medium | Data analysis, longer context, normal engineering work | More time and reasoning tokens |
| High | Difficult debugging, architecture, mathematics, multi-step logic | Highest latency and usage |
A practical workflow starts with low or medium for well-scoped implementation. Move to high when the model needs to explore several hypotheses or when a wrong change would be expensive.
Leaving every request on high can erase part of the cost advantage. Reasoning tokens are part of billed usage. Long agent loops can also trigger more tools and carry more history into later requests.
Speed and token efficiency are the real story
SpaceXAI serves Grok 4.5 at about 80 output tokens per second. That puts it closer to an interactive fast model than a slow premium reasoning system.
On SWE-Bench Pro, the company reports an average of 15,954 output tokens per task. Opus 4.8 max used 67,020 in the comparison. That is about 4.2 times more output tokens for Opus.
Artificial Analysis found a similar pattern across its Coding Agent Index. Grok 4.5 used about 1.9 million total tokens per task in Grok Build. GPT-5.5 used about 6.2 million in Codex. Fable 5 used about 7.2 million in Claude Code.

These numbers do not prove that Grok 4.5 will use four times fewer tokens in your repository. Benchmark tasks have fixed harnesses and controlled environments. They do show that the model's efficiency claim has measurable support.
There is also an important distinction between token efficiency and intelligence. A model can spend fewer tokens because it found the shortest correct path. It can also spend fewer tokens because it stopped too early. Always pair cost data with tests and success rates.
The 500K context window and the hidden cost boundary
Grok 4.5 has a 500,000 token context window. This is smaller than the one-million-token window of Grok 4.3.
SpaceXAI also marks a higher-context pricing boundary at 200,000 tokens. Requests that cross that level are billed at different rates. Artificial Analysis reports that the token rates double beyond the threshold.
This creates a practical cost trap. A 500K window makes it easy to keep adding files and conversation history. That does not mean you should. A long agent loop repeatedly resends context. One oversized prompt can therefore affect every later step.
For long Grok 4.5 workflows:
- Keep the active context below 200K when the extra material is not essential
- Set a stable
prompt_cache_keyso requests reach the same server and cache hits remain reliable - Use context compaction for long agent loops
- Summarize completed stages instead of carrying every raw tool result
- Load only relevant repository folders
- Track total tokens per completed task, not only the first request
A large context window is useful capacity. It is not free memory.
Grok 4.5 API pricing
At standard context levels, Grok 4.5 is priced at $2 per million input tokens, $0.50 per million cached input tokens, and $6 per million output tokens. The SpaceXAI pricing documentation also lists tool charges and higher-priority processing.
| Usage | Price per 1M tokens |
|---|---|
| Input | $2.00 |
| Cached input | $0.50 |
| Output | $6.00 |
cost = (input_tokens / 1,000,000 × $2.00)
+ (output_tokens / 1,000,000 × $6.00)
+ tool costs
+ any higher-context or priority multiplier
A request with 100,000 uncached input tokens and 10,000 output tokens would cost about $0.26 before tools. That is $0.20 for input and $0.06 for output.
Server-side tools add separate charges. Web search, X search, and code execution cost $5 per 1,000 calls. Attachment search costs $10 per 1,000 calls. Collections search costs $2.50 per 1,000 calls. Priority processing applies a two-times premium to token pricing.
The nominal token price is only the start. The best production measure is cost per verified outcome. Include retries, reasoning tokens, tool calls, context growth, and human review.
Grok 4.5 for Excel, PowerPoint, and Word
The launch is marketed around coding. SpaceXAI also places Grok 4.5 at the centre of its Office workflow.
Grok Build can research the web, create multi-sheet Excel models, write formulas, and leave notes for future work. In PowerPoint, the model can use native shapes and editable slide elements. In Word, it can turn research and rough notes into formatted prose.

This may be more valuable to many businesses than another coding benchmark. A financial model or executive deck becomes useful when it remains editable, follows the template, and shows where the numbers came from.
The same verification rule still applies. Check formulas. Check citations. Check chart ranges. Confirm that a slide's conclusion matches its data.
What the launch headlines leave out
It is not the most accurate model on every coding test
Grok 4.5 trails Fable max and GPT-5.5 xhigh on DeepSWE 1.1. It also trails Fable and Opus 4.8 on SWE-Bench Pro. Its advantage is the combination of high performance, speed, and lower cost.
The knowledge gains come with a warning
Artificial Analysis reports that Grok 4.5 improved from 35% to 52% accuracy on its Omniscience Index compared with Grok 4.3. On that same benchmark, the measured hallucination rate increased from 25% to 54%.
This is not a universal 54% hallucination rate. It is a benchmark-specific result. It still suggests a real risk. Grok 4.5 may know more while sounding more confident when it is wrong.
The public evidence is still young
Grok 4.5 launched on July 8. Most public commentary is still launch-day analysis or short tests. There is not yet enough independent production evidence to make strong claims about long-term reliability, model drift, or behaviour under sustained load.
Safety documentation is limited
As of publication, the Grok 4.5 launch page does not link a dedicated model-specific system card with detailed safety evaluations. That does not prove the model is unsafe. It means outside reviewers have less evidence for evaluating those claims.
For production use:
- Require tests before merging code
- Keep destructive actions behind explicit approval
- Run agents in restricted environments
- Verify factual claims through source documents
- Track failures by task category
- Do not treat a confident completion message as proof
Where Grok 4.5 is available
Grok 4.5 launched across several developer and productivity surfaces:
- Grok Build as the default coding model
- Cursor on all plans
- The SpaceXAI API and console
- Word, PowerPoint, and Excel add-ins
- OpenRouter, Vercel, Cloudflare, Snowflake, and Databricks Mosaic
SpaceXAI also listed Grok 4.5 under the $30-per-month SuperGrok plan. Limited free Grok 4.5 usage was offered in Grok Build and Cursor at launch.
Regional availability is a moving target. The model was not yet available in SpaceXAI products or the API console for EU users at launch. SpaceXAI said EU availability was expected later in July. Check the live documentation before publishing or integrating.
Grok 4.5 vs Grok 4.3
A newer model is not automatically the best choice for every production request. Grok 4.3 remains cheaper per token and has a larger context window.
| Property | Grok 4.5 | Grok 4.3 |
|---|---|---|
| Primary role | Frontier coding and agentic work | General production model |
| Context | 500K | 1M |
| Input price | $2.00 | $1.25 |
| Cached input | $0.50 | $0.20 |
| Output price | $6.00 | $2.50 |
| AA Intelligence gain | +16 points over 4.3 | Baseline |
Choose Grok 4.3 when a one-million-token window or lower unit price matters more than maximum engineering capability. Choose Grok 4.5 for harder code, terminal work, multi-step agents, and tasks where better success per attempt can offset the higher token rate.
How to test Grok 4.5 on your own work
Do not adopt Grok 4.5 because one benchmark looks impressive. Build a small evaluation from work your team has already completed.
Select ten to twenty tasks. Include a bug fix, a repository-wide change, a tool-heavy research task, a long-context question, a spreadsheet workflow, and a task where the correct answer is already known.
| Measure | What to record |
|---|---|
| Verified success | Did tests, calculations, or source checks pass? |
| Wall-clock time | How long did the full task take? |
| Token use | Input, cached input, reasoning, and output |
| Tool use | How many searches, executions, and file calls were required? |
| Corrections | How many times did a person redirect the model? |
| Manual rework | How much remained after the agent stopped? |
| Total cost | What did one verified completion actually cost? |
Run the same tasks through Grok 4.3 and your current primary model. Keep the harness, tools, permissions, and completion criteria as consistent as possible.
The winning model is not the one with the best prose. It is the one that produces the most verified outcomes for the time and budget you can sustain.
Who should use Grok 4.5?
Software teams
Grok 4.5 is worth testing for difficult implementation, terminal workflows, repository exploration, and long-running coding agents. Its speed makes it more interactive than many premium reasoning models.
Agent builders
The model is especially attractive when tools dominate the workflow. Function calling, web and X search, code execution, context compaction, and structured outputs are available through the API.
Analysts and finance teams
Excel, PowerPoint, Word, and web research are genuine parts of the launch. Use Grok 4.5 when the workflow needs editable deliverables. Keep a human check on formulas and facts.
Teams with simple high-volume tasks
Grok 4.5 may be unnecessary. Grok 4.3 or another smaller model can offer a lower unit price. Frontier capability only saves money when the task uses it.
The honest conclusion after two days
Grok 4.5 is not the best model on every benchmark. It may still be one of the most practical releases of 2026 for engineering teams.
Its value comes from the combination. Near-frontier coding. Fast output. Low API prices. Strong tool use. Fewer tokens per completed task. Direct integration into Grok Build, Cursor, and Office.
The compromises are real. The context window fell from one million to 500K. Long context becomes more expensive after 200K. Knowledge answers still need verification. Public safety evidence and long-term user experience remain limited.
The most accurate description is not “the smartest model.” It is a fast engineering machine with frontier-adjacent intelligence and aggressive economics.
For teams that measure verified outcomes, Grok 4.5 deserves a serious test.
Verification
Comments
0 totalLoading comments...