Grok 4.6 Lands: Same Price as 4.5, Frontier Parity

xAI released Grok 4.6 on August 12, 2026, at the same $2 per million input / $6 per million output headline rate as Grok 4.5 — and the most useful fact in the release is not in the launch post at all. It sits on xAI’s pricing page: those rates apply only while a prompt stays below 200,000 tokens. At or above that line, every token in the request — input, cached, and output alike — bills at $4/$12 per million instead.

That threshold is 40% of the way into the 500,000-token context window xAI documents for the model (200,000 of 500,000 — our arithmetic, not xAI’s framing). In practice, the advertised headline rate covers only the first two-fifths of the advertised window. For teams sizing agentic workloads — the exact use case xAI says this model is built for — that single billing rule matters more than any benchmark row in the launch post.

This guide covers what actually shipped and where, the full pricing table by surface, the long-context billing rule and what it does to real prompt sizes, what genuinely changed versus Grok 4.5 (less than the launch framing suggests, except one row that got more expensive), the fast-variant ambiguity in xAI’s own materials, the reasoning-effort ladder, and how to read the benchmark claims. Every number below comes from xAI’s launch post and documentation, OpenRouter’s listing, or Artificial Analysis — with derived figures labeled as our own arithmetic.

The launch post opens plainly: “Today we are releasing Grok 4.6.” xAI positions the model as building on Grok 4.5 with a particular focus on long-running agents and more ambitious interactive and visual work — staying with complex multi-step tasks like research, codebase work, and turning an idea into a polished application. Notably, this is a developer-surface launch: day one lands in Cursor and Grok Build, plus the API via console.x.ai (which the launch page’s own CTA copy now brands the “SpaceXAI API”) and partner routes on OpenRouter, Vercel, and Cloudflare.

Two things the launch post does not say are worth stating, because assumptions fill vacuums fast. Nothing on the page establishes that Grok 4.6 powers grok.com or X — the named surfaces are the developer ones above. And Grok 4.5 is not described as deprecated; its pricing and model pages remain live alongside the new model. If you covered Grok 4.5’s launch expecting a clean succession story, this is a sibling, not a replacement.

On training, xAI describes a longer supplemental run than Grok 4.5’s: curated model-generated data for reasoning and technical concepts, Grok 4.5 used to regenerate supervised fine-tuning trajectories across effort levels and agent harnesses, and agentic reinforcement learning spanning knowledge work, general coding, and domains like kernel optimization, web development, and computer-aided design. On longer trajectories, xAI says it observed “more self-testing and verification, with the model checking its own work before moving on” — a vendor description of internal testing, not an independent measurement. We dig into what self-verification claims are actually worth in our companion piece on Grok Build versus Claude Code self-verification, written alongside this post.

There is a launch promo: 2× included usage inside Grok Build and Cursor for the first week. xAI publishes no base-usage figure for either surface, so the multiplier is not quantifiable against a number — treat it as a nudge, not a budget input. xAI also describes its widest-ever pre-deployment safety testing for this model, plus post-deployment and third-party testing, without publishing pass rates or task counts. This lands one day after Grok Bot, xAI’s agent-teammate product, which launched August 11 — a busy week we are logging in our August 2026 model-release tracker.

The launch post states pricing in one sentence; the real table lives on docs.x.ai’s pricing page, where Grok 4.6 is one row among thirteen models. Pulled out and organized by surface rather than by model, it looks like this — with the Grok 4.5 comparison inline, because that delta is the actual launch-pricing story.

Three details in that table repay attention. First, the two tiers are not an either/or menu — the same model ID moves between them based on prompt size, which Section 03 unpacks. Second, priority processing is xAI’s documented speed mechanism: a 2× premium over standard rates applied to all token types, platform-wide, and you are only billed the priority rate when the API response confirms it. Third, Grok 4.6 gets no batch discount at all — the pricing page states plainly that models not on its 20% list have none, and neither Grok 4.6 nor Grok 4.5 is on it.

