Introducing Grok on Amazon Bedrock

This publish is co-written with Eric Jiang from xAI (SpaceXAI).

xAI’s Grok 4.3 is now typically obtainable on Amazon Bedrock, giving groups that construct brokers and AI workflows a mannequin that causes reliably over lengthy inputs. With this launch, xAI joins Amazon Bedrock as a mannequin supplier. Grok 4.3 is a mannequin with configurable reasoning effort. It affords sturdy instrument use and instruction following for constructing brokers, and token effectivity for high-volume inference. It accepts textual content and picture enter, and has a 1 million token context window for lengthy paperwork and multi-turn periods. The mannequin runs on Mantle, the next-generation inference engine in Amazon Bedrock.

This publish covers what makes Grok 4.3 an awesome match for agentic and enterprise workloads, the way you entry it via Amazon Bedrock, and find out how to use the capabilities most groups attain for first: a primary chat request, configurable reasoning effort, instrument calling, structured output, picture enter, and stateful multi-turn conversations.

Why Grok 4.3 is a superb match for agentic and reasoning workloads

Based on xAI, Grok 4.3 is constructed for enterprise work the place accuracy issues. By itself benchmarks on the time of the mannequin launch, xAI experiences it outperforms varied trade benchmarks. Grok 4.3 ranked #1 on the Synthetic Evaluation Omniscience benchmark with the bottom hallucination price among the many frontier fashions it in contrast. It additionally positioned #1 on the Synthetic Evaluation Tau2 Telecom benchmark for instrument calling in buyer help situations, and #1 on the Vals AI Case Legislation and Company Finance benchmarks for doc understanding. xAI additionally locations the mannequin on the intelligence-versus-cost Pareto frontier, which it describes as 2 to 10 occasions extra intelligence per greenback than different frontier fashions.

With Grok 4.3, you’ll be able to management how a lot the mannequin thinks earlier than answering via an effort stage on every request. You configure the hassle stage (none, low, medium, and excessive) per request and let one mannequin serve the complete vary of labor. A classification name can run at none effort to maintain latency low. A contract evaluation or case legislation activity can run at excessive when depth issues greater than response time. Grok 4.3 accepts textual content and picture enter and returns textual content, and its 1 million token context window leaves room for lengthy paperwork and prolonged multi-turn periods. The mannequin handles instrument calling and instruction following effectively, which is what makes it sensible for brokers that rely on operate calls to take motion. These traits line up with use instances similar to contract overview, credit score settlement evaluation, and monetary doc query answering. In these instances, the mannequin causes over lengthy inputs after which calls out to techniques of document.

The way you entry Grok 4.3 on Amazon Bedrock

Grok 4.3 runs on Mantle, and accessing it differs from fashions that use the Amazon Bedrock Runtime API. Mantle makes use of OpenAI-compatible APIs. You possibly can invoke Grok 4.3 both with the OpenAI SDK or via direct HTTPS requests to the Chat Completions API or the Responses API.

The Mantle endpoint URL is Area-specific and follows this sample:

For instance, in us-west-2 the bottom URL is https://bedrock-mantle.us-west-2.api.aws/openai/v1. Word that the Responses API URL route differs barely on the Mantle endpoint (/openai/v1/) from the Runtime endpoint (/v1/responses).

To arrange your SDK with Grok 4.3, set the bottom URL with the proper Area and path as described within the previous part.

When utilizing Grok, notice that the context window is 1 million tokens and that the defaults depart from the usual OpenAI specification in three locations:

temperature defaults to 0.7 moderately than 1.
top_p defaults to 0.95 moderately than 1.
max_completion_tokens defaults to 131072.

Set these explicitly in case your utility wants totally different conduct.

Authenticate and run a primary request

You could have two methods to authenticate in opposition to the Mantle endpoint, and each work with the identical OpenAI SDK. For manufacturing, we advocate short-term bearer tokens generated out of your IAM credentials, as a result of they expire mechanically and preserve entry tied to your IAM id. Use a long-term Amazon Bedrock API key for fast exploration and getting began. Prohibit long-lived keys to that function moderately than embedding them in manufacturing functions.

The next instance reveals find out how to authenticate with a long-term Amazon Bedrock API key to entry the mannequin. Deal with this as an exploration-only credential. You possibly can generate one from the Amazon Bedrock console, after which set up the OpenAI SDK:

Level the consumer on the regional Mantle endpoint and authenticate along with your API key. The mannequin ID is xai.grok-4.3:

from openai import OpenAI

consumer = OpenAI(
    api_key="",
    base_url="https://bedrock-mantle.us-west-2.api.aws/openai/v1",
)

response = consumer.chat.completions.create(
    mannequin="xai.grok-4.3",
    messages=[
        {"role": "user", "content": "In one sentence, what is Amazon Bedrock?"}
    ],
)
print(response.selections[0].message.content material)

