HomeAI models
xAI: Grok 4.6
xAI
•
Grok 4.6 (high)
•
Released 
August 2026

xAI
Grok 4.6 (high)

xAI's frontier model tuned for long-running agents, solving complex tasks in far fewer turns and tokens.

Modality:
Text
Image
Video
PDF
model ID
x-ai/grok-4.6
Start for free
arrow black icon
View API Docs
arrow white icon

Output Speed

55.53
tok/s

Intelligence Index

60.9
/ 100

Context Window

500000
tokens

Input price

12
Anytoken

Output price

36
Anytoken

Grok 4.6: Frontier Agentic Work at Fewer Turns per Task

‍
Grok 4.6 is xAI's current frontier model, built on the same foundation as Grok 4.5 with a longer supplemental training run focused on long-running agents, coding, and knowledge work. It sits at the top of the Grok lineup as a reasoning-capable agentic model with text and image input, text output, a 500K-token context window, and four reasoning-effort levels. Its distinguishing trait is task efficiency: independent testing shows it resolves long-horizon agent tasks in roughly half the turns of comparable frontier models. Long-running coding and knowledge-work agents benefit most.

Integrate Grok 4.6 via the AnyAPI.ai API

Performance

Where Grok 4.6 Wins: Turn Efficiency on Long-Horizon Agent Work

Grok 4.6's strongest results are agentic rather than static reasoning. On Artificial Analysis's GDPval-AA v2 measure of real-world agentic knowledge work, it reaches an Elo of 1753, behind only Claude Opus 5. More decisively, it resolves long-horizon tasks in roughly 53 turns and 0.5B input tokens on average, versus about 103 turns and 2.0B tokens for Claude Opus 5. Because long agent loops accumulate context rapidly, fewer turns and tokens translate directly into lower cost per completed task, making Grok 4.6 well-suited to sustained multi-step production agents rather than one-shot prompting.

Benchmarks

Grok 4.6 Benchmarks: Strong on Knowledge Work, Uneven on Pure SWE

Independent testing from Artificial Analysis places Grok 4.6 at 61 on its Intelligence Index, tying GPT-5.6 Sol and sitting just behind Claude Opus 5 and Claude Fable 5. It leads on agentic knowledge work: an AA-Briefcase Elo of 1577 and top-two placement on τ³-Banking (50.7%). Pure software-engineering evals are weaker relative to the frontier, with GPT-5.6 Sol Max leading DeepSWE and Terminal-Bench v3.0 by clear margins. Artificial Analysis also measured a 65.7% non-hallucination rate, relevant for customer-facing deployments where factuality matters more than raw coding throughput.

Output Speed

55.53
tok/s

Intelligence Index

60.9
/ 100

MMLU

Broad world knowledge and problem-solving
0
%

GPQA

PhD-level scientific reasoning across physics, biology, chemistry.
95
%

HLE

Adherence to multi-step structured instructions.
43
%

LiveCodeBench

Tool-calling reliability in long agentic loops.
0
%

Technical Specifications

What the model supports

Grok 4.6 (model ID grok-4.6) accepts text and image input and returns text only. It offers a 500K-token context window with four reasoning-effort levels, function calling, structured outputs, and server-side tools including search and code execution. Two specifications carry the most production weight: the 200K-token pricing threshold, which raises rates for the entire request once crossed, and the 500K window itself, which is the smallest among current frontier models where competitors reach 1M or more. Teams processing very large corpora must chunk or route around that ceiling.
Verified Specifications — 
Grok 4.6 (high)
Input modalities
Text
Image
Video
PDF
output modalities
Text
Context window
500000
 tokens
Maximum output tokens
450000
Reasoning
Yes
Knowledge cutoff
August 2026
Pricing (standard)
12
 AnyTokens in
 / 
36
 AnyTokens out

Quickstart

Sample code for Grok 4.6 (high)

Python
JavaScript
Curl
import requests

url = "https://api.anyapi.ai/v1/chat/completions"

payload = {
    "model": "x-ai/grok-4.6",
    "messages": [
        {
            "role": "user",
            "content": "Hello"
        }
    ]
}
headers = {
    "Authorization": "Bearer anyapi_api_key",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)
