xAI’s Grok 4.6 is now available in Amazon Bedrock

Today, we are announcing that xAI’s Grok 4.6 is available in Amazon Bedrock, adding a frontier model built for long-running agents, coding, and knowledge work to the Bedrock model catalog. Grok 4.6 launched on Bedrock on August 18, 2026. It offers a 500K token context window and supports configurable reasoning effort at four levels: low, medium, high, and xhigh.

This is xAI’s second model in Amazon Bedrock. When Grok 4.3 became generally available, xAI joined Amazon Bedrock as a model provider and the model was reachable through Bedrock Mantle, the OpenAI-compatible inference engine in Amazon Bedrock. Grok 4.6 widens that surface area considerably: it is available on both the bedrock-mantle and bedrock-runtime endpoints, and it supports the Converse API alongside Chat Completions and Responses.

This post covers what xAI says Grok 4.6 is designed for, how it is packaged on Amazon Bedrock, and how to send your first request.

What Grok 4.6 is built for

The capability and training details in this section come from xAI’s launch announcement, Introducing Grok 4.6.

Grok 4.6 builds on Grok 4.5 with a particular focus on long-running agents and more ambitious interactive and visual work. xAI describes the model as staying with complex tasks across many steps, whether that is researching a topic, analyzing information, working across a code base, or turning an idea into a polished application or work artifact.

On training, xAI reports a longer supplemental training run than Grok 4.5, using curated model-generated data for reasoning and advanced technical concepts, high-quality engineering data, and an improved optimizer and training recipe. It then used Grok 4.5 to regenerate the supervised fine-tuning trajectories across reasoning efforts, agent harnesses, and domains including STEM, software engineering, and knowledge work, filtering out problematic traces with model-based checks. The model was then trained on a wide range of agentic reinforcement learning tasks spanning knowledge work, general coding, and domain-specific environments such as kernel optimization, web development, and computer-aided design.

Two behaviors xAI calls out are worth noting for anyone building agents. On longer trajectories, the model began showing more self-testing and verification, checking its own work before moving on. It also produces stronger first passes on visual and interactive projects, establishing the structure and visual language of an application in a single pass, which the team found useful where the fastest route to a good result was to start with something substantial and then iterate.

On safety, xAI states that Grok 4.6’s safeguards have been improved and calibrated in line with the model’s capabilities, backed by what it describes as its widest-ever suite of pre-deployment testing for capabilities and safeguard calibration, plus post-deployment and third-party testing. The company positions its safety stack as maximizing utility and security across legitimate use cases in domains such as vulnerability patching, accelerating the engineering design cycle, and augmenting AI research.

Reported benchmark results

xAI reports that Grok 4.6 achieves frontier intelligence across several agentic coding and knowledge work benchmarks. These are the figures it published for Grok 4.6 High at launch on August 12, 2026:

Several of those evaluations come from Artificial Analysis, so it helps to know what they measure. According to Artificial Analysis, the Artificial Analysis Intelligence Index v4.1.1 is a composite that incorporates nine evaluations: GDPval-AA v2, τ³-Banking, Terminal-Bench v2.1, SciCode, Humanity’s Last Exam, GPQA Diamond, CritPt, AA-Omniscience, and AA-LCR. Those cover agentic tool use, reasoning and knowledge, knowledge reliability, long context reasoning, and quantitative analysis over spreadsheets and documents. AA-Briefcase is its agentic knowledge work benchmark, where AA-Briefcase Elo aggregates rubric pass rate, analytical quality Elo, and presentation Elo, with higher scores better.

Artificial Analysis also tracks cost and latency alongside intelligence. Its cost-per-task metric is a weighted average cost per Intelligence Index task, derived from input, cache hit, cache write, reasoning, and answer token prices, which is a useful lens if you are sizing a reasoning-heavy agent workload where reasoning tokens are a real line item.

What Grok 4.6 adds on Bedrock

Several Bedrock capabilities are new for this model rather than carried over from the earlier Grok launch.

