Grok 4.5 Benchmarks: What xAI Published, and How to Read It

xAI launched Grok 4.5 on July 8, 2026 with four coding benchmarks and one efficiency chart. Here is how to read the published numbers, identify the missing context, and run a small private benchmark before switching models.

Try Apidog today

The short version: Grok 4.5 benchmarks like a strong tier-two coding model. It splits results with Claude Opus 4.8, trails the frontier models, and its strongest published claim is output efficiency rather than raw accuracy.

Every number xAI published

From the announcement, xAI published four coding benchmark charts.

DeepSWE 1.0 pass@1

Model	Score
Claude Fable 5 (max)	66.1%
GPT 5.5 (xhigh)	64.31%
Grok 4.5	62.0%
Claude Opus 4.8 (max)	55.75%
Claude Opus 4.7 (max)	40.12%

DeepSWE 1.1

Model	Score
Claude Fable 5 (max)	70%
GPT 5.5 (xhigh)	67%
Claude Opus 4.8 (max)	59%
Grok 4.5	53%
GLM 5.2	44%

Terminal Bench 2.1

Model	Score
Claude Fable 5 (max)	84.3%
GPT 5.5 (xhigh)	83.4%
Grok 4.5	83.3%
Claude Opus 4.8 (max)	78.9%
Claude Opus 4.7 (max)	78.9%

SWE Bench Pro resolve rate

Model	Score
Claude Fable 5 (max)	80.4%
Claude Opus 4.8 (max)	69.2%
Grok 4.5	64.7%
Claude Opus 4.7 (max)	64.3%
GLM 5.2	62.1%
GPT 5.5 (xhigh)	58.6%

xAI also published an efficiency chart: 15,954 average output tokens per SWE Bench Pro task for Grok 4.5, versus 67,020 for Opus 4.8 (max). That is a 4.2x difference.

Where the benchmark numbers come from

The fine print on xAI’s charts matters:

• DeepSWE 1.0 was “created by Datacurve, run with each model provider’s harnesses by AA.”
• DeepSWE 1.1 used the “mini-swe-agent harness run by Datacurve.”
• “Competitor figures are drawn from the respective developers’ published system cards or benchmark leaderboards.”

In practice, this is a benchmark mosaic:

• Some results come from third-party eval work.
• Some competitor numbers come from vendors’ own published pages.
• Harnesses, scaffolding, and effort settings are not identical across every model.
• No independent external source had published Grok 4.5 numbers yet.

Datacurve’s involvement adds credibility, but this is still not the same as a single independent benchmark run under one harness.

How to read the charts

1. Grok 4.5 vs Claude Opus 4.8 is a real split

Against Claude Opus 4.8, Grok 4.5 has:

• 2 wins
  • DeepSWE 1.0: +6.25 points
  • Terminal Bench 2.1: +4.4 points
• 2 losses
  • DeepSWE 1.1: -6 points
  • SWE Bench Pro: -4.5 points

That supports an “Opus-class” framing, but not a stronger claim.

The pattern matters:

• Grok 4.5 wins the terminal-oriented and older evals.
• Opus 4.8 wins the newer, messier repo-level evals.

For a deeper model-by-model comparison, see Grok 4.5 vs Claude Opus 4.8.

2. Grok 4.5 does not beat the frontier models

On xAI’s own charts:

• Claude Fable 5 (max) leads all four published benchmarks.
• GPT 5.5 (xhigh) beats Grok 4.5 on three of four.

So the practical positioning is not “best coding model overall.” It is closer to price-performance and output efficiency.

For more context on Fable’s numbers, see our Fable 5 benchmark analysis.

3. The upgrade is real, but workload-dependent

Grok 4.5’s edge over models like GLM 5.2 is around 9–11 points on the two shared benchmarks. GLM 5.2 also costs a fraction as much, so capability-per-dollar depends on your task mix.

If you are choosing a model for production coding agents, do not compare only headline scores. Compare:

• resolve rate on your tasks
• latency
• output tokens
• cost per successful task
• failure modes
• required retries

The key metric: output tokens per task

The most important published number is the efficiency chart.

xAI claims:

• Grok 4.5: 15,954 average output tokens per SWE Bench Pro task
• Claude Opus 4.8 (max): 67,020 average output tokens per SWE Bench Pro task
• Difference: 4.2x fewer output tokens
• Delivery speed: 80 tokens per second

This matters because output tokens affect both cost and latency. In an agent loop, the cost compounds across planning, tool calls, retries, diffs, and explanations.

A model that scores 4.5 points lower on SWE Bench Pro can still be the better production choice if it completes enough tasks with far fewer output tokens. That trade-off is quantified in our pricing analysis.

Two caveats:

1. The efficiency result is vendor-measured on one benchmark.
2. Longer outputs are not always waste. Opus’s longer responses include extended reasoning, which may contribute to its stronger results on the repo-level evals.

