Grok 4.6: from the intelligence race to turn economics

Grok 4.6 is out.

Normally this is where the familiar model-launch script begins.

Smarter.
Faster.
Better at coding.

Three bars on a chart slightly longer than the other three bars.

Grok 4.6 has all of that. None of it is the interesting part.

What matters is where the improvement is starting to come from.

Start with what they are actually building

Grok 4.6 was released on August 12, 2026, roughly a month after Grok 4.5.

SpaceXAI describes the focus as long-running agents, and more ambitious interactive and visual work.

Researching a topic. Analyzing information. Working across a codebase. Turning an idea into a functioning application.

But there is another detail in this launch that I find more interesting.

Cursor opens its announcement with:

Today we are releasing Grok 4.6 together with SpaceXAI.

Not "Grok 4.6 is now available in Cursor."

Releasing it together.

A model company and an agent product jointly releasing a model is basically the subject of this entire article.

Because the question at the frontier is changing.

It used to be:

How difficult a problem can this model solve?

The more useful question is becoming:

How long can this model continue doing useful work?

That sounds like a small distinction.

What a benchmark used to ask

Hard problem One answer Score

What the work now asks

Open-ended task Fifty turns Recover from three dead ends Still going the right way

It isn't a small distinction at all.

A large part of the agent race is hiding inside it.

Back at the frontier, not above everyone else

Grok 4.6 High scores 61 on the Artificial Analysis Intelligence Index. Grok 4.5 scored 56.

GPT-5.6 Sol Max is also at 61. Fable 5 Max is at 62.

So the right headline isn't "Grok beat everyone."

It's that Grok is back at the frontier.

The Intelligence Index isn't the part I find most interesting anyway.

Things get much more interesting when the model is placed inside an environment.

There are two stories in that grid.

First, the jump from 4.5 to 4.6 is substantial.

Second, Grok does not win everywhere.

In fact one result is particularly uncomfortable given the way the model is being positioned.

That is exactly why it is interesting.

The Terminal-Bench problem

Look at Terminal-Bench 3.0.

Grok 4.6: 26%.
GPT-5.6 Sol Max: 34.6%.
Fable 5 Max: 34.1%.

This is a model explicitly built around long-running agents, and it trails its main competitors on a benchmark centred on sustained terminal work.

If we hide that row and show only CursorBench, we are not reviewing the model. We are doing marketing.

But that result does not end the Grok 4.6 story either.

Different benchmark versions and different agent scaffolds can produce very different pictures of the same model. Artificial Analysis, for example, gets a much stronger Grok 4.6 result on Terminal-Bench v2.1.

It would be wrong to describe that as "26% in one place and 88% in the same test somewhere else." They are not the same test. The benchmark version, the task set and the evaluation setup all differ.

The more interesting conclusion is this:

Knowing the model name is no longer enough to predict agent performance.

Change the benchmark version.
Change the harness.
Change the tool definitions.
Change context management.
Change the execution loop.

And the result can move dramatically.

Which brings us to the most interesting part of Grok 4.6.

Models are learning to live inside the harness

There is an easy-to-miss detail in how SpaceXAI describes training Grok 4.6.

The model received a longer supplemental training run than Grok 4.5, using curated model-generated reasoning data, high-quality engineering data, and an improved optimizer and recipe.

Then Grok 4.5 was used to regenerate SFT trajectories.

Not only across different reasoning efforts. Across different agent harnesses.

The reinforcement learning stage also included environments for general coding, kernel optimization, web development and CAD.

That matters.

Models are not only learning to produce better answers anymore. They are learning how to operate inside a harness.

Call a tool Inspect the result Decide again Recover when it breaks Hold the task across the trajectory Verify before declaring success

The transition from chatbot to agent is not happening only in the product interface.

It is reaching all the way down into the training pipeline.

Then CursorBench updated

After the release, Cursor's live CursorBench 3.2 leaderboard was updated with Grok 4.6.

This is where it gets genuinely interesting.

You can look at the score column and say Grok won.

I think that is the wrong column.

Look at steps and cost.