The bedrock-runtime endpoint. Grok 4.6 is served on bedrock-runtime in addition to bedrock-mantle, so you can reach it with the AWS SDKs and the standard Bedrock control surface rather than only an OpenAI-compatible client.

The Converse API, including streaming. Both converse and converse_stream are available. This is the practical payoff of runtime support: one message shape across models, and streaming through the usual Converse events (messageStart, contentBlockDelta, contentBlockStop, messageStop, metadata) without hand-rolling server-sent events (SSE) parsing.

An xhigh reasoning effort level. Effort runs low, medium, high, xhigh, extending the range at the top end for problems where a deeper pass is worth the tokens. On Converse, set it through additionalModelRequestFields={"reasoning_effort": "xhigh"} rather than a reasoning parameter.

Cross-Region inference. On bedrock-runtime you route through one of two inference profiles rather than pinning to a single Region. us.xai.grok-4.6 keeps traffic within the US geography when you have data residency requirements, and global.xai.grok-4.6 routes worldwide for the widest capacity pool. Global is also the cheaper of the two, at $2.00 per million input tokens against $2.20, so absent a residency constraint it is usually the better default.

Amazon Bedrock Guardrails. Grok 4.6 now supports Guardrails on bedrock-runtime across its APIs, giving you content filters, denied topics, personally identifiable information (PII) redaction, and word policies. You attach a guardrail by ID and version on the request, and the policy is evaluated against both the prompt and the model’s response. For agentic workloads this matters because it puts a consistent policy boundary around a model that might run unattended across many steps.

Invocation logging. With model invocation logging enabled, Grok 4.6 calls are captured as complete Amazon CloudWatch records: request body, response body, token counts including reasoning tokens, and the inference profile used. Useful for auditing agent runs where you need to see what the model was actually asked.

Prompt caching. Cached input is billed at roughly a quarter of the standard input rate, which matters for agents that resend a large system prompt or document on every turn. Caching applies to a repeated prefix, so keep stable content at the front of the request, and read the cached token count in the usage block to confirm the discount is landing before you build it into a cost model.

Tool calling, structured output, image input, response streaming, and encrypted reasoning content are available as well, but those date from the Grok 4.3 launch and are covered in that post.

How Grok 4.6 is packaged on Amazon Bedrock

Grok 4.6 accepts text and image input and returns text. Audio, speech, video, and embedding modalities are not supported, and it does not generate images. The model is reachable through two endpoints, and the model ID differs depending on which one you use:

On the API side, Grok 4.6 supports the Responses API, the Chat Completions API, and the Converse API. The Invoke API is not supported.

Feature support differs by endpoint, which is the detail most likely to shape your integration choice:

On bedrock-mantle, supported features include client-side tool calling, reasoning, structured outputs, prompt caching, response streaming, projects, and abuse detection.

On bedrock-runtime, supported features include reasoning, prompt caching, response streaming, invocation logs, and projects (default project only). Structured outputs, server-side tool use, intelligent prompt routing, count tokens, and application inference profiles are not supported on that endpoint.

Tool calling works on both endpoints. The model returns a structured function request, your code executes it, and you pass the result back. On bedrock-runtime you can drive that loop through Converse’s toolConfig or the OpenAI-compatible tools parameter, so agents that depend on function calls are not limited to bedrock-mantle.

If your application depends on JSON Schema structured output, that points you at bedrock-mantle. If you want the Converse API or invocation logging, that points you at bedrock-runtime.

Regions and inference options

Availability differs by endpoint. On bedrock-mantle, Grok 4.6 is available for in-Region inference in US West (Oregon) (us-west-2) . On bedrock-runtime, in-Region inference is not offered. Instead, you invoke the model through cross-Region inference profiles. Geo cross-Region inference is available from the US Regions (us-east-1, us-east-2, us-west-1, and us-west-2), and Global cross-Region inference is available from a considerably longer list spanning the US, Canada, Europe, Asia Pacific, the Middle East, Africa, and South America. Geo cross-Region routes across Regions within a geography while respecting data residency, and Global cross-Region routes anywhere worldwide when there are no residency constraints. The full table runs to more than 30 Regions, so check the model card and the Regional availability by model page for the current list before you pin a Region.