Whenever you’re prepared to include Amazon Bedrock into functions with better safety necessities, we advocate utilizing short-term credentials. You possibly can generate a short-term bearer token out of your current AWS credentials at request time utilizing the Amazon Bedrock token generator. This retains authentication tied to your IAM id and avoids a long-lived secret. To get began, set up the aws-bedrock-token-generator bundle.

pip set up aws-bedrock-token-generator

Use the provide_token operate from the aws_bedrock_token_generator library in code as proven under:

from aws_bedrock_token_generator import provide_token
from openai import OpenAI

consumer = OpenAI(
    api_key=provide_token(area="us-west-2"),
    base_url="https://bedrock-mantle.us-west-2.api.aws/openai/v1",
)

Configure reasoning output

You possibly can management how a lot of reasoning effort the mannequin spends via the reasoning parameter on the Responses API. The trouble ranges are none (which disables reasoning), low (the default), medium, and excessive. Larger effort tends to assist on multi-step issues the place a fast reply can be mistaken, at the price of extra output tokens.

The Chat Completions API doesn’t return a reasoning hint. If you need the mannequin’s reasoning obtainable throughout turns, use the Responses API. Within the default stateful sample, the place you set retailer=True and chain calls with previous_response_id, the service retains every flip’s reasoning and feeds it again mechanically, so you don’t handle it your self. Encrypted reasoning is for the stateless case. When you set retailer=False (for instance, when your workload requires that turns should not endured server-side), request the reasoning with embody=["reasoning.encrypted_content"]. Cross it again in your subsequent request’s enter to offer the mannequin its personal prior reasoning as context.

This instance runs a traditional trick query at excessive effort:

response = consumer.responses.create(
    mannequin="xai.grok-4.3",
    reasoning={"effort": "excessive"},  # none, low, medium, or excessive
    embody=["reasoning.encrypted_content"],
    max_output_tokens=4096,
    enter=(
        "A bat and ball value $1.10. The bat prices $1 greater than the ball. "
        "How a lot is the ball? Reply with simply the quantity."
    ),
)
print(response.output_text)
print(response.utilization.output_tokens_details.reasoning_tokens)

The mannequin labored via the algebra moderately than reaching for the intuitive mistaken reply of $0.10, and the utilization block experiences the reasoning tokens it spent internally. Drop the hassle to none and that very same discipline experiences 0 reasoning tokens, which is the setting to achieve for on easy, latency-sensitive calls:

response = consumer.responses.create(
    mannequin="xai.grok-4.3",
    reasoning={"effort": "none"},
    max_output_tokens=2048,
    enter="Say OK.",
)
print(response.output_text)  # OK.

A sensible sample is to run classification, extraction, and quick factual lookups at none or low, and reserve excessive for planning steps, math, and chains the place a single early mistake derails the entire activity.

Software calling is central to agentic workloads, and Grok 4.3 helps it via the identical OpenAI-compatible interface. You describe the instruments obtainable, the mannequin decides when to name one, and it returns a structured request that your code executes and feeds again. Grok 4.3 follows the usual OpenAI tool-calling form, so that you outline every instrument with a JSON Schema for its parameters.

The next instance affords a single get_weather instrument and asks a query that ought to set off it:

instruments = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        },
    }
]

response = consumer.chat.completions.create(
    mannequin="xai.grok-4.3",
    messages=[{"role": "user", "content": "What's the weather in Sydney? Use the tool."}],
    instruments=instruments,
    tool_choice="auto",  # let the mannequin resolve whether or not to name a instrument
)

tool_call = response.selections[0].message.tool_calls[0]
print(tool_call.operate.title, tool_call.operate.arguments)
# get_weather {"metropolis":"Sydney"}

The mannequin parsed the town out of the query and produced a legitimate arguments object that matches the schema. From right here you run the operate in your personal code, append a instrument position message with the consequence, and name the mannequin once more so it might probably fold the info right into a natural-language reply. That is the constructing block for multi-step brokers on Grok 4.3.

Structured output

Whenever you want the mannequin to return information your code can parse straight, use structured output with a JSON Schema. Grok 4.3 helps the json_schema response format with strict mode, so the response conforms to the schema you present, moderately than giving free-form textual content.

For instance, the next code asks for details a couple of nation and constrains the form of the reply:

import json

schema = {
    "kind": "object",
    "properties": {
        "title": {"kind": "string"},
        "capital": {"kind": "string"},
        "population_millions": {"kind": "quantity"},
    },
    "required": ["name", "capital", "population_millions"],
    "additionalProperties": False,
}

