Get Started with OpenAI GPT-5.6 on Amazon Bedrock: Reasoning, Tool Calling, and Caching

Summary

AWS's article positions Luna as a high-throughput, low-latency model for classification, summarization, and routing, and uses Responses API examples to show how to set reasoning effort, call tools, carry the model's output in full into the next turn, and cache a stable prefix with a prompt cache key and cache breakpoint.

Key Prompting and Engineering Practices

• For simple, high-volume tasks, start with none or low reasoning; raise it to medium, high, xhigh, or max for complex, multi-step tasks.

• After a tool call, append the model's previous response.output (including reasoning items) to the next input.

• Put stable system instructions, tool definitions, and reference materials at the front of the prompt, and put the changing user question at the end.

• Use explicit cache breakpoints when you need precise control; implicit caching is used when prompt_cache_options is not set.

• The cache prefix in the example must contain at least 1,024 tokens, and the cache key should remain consistent across related requests.

Reusable Code Snippets

response = client.responses.create(
    model="openai.gpt-5.6-luna",
    input="Classify these support tickets by urgency and route them to the right team.",
    reasoning={"effort": "low"},
    max_output_tokens=512,
    store=False,
)
print(response.output_text)

Key structure of a tool-calling loop:

input_list += response.output
for item in response.output:
    if item.type == "function_call":
        result = run_tool(item.arguments)
        input_list.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": json.dumps(result),
        })
final_response = client.responses.create(
    model="openai.gpt-5.6-luna",
    input=input_list,
    tools=tools,
)

Original Article

The following is the main visible body text extracted through the Tabbit international app, with the original English preserved; AWS navigation and unrelated footer content have been omitted.

OpenAI GPT-5.6 Sol, Terra, and Luna are now generally available on Amazon Bedrock. Sol is the flagship reasoning model, Terra balances performance and cost for everyday production work, and Luna is optimized for fast, low-cost inference, such as classification, summarization, and routing.

All three models support text and image input, text output, a 272K-token context window, and the Responses API. They also support none, low, medium, high, xhigh, and max reasoning effort.

Control reasoning effort

GPT-5.6 models can spend additional reasoning tokens on complex, multi-step tasks before answering, which improves results but increases latency and cost. Set the level with the reasoning parameter. Match the level to the task.

response = client.responses.create( model="openai.gpt-5.6-sol", input="A train leaves at 3 PM at 60 km/h. Another leaves an hour later at 90 km/h from the same station. When does the second catch up?", reasoning={"effort": "high"}, )

Call tools

GPT-5.6 supports tool calling. The model requests tools, the application runs them and returns the result, and the model produces the final response. Because GPT-5.6 models reason before responding, pass the model’s output items, which can include reasoning, back in the next request.

Reduce cost with GPT-5.6 prompt caching

Agentic and multi-step workloads repeat much of their context between calls. System instructions, tool definitions, and reference files often stay the same while only the latest input changes. GPT-5.6 supports implicit caching by default and explicit caching with cache breakpoints.

With a cache breakpoint, you mark the end of a reusable prompt prefix. On a subsequent request that shares that prefix, Amazon Bedrock reuses the processed context, and each call pays full price only for the new work. Cached input is billed at a 90% discount compared to uncached input tokens, and tokens written to cache are billed at 1.25 times the uncached input rate.

Explicit caching with cache breakpoints

The cached prefix must be at least 1,024 tokens, or nothing is cached. Setting a consistent prompt_cache_key across requests routes them to the same cache and improves match reliability.

Implicit caching

If you don’t set prompt_cache_options, GPT-5.6 uses implicit caching. Keep static content—system instructions, tool definitions, reference documents—at the front of the prompt and variable content at the end, set a consistent prompt_cache_key for related requests, and the endpoint reuses the processed prefix when it matches.