This is a change in shape from the Grok 4.3 launch, where, as noted in the Grok 4.3 post, the model used in-Region inference only and Geo and Global cross-Region inference were not offered.

Service tier and pricing

Grok 4.6 supports three service tiers. Standard is pay-per-token with no commitment, selected by setting "service_tier": "default" or omitting the field. Priority delivers faster, prioritized processing for a premium ("service_tier": "priority"). Flex offers lower-cost access for work that is not time-sensitive ("service_tier": "flex"). For per-token pricing across the tiers, see the Amazon Bedrock pricing page.

The other two tiers are priced as multipliers on those Standard rates: Priority at 1.75x, a 75 percent premium, and Flex at 0.5x, a 50 percent discount. So the same workload that costs $2.20 per million input tokens on Standard in-Region runs $3.85 on Priority and $1.10 on Flex, which makes tier selection a larger cost lever than the Region choice.

For reference, xAI lists Grok 4.6 pricing starting at $2 per million input tokens and $6 per million output tokens, with a fast variant at twice the price. Always confirm current rates on the Amazon Bedrock pricing page, because prices and tiers change.

Send your first request

Before your first call, confirm the model is available to you in the Bedrock console for the Region you plan to use. Grok 4.6 is served through inference profiles rather than on-demand throughput on the bare model ID, which is why requests name us.xai.grok-4.6 or global.xai.grok-4.6 on bedrock-runtime.

Grok 4.6 uses OpenAI-compatible APIs, so the OpenAI SDK works against either endpoint after you set the base URL. Install the SDK, and boto3 if you plan to use the Converse API:

pip install openai
pip install boto3

Generate a long-term Amazon Bedrock API key from the Amazon Bedrock console for exploration, then set your environment. For bedrock-mantle:

export OPENAI_API_KEY="<provide your Bedrock API key>"
export OPENAI_BASE_URL="https://bedrock-mantle.us-west-2.api.aws/openai/v1"

export OPENAI_API_KEY="<provide your Bedrock API key>"
export OPENAI_BASE_URL="https://bedrock-runtime.us-east-1.amazonaws.com/openai/v1"

A first request on bedrock-mantle with the Chat Completions API:

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="xai.grok-4.6",
    messages=[
        {"role": "user", "content": "Can you explain the features of Amazon Bedrock?"}
    ],
)
print(response)

On bedrock-runtime the difference is the model name: you pass a cross-Region inference profile instead of the bare model ID. This example also switches to the Responses API to show that shape:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="us.xai.grok-4.6",
    input="Can you explain the features of Amazon Bedrock?",
)
print(response)

And through the Converse API with boto3. Because reasoning is active, the first content block carries the reasoning and the answer sits in a later block, so search the blocks for the text rather than indexing content[0]:

import boto3

client = boto3.client("bedrock-runtime", region_name="us-east-1")

response = client.converse(
    modelId="us.xai.grok-4.6",
    messages=[
        {"role": "user", "content": [{"text": "Can you explain the features of Amazon Bedrock?"}]}
    ],
    inferenceConfig={"maxTokens": 2048},
)

blocks = response["output"]["message"]["content"]
text = next(b["text"] for b in blocks if "text" in b)
print(text)

On Converse you set the effort level through additionalModelRequestFields rather than a reasoning parameter:

response = client.converse(
    modelId="us.xai.grok-4.6",
    messages=[{"role": "user", "content": [{"text": "What is 17*23? Number only."}]}],
    inferenceConfig={"maxTokens": 3000},
    additionalModelRequestFields={"reasoning_effort": "xhigh"},
)

Three operational notes. First, on bedrock-runtime, Grok 4.6 is not available for in-Region inference, so requests must name us.xai.grok-4.6 or global.xai.grok-4.6.