response = consumer.chat.completions.create(
    mannequin="xai.grok-4.3",
    messages=[{"role": "user", "content": "Return facts about the country Australia."}],
    response_format={
        "kind": "json_schema",
        "json_schema": {"title": "country_facts", "strict": True, "schema": schema},
    },
    max_completion_tokens=4096,
)

information = json.hundreds(response.selections[0].message.content material)
print(information)
# {'title': 'Australia', 'capital': 'Canberra', 'population_millions': 26.6}

Setting strict to True and additionalProperties to False retains the response constrained to the keys you requested for, which pairs effectively with instrument calling when a downstream system expects a set document format. One operational notice from testing: requests often return a 400 from an automatic content material security examine even on benign enter, so construct a brief retry into manufacturing calls.

Picture enter

Grok 4.3 accepts pictures as enter and returns textual content, which covers doc understanding, chart studying, and visible query answering. You move a picture utilizing the identical sample because the OpenAI Chat Completions API, as a content material half with a information: URL holding base64-encoded bytes, or a public picture URL. The textual content and picture elements go in the identical content material array so the mannequin sees the query and the image collectively.

import base64

with open("chart.png", "rb") as f:
    b64 = base64.b64encode(f.learn()).decode()

response = consumer.chat.completions.create(
    mannequin="xai.grok-4.3",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this image in one short sentence."},
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{b64}"},
                },
            ],
        }
    ],
    max_completion_tokens=4096,
)
print(response.selections[0].message.content material)

In testing, the mannequin learn a generated take a look at picture and named its dominant colour accurately. Use a supported picture format similar to PNG or JPEG and preserve the encoding clear: a malformed or truncated picture payload returns a validation_error moderately than a best-guess reply.

Stateful conversations with the Responses API

The Responses API can maintain dialog state on the service facet, so you do not want to resend the complete message historical past on each flip. You retailer a flip by passing retailer=True, seize the returned response ID, and reference it on the subsequent name with previous_response_id. The mannequin treats the sooner alternate as context.

first = consumer.responses.create(
    mannequin="xai.grok-4.3",
    enter="Keep in mind the quantity 42. Simply acknowledge.",
    retailer=True,
    max_output_tokens=2048,
)

second = consumer.responses.create(
    mannequin="xai.grok-4.3",
    previous_response_id=first.id,
    enter="What quantity did I ask you to recollect?",
    max_output_tokens=2048,
)
print(second.output_text)  # 42

From the second consumer.responses.create name within the code instance, there isn’t a message being despatched aside from the previous_response_id. As a result of the service shops every flip, the mannequin’s prior reasoning is carried ahead mechanically to the subsequent name, so you retain each the dialog and the mannequin’s pondering in scope with out managing that state your self. One factor to know earlier than you flip this on: storing dialog state means the service retains these turns. Evaluate the Amazon Bedrock information safety documentation for particulars on the safety and privateness of your saved information, and find out how to disable retention if wanted.

Service tiers and Regional availability

Amazon Bedrock affords a number of service tiers so you’ll be able to match value and throughput to every workload. Normal tier on-demand inference offers pay-per-token entry with no dedication, Precedence affords preferential remedy within the processing queue for a better per-token value, and Flex offers lower-cost entry for workloads that aren’t time-sensitive. You need to use Grok 4.3 with the Normal, Precedence, and Flex tiers. For particulars, see service tiers for inference.

Grok 4.3 makes use of in-Area inference, so that you pin your consumer to a Area the place the mannequin is obtainable and set the Mantle base URL to match. Geo and World cross-Area inference should not provided for this mannequin at launch. The examples on this publish use us-west-2. For the present listing of supported Areas, see the Regional availability documentation, and for pricing throughout the tiers, see the Amazon Bedrock pricing web page.

Conclusion

Grok 4.3 on Amazon Bedrock provides you a reasoning-first mannequin with configurable effort, native instrument calling, strict structured output, picture understanding, and server-side dialog state. You possibly can attain the mannequin via the OpenAI SDK pointed on the bedrock-mantle endpoint. The examples on this publish don’t create billable AWS sources past per-request token utilization. However should you generated a long-term Amazon Bedrock API key for exploration, delete it from the Amazon Bedrock console if you end up completed. An extended-term secret is a standing credential, so eradicating those you not want retains your account’s assault floor small.

To begin constructing, overview the Grok 4.3 mannequin card for the present Area listing and parameter particulars, and see the Amazon Bedrock pricing web page for token charges. From there, just a few instructions are price exploring: wire the tool-calling loop finish to finish by executing the returned operate and feeding the consequence again, thread encrypted reasoning content material throughout Responses turns to offer long-running brokers continuity in how they suppose, and benchmark effort ranges in opposition to your personal workloads to search out the place increased reasoning stops incomes its token value. Be part of the dialogue within the Amazon Bedrock group on AWS re:Publish.