Fable 5 Max gets 70.5% in 72 steps at $17.32 per task.
Grok 4.6 Extra High gets 70.8% in 46 steps at $2.81.
Grok 4.6 High gets 69.9% in 39 steps at $2.34.
GPT-5.6 Sol Max reaches 67.2% in 48 steps at $5.69.

None of this means Grok is universally six times cheaper for real work. It is one benchmark, one harness, one task distribution.

But it demonstrates something important.

Price per token is becoming an insufficient way to think about agent economics.

From token economics to turn economics

A coding agent does not answer one prompt.

Read a file Search Write code Run the tests Read the error Realize an assumption was wrong Backtrack Run the tests again

Maybe it does this fifty times.

So putting two models' input-token prices side by side tells us a fraction of the real cost.

What the pricing page compares

• price per million input tokens
• price per million output tokens

What the bill is actually made of

• model price
• context growth
• number of turns
• recovery cost

An expensive model that finishes in twenty turns can be cheap.

A cheap model that needs 150 tool calls, three dead ends and a giant context window can be expensive.

One of the important metrics of the next phase will be cost per successful task, not cost per token.

And even that will not be enough. We will want turns per successful task, tokens per successful task, recovery rate, verification rate, wall-clock time.

Because an agent's cost does not end with the inference bill.

It burns time.
It produces bad work.
Sometimes it puts the human back into the loop.

AA-Briefcase makes the same point

Artificial Analysis' AA-Briefcase evaluation is interesting here because it measures longer-running knowledge work.

Grok 4.6 scores 1577 Elo. That is roughly Fable 5 territory, and ahead of GPT-5.6 Sol Max.

But the Elo number is not the interesting part.

Artificial Analysis reports Grok 4.6 completing tasks in roughly 53 turns and 0.5 billion input tokens, against roughly 103 turns and 2 billion input tokens for Claude Opus 5 Max.

It would be irresponsible to turn one benchmark into "Grok is twice as efficient."

But the underlying problem is real.

We need to evaluate an agent not only on whether it eventually reaches the right answer, but on how much nonsense it produces on the way there.

That is where a large part of the next model economy will be decided.

$2 / $6 is attractive, with three asterisks

Standard Grok 4.6 API pricing starts at $2 per million input tokens and $6 per million output tokens.

The model has a 500K context window and configurable reasoning effort from low through xhigh.

For a frontier model, that is aggressive. But the headline price has three details underneath it.

1. Fast costs twice as much

There is a lower-latency fast variant. It costs twice the standard rate.

So $2 / $6 becomes $4 / $12.

2. Pricing changes at 200K context

Once the prompt reaches 200K tokens, long-context pricing takes over. Input becomes $4, output becomes $12, cached input becomes $1.

Charging only the tokens above 200K at the higher rate would be the intuitive implementation.

That is not how it works. Once the threshold is reached, every token in the request is billed at long-context rates.

That is rather important for something positioned as a long-running agent model. As the session grows, the number on the pricing page may stop being your real price.

3. Cache got more expensive

This is my favourite detail.

Roughly a 67% increase, easy to miss while the headline input and output prices stay unchanged.

For long-running agents, cache is not a footnote. Persistent sessions, large system prompts, tool definitions and reused context make it part of the economics of the product.

So some long-running workloads may not be as cheap on 4.6 as the headline suggests.

Which brings us back to the same point.

A cheaper model does not make bad context architecture cheap.

Compaction, selective retrieval, state management and what you resend on every turn are becoming product-economics decisions.

Is the model getting better, or is the harness?

This is one of the biggest problems with model comparisons in 2026.

We see Grok in CursorBench. GPT inside Codex. Claude inside Claude Code.

Then we put the scores next to each other and ask which model is better.

But an agent's output is no longer just model output. It is closer to the whole system: model, system prompt, tools, context management, retry strategy, compaction, execution environment, verification loop.

One model

Harness AOwn tools
Own context rules

Harness BOwn retry policy
Own compaction

Harness COwn verification
Own environment

Three different scores

There is research pointing in the same direction.