Here is the sentence that should have been in the launch post, quoted from xAI’s pricing documentation:

Read it twice, because the intuitive model is wrong. This is not marginal pricing, where the first 200K tokens bill at $2 and only the overflow bills at $4. Once the prompt reaches the 200K-token threshold, every token in the request — the full input, any cached tokens, and all of the output — bills at the long-context rate. A 200,000-token prompt does not cost slightly more than a 199,000-token one; it costs double per token, on every token, including the response.

Put that against the context window. xAI’s model page documents 500,000 tokens for Grok 4.6, which means the headline $2/$6 rate covers only prompts using up to 40% of the window (200,000 of 500,000 — our arithmetic). The remaining 60% of the advertised context is real and usable, but every request that reaches into it ships at $4/$12. The table below applies xAI’s documented rule to illustrative prompt sizes — the rates are vendor-stated; the rows are our own worked examples.

Rates from xAI’s pricing documentation; tier assignment follows its stated threshold rule; window percentages are each prompt size divided by the documented 500,000-token maximum. Note the discontinuity between the third and fourth rows: 1,000 extra prompt tokens flip the entire request — including the output — from $2/$6 to $4/$12 per million. For an agent harness that packs context greedily, that is a step function hiding inside what looks like a flat price.

The strongest checkable fact in this launch is what did not change. On xAI’s own pricing table, Grok 4.5 and Grok 4.6 are identical row for row on uncached input and output — $2.00/$6.00 standard, | NOTE: minor typographical fix — stray space after the slash, inconsistent with '$4.00/$12.00' in the same sentence. Plain ASCII, verified to occur exactly once (line 707). $4.00/$12.00 long-context — and the documented context window is the same 500,000 tokens. Grok 4.6 is neither a price cut nor a context expansion. It is a capability update shipped at its predecessor’s exact rates, which for anyone who read our Grok 4.5 frontier comparison means the cost side of that analysis carries forward unchanged.

Except for one row. Cached input — the rate you pay when the API re-reads context it has already processed — rose from $0.30 to $0.50 per million on the standard tier, and from $0.60 to $1.00 on the long-context tier. Each is a 67% increase by our arithmetic on the two vendor-stated prices. The launch post does not mention it; we found it by reading the 4.5 and 4.6 rows of the pricing table side by side.

Why the cache row matters more than it looks: long-running agents — the workload xAI names as this model’s focus — are cache-heavy by construction. An agent loop re-sends its system prompt, tool definitions, and accumulated context on every turn, and prompt caching is what keeps that affordable. A “same price as last time” headline that quietly reprices the cache row is repricing the exact consumption pattern this model is marketed for. That is worth knowing before you carry a Grok 4.5 cost model forward into a 4.6 deployment.

There is a broader pattern here that we expect to keep seeing: vendors hold headline input/output rates steady — the two numbers everyone screenshots — while the economics move in the rows fewer people read: cache rates, long-context tiers, batch eligibility. The headline is the anchor; the invoice is the table.

One line in the launch post has no counterpart anywhere in xAI’s documentation. The post states: “Pricing starts at $2 per million input tokens and $6 per million output tokens. Additionally, there is a fast variant which is twice the price.” That is the entire disclosure — no model ID, no name, no pricing-table row.

We looked for the product behind the sentence. No fast Grok 4.6 model ID appears in xAI’s pricing table (thirteen model rows), its models index, or OpenRouter’s catalog. Doubling the standard rate yields $4/$12 by simple arithmetic — but those dollar figures are ours, not xAI’s, and they happen to be numerically identical to the fully documented long-context tier, which is a different thing entirely: a prompt-size threshold on the same model ID, not a faster variant. The closest documented mechanism is priority processing — a platform-wide 2× premium on all token types — but xAI’s docs present that as a service tier, not a Grok 4.6 variant.

Stated neutrally: this is a genuine ambiguity in the vendor’s own launch materials, and the practical guidance is simple. Build against what the pricing table documents — the standard tier, the long-context tier, and priority processing — and treat the fast variant as an announcement without a product page until a model ID shows up in the documentation.