import requests url = "https://api.anyapi.ai/v1/chat/completions" payload = { "model": "x-ai/grok-4.6", "messages": [ { "role": "user", "content": "Hello" } ] } headers = { "Authorization": "Bearer anyapi_api_key", "Content-Type": "application/json" } response = requests.post(url, json=payload, headers=headers) print(response.text)
View docs
Copy
Code is copied
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer anyapi_api_key', 'Content-Type': 'application/json'},
  body: JSON.stringify({model: 'x-ai/grok-4.6', messages: [{role: 'user', content: 'Hello'}]})
};

fetch('https://api.anyapi.ai/v1/chat/completions', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
const options = { method: 'POST', headers: {Authorization: 'Bearer anyapi_api_key', 'Content-Type': 'application/json'}, body: JSON.stringify({model: 'x-ai/grok-4.6', messages: [{role: 'user', content: 'Hello'}]}) }; fetch('https://api.anyapi.ai/v1/chat/completions', options) .then(res => res.json()) .then(res => console.log(res)) .catch(err => console.error(err));
View docs
Copy
Code is copied
curl --request POST \
  --url https://api.anyapi.ai/v1/chat/completions \
  --header 'Authorization: Bearer anyapi_api_key' \
  --header 'Content-Type: application/json' \
  --data '
{
  "model": "x-ai/grok-4.6",
  "messages": [
    {
      "role": "user",
      "content": "Hello"
    }
  ]
}
'
curl --request POST \ --url https://api.anyapi.ai/v1/chat/completions \ --header 'Authorization: Bearer anyapi_api_key' \ --header 'Content-Type: application/json' \ --data '{ "model": "x-ai/grok-4.6", "messages": [ { "role": "user", "content": "Hello" } ]}'‍
View docs
Copy
Code is copied
View docs
Code examples coming soon...

Comparison

Grok 4.6 vs Grok 4.5: What Actually Changes for Agents?

Grok 4.6 is a refinement of Grok 4.5 on the same foundation, with a longer supplemental training run rather than a bigger base model. Both share a 500K context window, the same headline token pricing, image input, and text output. Grok 4.6 improves on Grok 4.5 across every benchmark xAI reports, with the largest gains clustered in agentic engineering — APEX-Agents rises more than 10 points. The practical decision is not whether 4.6 is generally better, but whether its efficiency and quality gains justify slower response times and higher effective cost per task.

Dimension
Grok 4.6 (high)
Grok 4.5
Context window
500000
tokens
500000
tokens
Output speed
55.53
tok/s
49.34
tok/s
Intelligence Index
60.9
55.8
Input pricing
12
AnyToken
12
AnyToken
Output pricing
36
AnyToken
36
AnyToken
Knowledge cutoff
August 2026
July 2026

Choose Grok 4.6 when you run long-horizon agents and value fewer turns, higher agentic-knowledge-work quality, and the new xhigh reasoning level that Grok 4.5 silently downgraded. Choose Grok 4.5 when latency matters, when prompts are stable with high cache hit rates, or when your workload is interactive: Grok 4.6's time-to-first-token regressed substantially and it emits notably more output tokens per task, raising effective cost even at an unchanged list price. Benchmark your own agent loop before upgrading.

Limitations & Trade-offs

Where Grok 4.6 (high) falls short

1
Slow time-to-first-token. Independent testing shows Grok 4.6's time-to-first-token rose sharply over Grok 4.5 — from single-digit seconds to roughly 30 seconds under heavier reasoning. For interactive chat and tooling where a user waits on the first token, a half-minute delay is a genuine usability problem. Latency-sensitive real-time applications should prefer a lower-latency model or a faster tier.
2
200K pricing cliff inside a 500K window. The 500K context is not a flat pool: once a prompt reaches 200K input tokens, xAI bills the entire request at long-context rates, roughly doubling input and output cost. Long-document or large-codebase workloads can incur surprising bills, so context policy and compaction become part of the cost model, not an afterthought.
3
Smallest context among frontier peers. At 500K tokens, Grok 4.6's window is smaller than competitors that reach 1M or more. Workloads that must hold very large corpora, entire monorepos, or extensive multi-document context in a single request will need chunking, retrieval, or another model. This limits Grok 4.6 for the largest single-pass long-context tasks.
4
Agentic-coding regression and uneven SWE results. Early independent listings show a specific regression in multi-step tool-using coding relative to Grok 4.5, and Grok 4.6 trails GPT-5.6 Sol Max on DeepSWE and Terminal-Bench v3.0. If fully autonomous software engineering is your primary workload, the benchmarks point elsewhere; Grok 4.6's advantage is agentic knowledge work and turn efficiency, not raw coding leadership.

Best-Fit Workloads

Where this model earns its place

01

Long-running knowledge-work agents

‍
Grok 4.6's strongest evidence is on real-world agentic knowledge work, leading on GDPval-AA v2 (1753 Elo, behind only Claude Opus 5) and AA-Briefcase (1577 Elo). It resolves tasks in about half the turns and a quarter of the input tokens of comparable models, making it well-suited to agents that carry a project from research through analysis to a finished artifact. The efficiency lowers cost per completed task on sustained loops.

02

Multi-step coding agents in an existing harness

‍
With function calling, server-side code execution, streaming reasoning summaries, and co-designed agent training, Grok 4.6 fits multi-file coding agents inside harnesses like Cursor or Grok Build. Day-one availability across major gateways removes integration friction. Note the caveat: pure autonomous software-engineering evals (DeepSWE, Terminal-Bench v3.0) trail the top competitors, so validate against your own codebase tasks.

03

Customer-facing tool-using assistants

‍
A top-two result on τ³-Banking (50.7%) for multi-turn customer service with tool use, plus an independently measured 65.7% non-hallucination rate, make Grok 4.6 a reasonable fit for assistants that must call tools reliably across a conversation. Factuality matters more than coding throughput here, and Grok 4.6's non-hallucination measurement is relevant. Latency-sensitive chat should still weigh the slower first-token time.

04

Image-grounded analysis and visual builds

‍
Grok 4.6 accepts image input alongside text, supporting tasks that reason over screenshots, diagrams, or design references and turn them into working interactive or visual output. xAI and Cursor report stronger first attempts on visual web projects. Output remains text-only — the model understands images but does not generate them — so pair it with a separate image-generation service where rendered images are required.

Pricing in anytokens via AnyAPI
Input
12
₳
Output
36
₳
Cache write
—
₳
Cache read
3
₳
Get API access
arrow black icon
Read Docs

on this page

PerformanceBenchmarksTechnical SpecificationsQuickstartComparisonLimitations & Trade-offsBest-Fit WorkloadsIntegrationFAQ

Integration

Access Grok 4.6 (high) via AnyAPI.ai

Access Grok 4.6 (high) through AnyAPI.ai using a unified API built for multi-model AI applications. Integrate Grok 4.6 (high) without maintaining a separate provider-specific connection, and keep the flexibility to test, switch, or combine models as your application requirements evolve.

01

One API integration

Access Grok 4.6 (high) and other AI models through the same API workflow instead of maintaining separate integrations for every provider.

02

Easy model switching

Test Grok 4.6 (high) against alternative models or switch models as your performance, capability, or cost requirements change without rebuilding your application around another provider API.

03

Flexible for production

Use Grok 4.6 (high) from experimentation through production while keeping your AI stack flexible as workloads, traffic, and model requirements evolve.

04

Multi-model applications

Use Grok 4.6 (high) for the workloads where it performs best and combine it with other models for tasks that require different capabilities, performance, or efficiency.

Start free
arrow black icon
Read Docs

Frequently Asked Questions

Answers to common questions about integrating and using this AI model via AnyAPI.ai

Grok 4.6 has a 500,000-token context window, unchanged from Grok 4.5. Note that when a prompt reaches 200,000 input tokens, xAI applies long-context pricing to the entire request, not just the tokens above the threshold. It is also the smallest context window among current frontier models, several of which reach 1M or more.

Yes. Grok 4.6 supports four reasoning-effort levels: low, medium, high (the default), and xhigh. The xhigh level is new to 4.6; Grok 4.5 accepted the parameter but silently downgraded it to high. Higher effort improves quality on hard tasks but increases response time and output tokens.

Grok 4.6 improves on non-agentic coding over Grok 4.5, but on pure autonomous software-engineering evals like DeepSWE and Terminal-Bench v3.0 it trails GPT-5.6 Sol Max, and early independent listings show a specific regression in multi-step agentic coding. Its coding value lies in efficient agent loops within a harness, not benchmark leadership on autonomous SWE.

Grok 4.6 accepts text and image input and produces text output only. It can understand and reason over images but does not generate them — image generation is a separate xAI service. There is no audio or video input on the grok-4.6 API model.

Grok 4.6 improves on Grok 4.5 across every benchmark xAI reports, with the biggest gains in agentic work, and shares the same 500K context and headline token pricing. However, its time-to-first-token regressed substantially, it emits more output tokens per task, and its cached-input rate rose, so effective cost per task can increase. Benchmark your own workload before upgrading.