ISO-Bench, published in February 2026, evaluated coding agents on 54 real inference-optimization tasks taken from vLLM and SGLang. One of its most interesting findings was that agents using the same underlying model could perform substantially differently.

The researchers' conclusion is hard to ignore: scaffolding can be as important as the model itself.

Grok 4.6 is a nice real-world example.

Cursor is not a neutral frontend sitting on top of the model. Grok 4.5 was already jointly trained with Cursor, using trillions of tokens of Cursor data including developer-agent interactions.

With 4.6 the relationship goes further. SFT trajectories are generated across agent harnesses. Cursor and SpaceXAI release the model together. Cursor observes and tunes around its long-trajectory behaviour.

These are no longer the same question:

Which model is better?

and

Which model is better inside this harness?

That distinction is going to matter more and more.

Model companies will move closer to harnesses.
Harness companies will move closer to model training.
Agent runtimes will become RL environments.

The boundary between model and product will keep blurring.

Self-verification isn't a small feature

One of the most interesting lines in Cursor's announcement is not in the benchmark table.

Cursor says that on longer trajectories they started seeing more self-testing and verification, with the model checking its own work before moving on.

We should not overstate this. It is an observation from Cursor, not an independent benchmark.

But the direction matters.

The next major improvement in coding agents may not come from writing better code. It may come from getting better at rejecting their own bad work.

Run the test.
Inspect the result.
Check the requirement again.
Notice that something doesn't work.
Don't say "completed" until the task is complete.

The most frustrating thing about today's coding agents isn't that they can't write code. They often write perfectly decent code.

The problem is that they don't know when to stop.

They declare partially completed work finished.
They move on with broken tests.
They implement something adjacent to the requirement and decide the job is done.

That is why self-verification could be worth more than another few benchmark points.

But 26% on Terminal-Bench 3.0 is a useful reminder: this problem is nowhere near solved.

So, is Grok 4.6 the best model?

I don't know.

More importantly, I am not convinced that is a useful question anymore.

CursorBench currently puts Grok 4.6 at the top.
GPT-5.6 Sol Max is significantly ahead on DeepSWE.
Grok trails on Terminal-Bench 3.0.
It is very strong on GDPVal-AA.
It is around Fable 5 territory on AA-Briefcase.

Change the harness and the ranking may move again. Change reasoning effort. Change the tools. Change the task distribution. It moves again.

In 2026, opening one leaderboard and declaring this is the best AI model in the world is becoming increasingly meaningless.

What I want to know is the workload.

What are you asking it to do?
Inside which harness?
For how many hours?
How much context will it carry?
How many turns does it need?
Can it recover from a bad path?
Does it verify its own work?

And after all of that:

How much does a successfully completed task actually cost me?

My takeaway

The interesting thing about Grok 4.6 isn't its 70.8% on CursorBench. It isn't the 61 on the Intelligence Index either.

The real signal is this:

As frontier models converge, competition is moving from raw intelligence toward economically sustainable work.

I don't need an agent to produce the world's smartest answer at every step. If it is going to work for hours, I need it to use the right tools, avoid bloating its context, recover from mistakes, verify its work, and do all of that economically.

Grok 4.6 looks very strong in that race.

Does it win? On some workloads, yes. On others, clearly not.

That is exactly how these models should be evaluated.

Because models aren't competing only for chatbot subscriptions anymore.

Routers select models per task.
Coding agents make dozens of inference calls.
Background agents run for hours.
Multi-agent systems can turn one request into several model sessions.

In that world, model selection will increasingly be done not by brand loyalty, but by accounting.

And that accounting will not be as simple as asking how much a million tokens costs.

The question will be:

How much does it cost me to complete the same job reliably?

Grok 4.6's most interesting contribution is forcing that question into the foreground.

Another model may take the top spot on CursorBench in a few weeks. It probably will.

That part isn't very important.

The more durable shift is this:

The model race is slowly becoming a race in turn economics.

And the winner may not be the model that gives the most impressive answer once.

It may be the one that can keep moving in the right direction for the longest.