Second, bedrock:InvokeModel is evaluated against three resources: your account’s default project, the inference profile you name, and the underlying foundation model. The foundation model ARN is wildcarded across Regions because cross-Region profiles route outside the calling Region. Bearer-token authentication on the OpenAI-compatible endpoints additionally requires bedrock:CallWithBearerToken, which boto3 and Converse do not need:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "bedrock:InvokeModel",
            "Resource": [
                "arn:aws:bedrock:{region}:{account-id}:project/default",
                "arn:aws:bedrock:{region}:{account-id}:inference-profile/us.xai.grok-4.6",
                "arn:aws:bedrock:*::foundation-model/xai.grok-4.6"
            ]
        },
        {
            "Effect": "Allow",
            "Action": "bedrock:CallWithBearerToken",
            "Resource": "*"
        }
    ]
}

List every inference profile you plan to call. Profiles are scoped individually, so a policy naming us.xai.grok-4.6 does not cover global.xai.grok-4.6.

Third, the two authentication mechanisms cover different code paths. An Amazon Bedrock API key in OPENAI_API_KEY travels as a bearer token and authenticates the OpenAI-compatible calls on both endpoints. The boto3 Converse examples sign with SigV4 instead, drawing on your ordinary AWS credentials from the environment, a profile, or a role. Configure both if you intend to use Converse alongside the OpenAI-compatible APIs.

Treat a long-term API key as an exploration-only credential. For production, the Grok 4.3 launch post recommends short-term bearer tokens generated from your IAM credentials with the aws-bedrock-token-generator package, because they expire automatically and keep access tied to your IAM identity, and that guidance applies equally here.

Working with reasoning effort

Reasoning is active on Grok 4.6 by default, and you configure how much of it the model spends through the reasoning parameter with low (the default), medium, high, or xhigh. The xhigh level is new relative to what the Grok 4.3 launch post documented, where the levels were none, low, medium, and high.

Reasoning content is encrypted. You can have it returned by passing include: ["reasoning.encrypted_content"] on a Responses API request, then send that content back on subsequent turns to give the model its own prior reasoning as context in a multi-turn conversation. The Chat Completions API does not return reasoning tokens.

Encrypted reasoning is a Responses API feature, so this example uses the OpenAI client rather than the boto3 client from the Converse examples above:

from openai import OpenAI

client = OpenAI()  # OPENAI_BASE_URL points at the bedrock-runtime endpoint

response = client.responses.create(
    model="us.xai.grok-4.6",
    reasoning={"effort": "high"},
    include=["reasoning.encrypted_content"],
    input="Explain quantum entanglement simply.",
)
print(response.output_text)

Because reasoning is by default and effort is per request, effort level is a real cost and latency control. Run short extraction and classification calls at low, and reserve high or xhigh for planning steps and long agent trajectories where an early mistake compounds. Benchmarking effort levels against your own workload is the fastest way to find where higher reasoning stops earning its token cost.

Get started

Grok 4.6 on Amazon Bedrock gives you a model xAI built for long-running agents and ambitious interactive work, with a 500K token context window, four reasoning effort levels, image input, prompt caching, and a choice between the OpenAI-compatible bedrock-mantle endpoint and the bedrock-runtime endpoint with Converse API and cross-Region inference support.

To start building, review the Grok 4.6 model card for the current Region list, feature matrix, and parameter details, and check the Amazon Bedrock pricing page for token rates. If you generated a long-term Amazon Bedrock API key for exploration, delete it from the Amazon Bedrock console when you are finished. A standing credential you no longer need only widens your account’s exposure surface.

Sources

• Amazon Bedrock Grok 4.6 model card: https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-xai-grok-4-6.html
• xAI models in Amazon Bedrock: https://docs.aws.amazon.com/bedrock/latest/userguide/model-cards-xai.html
• xAI, Introducing Grok 4.6: https://x.ai/news/grok-4-6
• Artificial Analysis, model comparison and benchmark methodology: https://artificialanalysis.ai/models
• AWS, Introducing Grok on Amazon Bedrock (Grok 4.3): https://aws.amazon.com/blogs/machine-learning/introducing-grok-on-amazon-bedrock/