Grok 4.5 Explained: Coding Benchmarks, 80 TPS, Token Efficiency, and API Pricing

Introduction

Grok 4.5 puts xAI back into the front row of the coding-model race.

Released on July 8, 2026, the model is designed for software engineering, agentic tasks, and broader knowledge work. It was trained with Cursor and is now available through the xAI API, Grok Build, and Cursor. The headline is not only model quality. Grok 4.5 is also positioned around faster serving, fewer generated tokens, and a lower cost per completed task.

The official model documentation lists a 500,000-token context window, text and image input, configurable reasoning, function calling, structured output support, and API pricing of $2 per million input tokens** and **$6 per million output tokens.

This article explains where Grok 4.5 performs well, how its efficiency claims should be interpreted, what changed in training, and why the surrounding inference stack may become just as important as the model itself.

Grok Gets Its Own Opus-Class Coding Model

Grok 4.5 is xAI's flagship model for coding, agentic work, and general computer-based knowledge tasks. The official launch materials describe it as a model that can handle long-running work, use tools, recover from errors, and verify results instead of stopping after a single response.

That places it in the same broad category as high-end models used for autonomous coding, repository-level changes, technical research, data analysis, and multi-step office workflows.

Core Model Specifications

Item	Grok 4.5
Model name	grok-4.5
Primary use cases	Coding, agentic tasks, knowledge work
Input modalities	Text and images
Output modality	Text
Context window	500,000 tokens
Reasoning	Configurable
Function calling	Supported
Structured outputs	Supported
Input price	$2 per 1M tokens
Cached input price	$0.50 per 1M tokens
Output price	$6 per 1M tokens
Reported serving speed	Up to 80 tokens per second
Availability	xAI API, Grok Build, Cursor

The 500K context window is large enough for substantial codebases, long technical documents, multi-file investigations, and extended agent histories. A large context window does not automatically guarantee better results, but it gives tools more room to provide relevant source material without aggressive truncation.

Coding Benchmark Results

The official xAI announcement publishes results across several software-engineering evaluations. Grok 4.5 is not the top model on every benchmark, but it remains competitive with other frontier systems.

Benchmark	Grok 4.5	Selected comparison results
DeepSWE 1.0	62.0%	Fable max 66.1%; GPT-5.5 xhigh 64.31%; Opus 4.8 max 55.75%
DeepSWE 1.1	53.0%	Fable max 70%; GPT-5.5 xhigh 67%; Opus 4.8 max 59%
Terminal-Bench 2.1	83.3%	Fable max 84.3%; GPT-5.5 xhigh 83.4%; Opus 4.8 max 78.9%
SWE-Bench Pro	64.7%	Fable max 80.4%; Opus 4.8 max 69.2%; Opus 4.7 max 64.3%
SWE Marathon	29.0%	Opus 4.8 max 26.0%; Fable max 24.0%; Opus 4.7 max 16.0%

These numbers suggest a model that is especially strong on terminal work, practical engineering tasks, and longer agentic workflows. They should still be read carefully. Benchmark harnesses, reasoning settings, tool access, and provider-specific configurations can affect the outcome.

Cursor also disclosed that an older snapshot of the Cursor codebase was accidentally present in training data, which could influence CursorBench. The company excluded that benchmark from its public comparison and said the data would not be used for future models.

Faster Serving and Lower Token Use

The most practical claim around Grok 4.5 is efficiency.

xAI says the model is served at up to 80 tokens per second. That is fast enough to make long reasoning traces, repository edits, and iterative agent loops feel more responsive than slower premium models.

The company also reports that Grok 4.5 used an average of 15,954 output tokens per SWE-Bench Pro task, compared with 67,020 output tokens for Opus 4.8 at its maximum setting. That works out to roughly 4.2 times fewer output tokens on the measured workload.

Token efficiency matters for three reasons:

1. Lower latency: fewer generated tokens usually mean the task finishes sooner.
2. Lower API cost: output tokens are often more expensive than input tokens.
3. Shorter agent loops: concise reasoning can reduce the time spent passing large histories between tools.

The important metric is not simply price per million tokens. Teams should compare the cost of completing the same task at an acceptable quality level. A model with a higher listed token price can still be cheaper if it needs fewer attempts, fewer tool calls, or fewer generated tokens.

API Pricing

The base API price is:

Token type	Price
Input	$2 per 1M tokens
Cached input	$0.50 per 1M tokens
Output	$6 per 1M tokens

Cursor also lists a faster variant at $4 per million input tokens** and **$18 per million output tokens inside its own model offering. Pricing and availability may differ by platform, so production teams should confirm the rate in the environment they actually use.

