Tabbit
ResourcesBlogModels
Tabbit LogoTabbit

Tabbit — The AI Browser that Works for You

Topics

  • Best Browsers 2026: Rankings and Top Lists
  • AI Browser Guides and Resources
  • Browser Comparisons: Head-to-Head Guides
  • Browser Reviews and Explainers
  • Browser Alternatives
  • Browser Directory: Guides by Browser
  • Agentic Browser Resources
  • Browser Downloads and Install Guides
  • Browser Productivity Resources
  • SillyTavern Model Guides and Presets

Popular Guides

  • Best Browsers 2026: Top 10 Ranked & Compared
  • Best Free AI Browsers 2026: Plans & Prices Compared
  • Rabbit Browser: What It Is & Why Tabbit Is Better
  • Firefox vs Chrome 2026: Privacy, RAM & Speed Compared
  • Best Lightweight Browsers 2026: 7 Tested for RAM & Speed
  • AI Browser List 2026: 10 Browsers Compared
  • Neobrowser: Norton Neo, Download & Alternatives
  • Edge vs Chrome 2026: Speed, RAM & Battery Tested
  • Best Internet Browser for Android 2026
  • Best AI Browser 2026: Top 9 Tested & Ranked

Events

  • Tabbit Skill Competition
  • KPOP SBTI Fandom Personality Test
  • Tabbit Campus Creator Program
  • fifi's Picks: AI Skills for Research Papers
  • User Survey

About

  • Tabbit Blog
  • Press & Media
English
简体中文English
Showcases & prompts

GPT-5.6 Luna · Configuration

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

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。

Source reviewed; not testedGPT-5.6 Luna API-compatible client; confirm model ID, tools, reasoning settings and limits before execution.

Prerequisites and inputs

  • API credentials
  • model ID
  • tool schema
  • test input
  • failure handling

Task outcome\n\nTurn “Get Started with OpenAI GPT-5.6 on Amazon Bedrock: Reasoning, Tool Calling, and Caching” into a checkable starting workflow; do not treat a showcase as general capability.\n\n## Prerequisites\n\n- Prepare the goal, inputs, runtime, and acceptance criteria.\n- Confirm the live GPT-5.6 Luna entry, tool permissions, and version.\n\n## Steps\n\n1. Run a minimal input first and record the model, tools, latency, and failure state.\n2. Check the output against the required format and acceptance criteria, then add missing constraints.\n3. Manually review facts, code, visual artifacts, and external actions.\n\n## Boundary\n\nThis guide is an editorial adaptation of the source observation; it does not claim that Tabbit has verified the source client capabilities.

Read the source research notes

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.

Source and dates

AWS Machine Learning Blog · Source date: 2026-07-24 · Edited: 2026-09-20

Read the original source
Variable checklist

No required variables

Related showcases & prompts

GPT-5.6 Luna API Model Parameters and Cost ConfigurationThe Builder's Guide to GPT-5.6: Luna's Model Selection, Agent Orchestration, and CachingGPT-5.6 Prompting Guide: Luna's Work Contract and Model RoutingApply Occam’s Razor: Reducing Overengineering in Luna/Codex Prompts

Related reviews

GPT-5.6 Luna Reddit Codex Quota and Cache Cost: A Hands-on MeasurementGPT-5.6 Luna Benchmarks & Pricing (Public Benchmarks & Pricing)I Benchmarked GPT-5.6 Sol/Luna/Terra by Role: Role-Based EvaluationAgents on Rails: 8 Models, 21 Atomic Tasks

GPT-5.6 Luna

Use GPT-5.6 Luna in Tabbit

Run this guide in the environment listed above. Downloading does not transfer the template or establish model availability for your account.