Did Grok 4.6 catch GPT-5.6? It beats Sol on one benchmark, but real coding users disagree

The short answer

Grok 4.6 has reached GPT-5.6 Sol on some scores, but real Coding users have not reached the same verdict. On CursorBench 3.2, Grok 4.6 High scores 69.9% versus 67.2% for GPT-5.6 Sol Max; both score 61 on the Artificial Analysis Intelligence Index. Switch to DeepSWE 1.1 and Sol leads 73% to 65.9%. On Terminal-Bench 3.0, Sol leads 34.6% to 26%.

This is not “Grok beats Sol everywhere.” It is a more useful contrast: leaderboards measure a particular task, reasoning setting and harness, while real users must ship code with correct edge cases, concurrency behavior and maintainable tests.

Act one: Grok 4.6 really is in the first tier

On August 12, xAI and Cursor released Grok 4.6. The positioning was not a routine chat upgrade, but a model for long-running agents, complex coding, knowledge work and interactive visual projects.

Cursor's public table shows why the launch spread quickly:

• CursorBench 3.2: Grok 4.6 High 69.9%, Sol Max 67.2%;
• FrontierCode 1.1 Extended: 61.3% versus 60.6%;
• APEX-Agents: 57.5% versus 56.7%;
• Artificial Analysis Intelligence Index: 61 for both.

So “Grok 4.6 is a top-tier Coding Agent” is supported by public evidence. It is no longer merely a model catching up by a few points.

But “first tier” and “Sol is beaten everywhere” are not the same claim.

Act two: change the exam and the ranking flips

The same official table reports Sol at 73% and Grok at 65.9% on DeepSWE 1.1. On Terminal-Bench 3.0, Sol scores 34.6% and Grok 26%. Those gaps are more visible than Grok's narrow CursorBench lead.

The reason is straightforward. Agent benchmarks are not one standardized exam: some emphasize cross-file edits, some terminal operation, some long trajectories and software engineering, while others also reflect retrieval, retry and context management in the harness.

So “Grok passed Sol” can be true and misleading at the same time. Ask first: what task, what reasoning setting and what toolchain?

Act three: a 2,500-line backend task exposed the blind spot

After the leaderboard release, one Cursor user put Grok 4.6 Extra High and GPT-5.6 Sol Medium on the same roughly 2,500-line backend feature task, with the same repository, plan and starting point, then asked another model to review the results.

The conclusion was not that Grok failed to finish. It was that Sol had roughly a 60:40 advantage on monetary edge cases, race-condition risk, architecture and test quality.

This is a one-user experiment, not evidence that Sol wins every project. But it surfaces the question benchmarks often hide:

Finishing a task is not the same as shipping code you trust.

Teams also care about error handling, maintenance cost, hidden races, tests written only to pass, and whether a change makes another module harder to reason about. Many benchmarks cannot compress those differences into one binary success score.

The most disruptive number may be cost per successful task

Grok 4.6 starts at $2 per million input tokens and $6 per million output tokens through the API; the fast variant costs twice as much. Cursor also reports a CursorBench High result of about 69.9%, $2.34 per task, 32,449 tokens and 39 steps.

The community has separately compiled an estimate near 70.8% and $2.81 per task for Extra High. That is a community calculation, not an independent Cursor cost audit, so it should be treated as a lead rather than a settled fact.

The underlying question still matters: companies do not buy a low token rate. They buy the total cost of a mergeable pull request.

If Sol succeeds slightly more often but costs much more, while Grok occasionally needs a rework but is far cheaper, the decision is no longer “which score is higher?” It is “which setup costs less per successful task?”

A cheap model can spend the savings on thinking

Several Cursor users report that Grok 4.6 consumes more reasoning tokens than 4.5. This is still a community observation, not a controlled study, but it shows why price per million tokens is not price per task.

Model A costs $10 per million tokens and uses 1M for a task: $10. Model B costs $3 per million, apparently 70% cheaper; if it rereads files, rolls back and retries until it uses 5M, the bill is $15.

For agents, more useful measures are:

• cost per successful task;
• cost per mergeable pull request;
• total time after rework;
• residual risk left for human review.

Cursor's harness belongs in the equation

Grok 4.6 was trained jointly with Cursor, and Cursor says its training covered trajectories across different agent harnesses. A strong CursorBench result therefore cannot automatically mean the base model will behave identically everywhere.

Coding-agent capability looks more like model + system prompt + retrieval + tools + context management + compression + retries + test loops.

The same Grok 4.6 may behave differently in another harness. Sol may also lose or gain an advantage when the surrounding tools change. The community question “does CursorBench measure Grok, or Grok plus Cursor?” is a legitimate measurement question, not a conspiracy theory.

Our judgment: try it, but do not cancel Sol yet

For ordinary implementation, frontend prototypes, batch edits and cost-sensitive Coding tasks, Grok 4.6 is strong enough to deserve a repository-level trial. Its public scores, price and long-horizon positioning make that trial rational.

For complex backends, money systems, concurrency control, architecture and final production review, the current evidence is not enough to recommend dropping Sol. The 2,500-line comparison is not a scientific benchmark, but it captures the cost of high-risk work: one missed edge case can cost more than a few dollars saved.

The smarter workflow may not be a binary choice. Use Grok for ordinary implementation, Sol or another strong model for difficult bugs and architecture review, then ask an independent model to review the patch. You are not buying “the world's smartest model”; you are assigning tasks to an AI engineering team.

What to watch next

• Whether Grok 4.6 remains stable across independent harnesses, repositories and larger samples;
• whether CursorBench's cost figures reproduce in real projects rather than only in its task distribution;
• whether community observations about reasoning tokens, rework and test quality become controlled comparisons;
• whether cost per successful task and cost per mergeable PR replace token rates as the main selection metrics;
• whether more public reviews expose edge-case and concurrency differences between Grok and Sol on high-risk backend work.

*Editor's note: official scores and prices come from xAI and Cursor pages. The 2,500-line backend comparison and token-use observations are community case studies, not population-level conclusions. This article separates confirmed facts, editorial judgment and unknowns; run a small test on your own repository before switching.*