From Code Generation to Full Workflows

Grok 4.5 is meant to do more than complete a function or explain an error. The official examples include:

• Building a solar-system simulation from one prompt
• Creating end-to-end web applications
• Producing PowerPoint slides with native shapes
• Constructing multi-sheet spreadsheet models
• Working across software engineering, finance, legal, and research tasks
• Using tools over long-running agent sessions

The solar-system demo is useful because it combines design, front-end code, 3D rendering, controls, and interaction logic. It is not proof that every one-prompt application will be production-ready, but it shows the kind of integrated task the model is being optimized to handle.

Grok 4.5 also extends into office work. In the launch materials, it creates structured business-review slides and works with spreadsheets that involve formulas, web research, and multiple sheets.

For development teams, a practical workflow may look like this:

1. Give Grok 4.5 the repository context and a clearly scoped task.
2. Let it inspect files, implement the change, and run validation commands.
3. Require it to provide a concise change summary and evidence from tests.
4. Review the patch with a human or a second model before merging.
5. Keep production deployment and sensitive operations behind explicit approval.

A model can be fast and capable while still producing incorrect assumptions, unsafe changes, or incomplete validation. The best use of agentic coding models is usually structured automation with visible evidence, not unrestricted autonomy.

Efficiency Gains Come From a Different Training Strategy

The efficiency gains are not presented as a simple serving optimization. Both xAI and Cursor describe changes across model architecture, data preparation, reinforcement learning, and distributed training.

Mixture-of-Experts Architecture

Cursor describes Grok 4.5 as a mixture-of-experts model. In a MoE system, only part of the network is activated for a given token or task. This can increase total model capacity without requiring every parameter to participate in every inference step.

The official sources do not publish enough implementation detail to calculate the exact compute used per token. It is therefore more accurate to focus on measured behavior—speed, benchmark quality, and token consumption—than to infer performance from an unverified parameter count.

Training at GB300 Scale

xAI says Grok 4.5 was trained across tens of thousands of NVIDIA GB300 GPUs. Training at this scale requires more than raw hardware. Long runs need stable distributed systems, checkpoint recovery, networking, data pipelines, and monitoring that can keep thousands of accelerators productive.

The announcement emphasizes stability techniques designed for very large training runs. This matters because a failure in a long experiment can waste a large amount of compute if the system cannot recover efficiently.

Better Data Density, Not Just More Tokens

The training pipeline included:

• Large-scale deduplication
• Quality scoring
• Domain-focused filtering
• High-signal data selection
• A broader mix of coding, science, engineering, mathematics, and knowledge-work material

The objective is to improve the density of useful training signals instead of relying only on raw token volume. Repeated, low-quality, or weakly relevant data can increase training cost without providing the same improvement as carefully selected examples.

Cursor Interaction Data

Cursor says the model was trained with trillions of tokens of Cursor data. According to the company, the dataset captures interactions between users, codebases, software tools, and agents.

This distinction is important. A code-only dataset teaches syntax, patterns, libraries, and common implementations. Interaction data can also teach the sequence of work:

• How developers inspect an unfamiliar repository
• Which files they open before making a change
• How they respond to test failures
• When they use terminal commands
• How they revise a patch after feedback
• How an agent interacts with tools and its environment

That helps explain why Grok 4.5 is positioned around software engineering rather than isolated code completion.

Reinforcement Learning on Difficult, Realistic Tasks

xAI says its reinforcement-learning program covers hundreds of thousands of tasks, with a focus on multi-step software engineering and other technical work.

Cursor describes environments that train the model to:

1. Explore the problem
2. Use tools
3. Recover from mistakes
4. Verify the result
5. Continue working across long task horizons

The companies also built distributed agent systems to generate, test, and refine these training environments at scale. Some agent rollouts can run for hours while the larger training process continues asynchronously.

This is a meaningful change from narrow benchmark optimization. The model is being trained not only to produce a correct final answer, but to navigate the process that leads to one.

One More Thing: Systems Engineering May Be the Next Battleground

Model weights are only one part of the final product.

A public statement from Elon Musk said Grok 4.5 was not yet using xAI's internally developed C/C++ inference software mapped specifically to GB300 hardware. He suggested that the optimized stack could potentially double serving speed or improve it further.

This is a forward-looking claim rather than a measured production result, so it should not be treated as guaranteed performance. Still, it highlights where model competition is moving.

When frontier models become closer in benchmark quality, the surrounding system can create the practical advantage:

• Kernel and compiler optimization
• Request scheduling
• Mixture-of-experts routing
• Quantization
• Memory management
• Prompt caching
• Batch processing
• Hardware-specific inference code
• Agent orchestration
• Tool latency and reliability

For users, this means model comparisons should include more than a single intelligence score. A model that responds faster, produces fewer tokens, uses caching effectively, and completes tasks with fewer retries may deliver better real-world value even when another model leads on a benchmark.

Getting Started with the Grok 4.5 API

Grok 4.5 is available through xAI's Responses API. The following Python example uses the OpenAI-compatible client interface:

import os
from openai import OpenAI

api_key = os.environ.get("XAI_API_KEY")
if not api_key:
    raise RuntimeError("Set the XAI_API_KEY environment variable first.")

client = OpenAI(
    api_key=api_key,
    base_url="https://api.x.ai/v1",
)

response = client.responses.create(
    model="grok-4.5",
    input=(
        "Review this JavaScript function, fix the bug, "
        "and explain the change: "
        "function median(values) { values.sort(); "
        "return values[values.length / 2]; }"
    ),
)

print(response.output_text)

Before using the model in production:

1. Store the API key in an environment variable or secret manager.
2. Add timeouts and retry handling.
3. Log token usage and total request cost.
4. Validate tool calls before execution.
5. Require approval for destructive or production-impacting actions.
6. Pin a dated model version when deterministic behavior matters.

FAQ

What is Grok 4.5?

Grok 4.5 is xAI's frontier model for coding, agentic tasks, and knowledge work. It supports text and image input, configurable reasoning, function calling, and structured outputs.

How large is the Grok 4.5 context window?

The official xAI model documentation lists a 500,000-token context window. Actual usable context may depend on request format, tool output, and platform-specific limits.

How much does the Grok 4.5 API cost?

The published base price is $2 per million input tokens, $0.50 per million cached input tokens, and $6 per million output tokens. Platform-specific variants or priority serving may use different rates.

Is Grok 4.5 better than Claude Opus for coding?

The answer depends on the benchmark and workflow. Grok 4.5 is competitive on several engineering tests and leads some comparisons, while other models remain ahead on others. Speed, token use, tool reliability, and task-completion cost should be evaluated alongside benchmark scores.

Why is Grok 4.5 described as token-efficient?

xAI reports that Grok 4.5 used 15,954 output tokens per SWE-Bench Pro task on average, compared with 67,020 for Opus 4.8 at its maximum setting. That is about 4.2 times fewer output tokens for the measured workload.

Can Grok 4.5 process images?

Yes. The official model page lists text and image input with text output. This makes it suitable for tasks such as screenshot analysis, document review, and visual context inside an agent workflow.

Is Grok 4.5 available in Cursor?

Yes. Cursor says Grok 4.5 is available across its desktop, web, iOS, CLI, and SDK experiences. Usage allowances and pricing depend on the selected Cursor plan.

Is Grok 4.5 suitable for production agents?

It can be used as the reasoning model inside a production agent, but the surrounding system still needs permission controls, validation, observability, retries, and human approval for high-impact actions. Benchmark strength does not remove the need for operational safeguards.

Related Tools

• xAI API Console: Create API keys, manage credits, and access xAI models.
• Cursor: An AI coding environment that includes Grok 4.5 across multiple products.
• Grok Build: xAI's agentic coding environment powered by Grok 4.5.
• xAI Python SDK: The official Python SDK for building with xAI models.
• OpenAI Python Library: A compatible client library that can call the xAI Responses API through a custom base URL.

Related Links

• Introducing Grok 4.5: The official xAI launch announcement with benchmarks, training details, speed, and pricing.
• Grok 4.5 Model Documentation: Official specifications for context length, modalities, capabilities, and token pricing.
• Grok 4.5 Developer Guide: Official API examples and integration guidance.
• xAI Pricing: Current model and API pricing from xAI.
• Cursor Introduces Grok 4.5: Cursor's explanation of joint training, interaction data, and reinforcement learning.
• xAI Models: The current xAI model catalog and model-selection guidance.
• xAI Release Notes: Official release history and configuration updates.

Summary

Grok 4.5 is a frontier model aimed at coding, agents, and knowledge work. Its strongest practical advantages are the combination of competitive engineering performance, up to 80-token-per-second serving, a 500K context window, and lower token consumption on the published SWE-Bench Pro comparison.

The training approach combines large-scale infrastructure, curated data, Cursor interaction traces, and reinforcement learning in realistic tool-using environments. That helps move the model from isolated code generation toward longer, end-to-end workflows.

The main story is not only that Grok has become more capable; it is that xAI is competing on the full cost and speed of completing real work.