Treat efficiency as a measurable trade-off, not a free win.

What is still missing

Before making a production switch, account for these gaps:

• No independent third-party evaluation yet
  
  No Artificial Analysis intelligence index entry, no LMArena placement, and no community SWE-bench replication as of July 9.

• Coding-only benchmarks
  
  xAI published no general reasoning, math, science, or safety benchmarks for a model it also markets for knowledge work.

• No effort-mode disclosure for Grok 4.5
  
  Competitor settings are labeled, such as max and xhigh. xAI does not state whether Grok 4.5’s scores use default or maximum configuration.

• Week-one launch risk
  
  Early model releases often have regressions, serving instability, and quiet behavior changes during the first month.

Run your own benchmark instead

Public benchmarks are useful for direction. They do not tell you whether a model works for your codebase.

A lightweight private eval is usually enough for a switching decision.

Step 1: Pick real tasks

Collect 10–20 representative tasks from your backlog.

Good candidates:

• failing tests that need a fix
• small refactors
• API integration changes
• bug reports with clear reproduction steps
• dependency upgrade issues
• documentation-to-code implementation tasks

For each task, save:

• prompt
• repository context
• expected behavior
• test command
• acceptance criteria

Example task format:

## Task

Fix the pagination bug in the `/users` endpoint.

## Context

The API returns duplicate users when `page=2&limit=20`.

## Expected outcome

- No duplicate users across pages
- Existing tests still pass
- Add or update a regression test

## Validation

Run:

bash
npm test -- users.pagination.test.ts

Step 2: Use one request template per model

In Apidog, create a saved request for each candidate model.

Because xAI and Anthropic expose OpenAI-compatible surfaces, you can use one collection and swap the model with a variable.

Example request body:

{
  "model": "{{model}}",
  "messages": [
    {
      "role": "system",
      "content": "You are a coding assistant. Produce minimal, correct patches. Explain assumptions briefly."
    },
    {
      "role": "user",
      "content": "{{task_prompt}}"
    }
  ],
  "temperature": 0.2
}

Then test values such as:

model=grok-4.5
model=your-current-model

Step 3: Capture usage and latency

For each run, record:

• task ID
• model
• pass/fail
• reviewer score
• latency
• input tokens
• output tokens
• total tokens
• retry count

The important field is the usage object returned by the model API. Store it with the result so you can calculate cost per accepted output, not just cost per request.

Example result schema:

{
  "task_id": "users-pagination-001",
  "model": "grok-4.5",
  "passed": true,
  "latency_ms": 18420,
  "usage": {
    "prompt_tokens": 8200,
    "completion_tokens": 3100,
    "total_tokens": 11300
  },
  "notes": "Passed regression test after one response."
}

Step 4: Score outputs blind

If possible, hide model names from reviewers.

Score each output on:

Criterion	Question
Correctness	Does it solve the task?
Testability	Are tests included or updated?
Minimality	Is the patch focused?
Maintainability	Is the code easy to review?
Safety	Did it avoid unrelated changes?
Cost	How many output tokens did it use?

A simple scoring rubric is enough:

0 = unusable
1 = partially useful but needs major edits
2 = mostly correct with minor edits
3 = accepted as-is

Step 5: Compare cost per accepted task

Do not compare only average token count. Compare token usage for tasks that pass.

Use:

cost_per_accepted_task =
  total_cost_for_model / number_of_accepted_outputs

Also track:

avg_output_tokens_per_accepted_task =
  total_output_tokens_for_accepted_outputs / accepted_outputs

This is where xAI’s efficiency claim becomes testable. If Grok 4.5 is not meaningfully shorter on your prompts, the headline economics may not apply to your workload.

You can Download Apidog free and build the harness quickly. Setup details for xAI are in our Grok 4.5 API guide.

FAQ

What benchmarks did xAI publish for Grok 4.5?

xAI published four coding evals:

• DeepSWE 1.0
• DeepSWE 1.1
• Terminal Bench 2.1
• SWE Bench Pro

It also published a token-efficiency comparison against Claude Opus 4.8. xAI did not publish non-coding benchmarks in the announcement.

Are there independent Grok 4.5 benchmarks?

Not yet. The published figures mix Datacurve-run evals with numbers from other vendors’ system cards or benchmark leaderboards. Independent indexes typically arrive after launch.

Does Grok 4.5 beat Claude Opus 4.8?

On two of four published benchmarks, yes. Opus 4.8 wins the two harder repo-level evals. Grok 4.5’s main advantage is lower output volume and cost. See the full comparison.

Is Grok 4.5 the strongest coding model available?

No. xAI’s own charts show Claude Fable 5 (max) leading every published benchmark. Grok 4.5 is positioned more around intelligence per dollar and output efficiency.