The model page documents a 500,000-token context window, text and image input with text output, and function calling, structured outputs, and reasoning. The models overview states the knowledge cutoff verbatim: “The knowledge cut-off date of Grok 4.6 is February 1, 2026.” Serving details: regions us-east-1 and us-west-2, with rate limits of 150 requests per second and 50,000,000 tokens per minute. One spec is conspicuously absent — xAI publishes no maximum output-token figure for Grok 4.6 on its pricing page, the model page, or the reasoning docs. We state that as an absence rather than estimating one.

The reasoning-effort ladder is where API builders get caught. Grok 4.6 documents four rungs — and the reasoning docs are explicit about the defaults: “If not specified, reasoning_effort defaults to ‘high’. Reasoning cannot be disabled.”

Two integration notes from the same docs. Grok 4.6 exposes summarized reasoning as streamable reasoning_content deltas alongside the final response, with optional encrypted full reasoning traces for multi-turn continuation. And three familiar sampling parameters — presencePenalty, frequencyPenalty, and stop — cannot be used with this reasoning model: requests including them return an error, so scrub them from any shared request builder before pointing it at grok-4.6.

The ladder’s ceiling deserves emphasis for anyone writing multi-vendor routing code: there is no max rung documented for Grok 4.6 or Grok 4.5 — xhigh is the top. Rival ladders from OpenAI and Anthropic document a max tier above their own high, so a harness that assumes a universal effort vocabulary will misbehave differently per vendor — and on Grok 4.5 the failure is silent downgrading, not an error.

This post deliberately does not re-litigate the frontier comparison — that analysis has its own dedicated companion. But the launch post’s framing is worth reading precisely, because it is more modest than a skim suggests. xAI writes that Grok 4.6 “achieves frontier intelligence across several agentic coding and knowledge work benchmarks” and that “It matches GPT-5.6 Sol on the Artificial Analysis Intelligence Index, which is a composite score of nine benchmarks.” The operative verb is matches — the vendor’s own claim is parity with one named rival on one named index, not leadership of the frontier. Nothing in the materials we reviewed supports extending that tie into a leadership claim, and we do not.

The comparison table’s configuration matters as much as its numbers. xAI’s own column headers read Grok 4.6 High, Grok 4.5 High, GPT-5.6 Sol Max, and Fable 5 Max — the new model at its default rung (third of four on its own ladder) against rivals at their documented ceilings, with competitor figures drawn, per xAI’s footnote, from the respective developers’ published system cards or leaderboards. What that asymmetry does to score interpretation — in both directions — is exactly what our companion effort-tier analysis unpacks, and the general skill of reading a vendor table that discloses its own losses gets its own companion guide.

Marketplace data corroborates the list price. OpenRouter’s x-ai/grok-4.6 listing shows $2.00/$6.00 with $0.50 cached input — an exact match to xAI’s standard-tier list — served by two providers at launch with throughput around 127 to 130 tokens per second and P50 latency of 0.53 to 0.78 seconds. OpenRouter also reports a weighted-average price its customers actually pay: $0.8854 per million input and $6.117 per million output. Label that correctly — it is an OpenRouter-observed blended average reflecting caching and discount mix across real traffic, not a different list price. For long-running agentic work, the cache-row increase in Section 04 is the change to model first.

Looking forward, the safest read is that per-surface pricing complexity is becoming the norm, not the exception: one model ID now carries at least four billing behaviors (standard, long-context, priority, cached) before a fast variant even gets a model ID. Evaluating a model on its headline rate alone was already sloppy; on this pricing table it is measurably wrong at exactly the prompt sizes agentic workloads use. If your team is deciding where Grok 4.6 fits in a multi-vendor stack — or whether your current cost model survives contact with a 200K threshold — that per-surface pricing audit is the kind of work our AI transformation engagements start with, and Grok Build itself — one of the two day-one surfaces — is covered in our Grok Build deep dive.