GPT-5.6 no Amazon Bedrock: três modelos, um endpoint
A AWS anunciou a disponibilidade geral dos modelos GPT-5.6 Sol, Terra e Luna no Amazon Bedrock. A proposta é direta: desenvolvedores que precisam de modelos de fronteira para workloads de codificação agêntica, raciocínio de longa duração e inferência de alto volume agora podem acessá-los pela API familiar da OpenAI, sem precisar operar infraestrutura de modelos separada.
O GPT-5.6 introduz um sistema de nomenclatura onde o número identifica a geração e os nomes Sol, Terra e Luna identificam camadas de capacidade duráveis que podem evoluir de forma independente. A tabela abaixo resume as especificações de cada modelo:
- Sol (
openai.gpt-5.6-sol): ideal para codificação autônoma, pesquisa de segurança, análise científica e raciocínio profundo em múltiplos passos. Disponível em US East (N. Virginia) e US East (Ohio). - Terra (
openai.gpt-5.6-terra): equilibra raciocínio, desempenho e custo para workloads de produção de uso geral. Disponível em US East (N. Virginia), US East (Ohio) e US West (Oregon). - Luna (
openai.gpt-5.6-luna): otimizado para workloads de alto volume e baixa latência, como classificação, sumarização e roteamento. Disponível nas mesmas regiões do Terra.
Os três modelos suportam entrada de texto e imagem, saída de texto, uma janela de contexto de 272 mil tokens e a Responses API. Todos também suportam os níveis de esforço de raciocínio: none, low, medium, high, xhigh e max. O preço corresponde às tarifas de primeira parte da OpenAI, e o uso conta para os compromissos existentes da AWS.
Acessando o GPT-5.6 pelo endpoint bedrock-mantle
O acesso aos modelos GPT-5.6 é feito pela Responses API da OpenAI no endpoint bedrock-mantle. A URL base é https://bedrock-mantle.{region}.api.aws, e a Responses API fica em /openai/v1/responses. Basta substituir {region} pela região AWS desejada, como us-east-1.
O endpoint funciona com os SDKs Python e TypeScript da OpenAI. Para migrar uma aplicação existente, basta substituir a URL base da OpenAI pelo endpoint bedrock-mantle, usar o ID do modelo correspondente no Amazon Bedrock e autenticar com uma chave de API do Amazon Bedrock ou credenciais AWS.
Segurança e controle de dados
Cada chamada de modelo é executada sob as políticas do AWS Identity and Access Management (IAM), dentro da sua nuvem privada virtual (VPC) e registrada no AWS CloudTrail. A inferência em região mantém as requisições dentro da região AWS especificada, o que ajuda equipes a atender requisitos de residência de dados.
Por serem modelos de terceiros, o GPT-5.6 Sol, Terra e Luna estão sujeitos a os termos da OpenAI. Para esses modelos, tráfego sinalizado por classificadores é retido por até 30 dias para detecção de abuso automatizada offline. As entradas e saídas retidas são armazenadas e processadas pela AWS e não são compartilhadas com o provedor do modelo, a menos que você opte por isso. O controle da configuração de retenção é feito pelo modo de retenção de dados. Vale destacar que seus prompts e respostas não são usados para treinar modelos.
Primeiros passos: pré-requisitos e autenticação
Para usar os modelos GPT-5.6, é necessário uma conta AWS com permissões para executar inferências no endpoint bedrock-mantle. Uma forma de conceder essas permissões é anexar a política gerenciada AmazonBedrockMantleInferenceAccess ao seu principal do IAM. Ela concede acesso de leitura e criação de inferências, incluindo bedrock-mantle:CreateInference e bedrock-mantle:CallWithBearerToken.
Instale o SDK Python da OpenAI, versão 2.45.0 ou superior:
pip install "openai>=2.45.0"A autenticação pode ser feita de duas formas:
Chave de curta duração com atualização automática: o cliente nativo BedrockOpenAI do SDK usa um provedor de token que gera uma chave de curta duração a partir das credenciais AWS e a atualiza antes de cada requisição. Os exemplos deste artigo usam esse cliente.
from aws_bedrock_token_generator import provide_token
from openai import BedrockOpenAI
region = "us-east-1"
client = BedrockOpenAI(
aws_region=region,
bedrock_token_provider=lambda: provide_token(region=region),
)Chave de curta duração via variável de ambiente: defina a chave em AWS_BEARER_TOKEN_BEDROCK e passe-a ao cliente. Como essa chave não é atualizada automaticamente, ela expira em no máximo 12 horas. Para produção, prefira a opção com atualização automática ou armazene a chave no AWS Secrets Manager.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://bedrock-mantle.us-east-1.api.aws/openai/v1",
api_key=os.environ["AWS_BEARER_TOKEN_BEDROCK"],
)Executando a primeira inferência com a Responses API
Com o cliente configurado, é possível chamar o GPT-5.6 Terra pela Responses API. A API usa um único campo input e retorna o texto gerado em output_text.
response = client.responses.create(
model="openai.gpt-5.6-terra",
input="Explain the benefits of prompt caching for agentic workloads.",
max_output_tokens=512,
store=False,
)
print(response.output_text)Controlando o esforço de raciocínio
Os modelos GPT-5.6 podem gastar tokens adicionais de raciocínio em tarefas complexas de múltiplos passos antes de responder, o que melhora os resultados mas aumenta a latência e o custo. O nível é definido com o parâmetro reasoning.
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"},
)
print(response.output_text)Chamando ferramentas (tool calling)
O GPT-5.6 suporta chamada de ferramentas, permitindo que o modelo solicite ferramentas definidas pela aplicação e use seus resultados para completar uma requisição. O exemplo abaixo demonstra a chamada de ferramenta no lado do cliente, onde a aplicação executa a ferramenta e retorna o resultado ao modelo.
import json
tools = [
{
"type": "function",
"name": "get_weather",
"description": "Get the current weather for a given location",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "City and country (for example, Seattle, US)",
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "Temperature unit",
},
},
"required": ["location"],
},
}
]
# Step 1: Send the user request with the tool definition.
input_list = [{"role": "user", "content": "What's the weather like in Seattle?"}]
response = client.responses.create(
model="openai.gpt-5.6-terra",
input=input_list,
tools=tools,
)
# Step 2: Carry the model's output (including any reasoning items) into the next turn.
input_list += response.output
# Step 3: Run each requested function and append its result.
for item in response.output:
if item.type == "function_call":
args = json.loads(item.arguments)
result = {
"location": args["location"],
"temperature": 64,
"condition": "Partly cloudy",
}
input_list.append(
{
"type": "function_call_output",
"call_id": item.call_id,
"output": json.dumps(result),
}
)
# Step 4: Ask the model for the final response, incorporating the tool result.
final_response = client.responses.create(
model="openai.gpt-5.6-terra",
input=input_list,
tools=tools,
)
print(final_response.output_text)Como os modelos GPT-5.6 raciocinam antes de responder, é importante passar os itens de saída do modelo (que podem incluir raciocínio) de volta na próxima requisição, como o exemplo acima faz ao acrescentar response.output à lista de entrada. Para implantações em produção, a AWS recomenda usar o Amazon Bedrock Guardrails para implementar salvaguardas personalizadas às suas políticas de IA responsável.
Reduzindo custos com cache de prompts
Workloads agênticos e de múltiplos passos repetem grande parte do contexto entre chamadas — instruções de sistema, definições de ferramentas e arquivos de referência costumam permanecer iguais enquanto apenas a entrada mais recente muda. O GPT-5.6 suporta cache de prompts em dois modos no Amazon Bedrock.
- Cache implícito: ativado por padrão. Requisições elegíveis são cacheadas automaticamente sem alterações no código.
- Cache explícito: permite marcar pontos de quebra de cache para controle preciso sobre quais partes do prompt são cacheadas.
Em ambos os modos, o cache reduz o custo de processar repetidamente contextos compartilhados conforme o volume de requisições cresce. Tokens de entrada cacheados são cobrados com 90% de desconto em relação a tokens não cacheados, e tokens gravados no cache são cobrados a 1,25 vezes a taxa de entrada não cacheada. Consulte a página de preços do Amazon Bedrock para valores atualizados. O conteúdo cacheado fica disponível por pelo menos 30 minutos.
Cache explícito com pontos de quebra
Para cachear um prefixo, adicione um prompt_cache_breakpoint ao bloco de conteúdo que encerra a seção reutilizável e defina prompt_cache_options para o modo explícito. Definir um prompt_cache_key consistente entre requisições direciona-as ao mesmo cache e melhora a confiabilidade de correspondência. Cada ponto de quebra requer um prefixo de pelo menos 1.024 tokens, e é possível definir até quatro pontos de quebra de cache por requisição.
# Replace with your real system instructions and reference content.
# The cached prefix must be at least 1,024 tokens, or nothing is cached.
system_prompt = "You are a technical support agent for Example Corp. ...(1,024+ tokens)..."
def ask(question):
return client.responses.create(
model="openai.gpt-5.6-terra",
prompt_cache_key="support-agent:system-prompt-v1",
prompt_cache_options={"mode": "explicit"},
input=[
{
"type": "message",
"role": "developer",
"content": [
{
"type": "input_text",
"text": system_prompt,
# Cache everything up to this breakpoint (the system instruction).
"prompt_cache_breakpoint": {"mode": "explicit"},
}
],
},
{
"type": "message",
"role": "user",
"content": [{"type": "input_text", "text": question}],
},
],
)
# First call: writes the prefix to cache.
first = ask("How do I configure single sign-on?")
print("write:", first.usage.input_tokens_details.cache_write_tokens)
# Second call with the same prefix and cache key: read the prefix from cache.
second = ask("How do I reset a password?")
print("read: ", second.usage.input_tokens_details.cached_tokens)
print(second.output_text)Cache implícito
Se prompt_cache_options não for definido, o GPT-5.6 usa o cache implícito. O Amazon Bedrock coloca automaticamente um ponto de quebra de cache na mensagem mais recente e respeita quaisquer pontos de quebra explícitos adicionados. A recomendação é manter o conteúdo estático (instruções de sistema, definições de ferramentas, documentos de referência) no início do prompt e o conteúdo variável no final, além de definir um prompt_cache_key consistente para requisições relacionadas.
response = client.responses.create(
model="openai.gpt-5.6-terra",
prompt_cache_key="support-agent:kb-v1",
input=[
{
"type": "message",
"role": "developer",
# Static content first so it forms a stable, cacheable prefix.
"content": [{"type": "input_text", "text": system_prompt}],
},
{
"type": "message",
"role": "user",
"content": [{"type": "input_text", "text": "How do I configure single sign-on?"}],
},
],
)
print(response.output_text)O cache explícito é mais adequado para loops agênticos com um prefixo grande e estável, onde se deseja controle total sobre o que é cacheado. O cache implícito é mais simples e se adapta bem a workloads de chat e RAG (Geração Aumentada por Recuperação) com um prefixo naturalmente estável. A cobrança é a mesma nos dois modos. Para desativar o cache em uma requisição, defina prompt_cache_options para o modo explícito sem adicionar nenhum ponto de quebra.
Monitorando a taxa de acerto do cache
Cada resposta reporta a atividade de cache no objeto usage. O campo input_tokens_details.cached_tokens indica o número de tokens lidos do cache, e cache_write_tokens indica os gravados. Como cached_tokens já faz parte do total de input_tokens, a taxa de acerto do cache pode ser calculada dividindo cached_tokens por input_tokens.
usage = response.usage
details = usage.input_tokens_details
cached = getattr(details, "cached_tokens", 0) or 0
cache_write = getattr(details, "cache_write_tokens", 0) or 0
total_input = usage.input_tokens
hit_rate = cached / total_input if total_input else 0.0
print(f"Cached tokens: {cached}")
print(f"Written tokens: {cache_write}")
print(f"Total input: {total_input}")
print(f"Cache hit rate: {hit_rate:.1%}")O endpoint bedrock-mantle publica métricas de tokens de conta, projeto e modelo no Amazon CloudWatch sob o namespace AWS/BedrockMantle, mas não publica uma métrica específica de cache — portanto, o objeto de uso da resposta é a fonte oficial para medir o desempenho do cache.
Usando o GPT-5.6 com o Codex
O Codex é o agente de codificação da OpenAI para desenvolvedores. Ele trabalha com arquivos locais, repositórios, terminais e ambientes de desenvolvimento para escrever funcionalidades, corrigir bugs, executar testes e abrir pull requests. É possível executá-lo pela linha de comando (Codex CLI), como extensão de IDE para Visual Studio Code e JetBrains, ou no aplicativo desktop do ChatGPT.
Para apontar o Codex para o Amazon Bedrock, basta definir o modelo e o provedor no arquivo ~/.codex/config.toml:
model = "openai.gpt-5.6-sol"
model_provider = "amazon-bedrock"
[model_providers.amazon-bedrock.aws]
region = "us-east-1"O Codex autentica com uma chave de API ou com as credenciais do SDK AWS. Se AWS_BEARER_TOKEN_BEDROCK estiver definido, o Codex o usa primeiro; caso contrário, recorre à cadeia de credenciais do SDK AWS. O aplicativo desktop do ChatGPT e a extensão de IDE podem não herdar o ambiente do shell, então é recomendável colocar as variáveis necessárias em ~/.codex/.env:
AWS_BEARER_TOKEN_BEDROCK=<your-api-key>Reinicie o aplicativo ou a extensão após alterar ~/.codex/config.toml ou ~/.codex/.env. Para tarefas de codificação, esforços de raciocínio mais altos são adequados para refatorações e depurações complexas, enquanto níveis mais baixos mantêm edições rotineiras rápidas. No aplicativo desktop do ChatGPT, é possível escolher entre Light, Medium, High e Extra High para cada tarefa.
Cotas e escalonamento
As requisições aos modelos GPT-5.6 usam inferência sob demanda no nível de serviço Standard, onde se paga por token sem reservar capacidade. A inferência no endpoint bedrock-mantle é governada por duas cotas por modelo e por região: uma para tokens de entrada por minuto e outra para tokens de saída por minuto. Não há cota de requisições por minuto.
Tokens de entrada cacheados lidos pelo cache de prompts não contam para a cota de tokens de entrada por minuto — mais um motivo pelo qual o cache ajuda em escala. Se uma cota de tokens por minuto for excedida, o endpoint retorna uma resposta HTTP 429. A recomendação é tratar throttling transitório com backoff exponencial e um contador limitado de tentativas, que o SDK da OpenAI suporta pela configuração max_retries:
from aws_bedrock_token_generator import provide_token
from openai import BedrockOpenAI
region = "us-east-1"
client = BedrockOpenAI(
aws_region=region,
bedrock_token_provider=lambda: provide_token(region=region),
max_retries=6,
)Para reduzir o throttling em alto volume sustentado, distribua workloads grandes ao longo de vários minutos em vez de disparar em rajadas rápidas. Para mais detalhes, consulte as cotas para o endpoint bedrock-mantle.
Limpeza e custos
A inferência sob demanda gera cobranças apenas quando um modelo é invocado, portanto não há infraestrutura para desativar. Se uma chave de API de curta duração foi gerada, ela expira automaticamente em até 12 horas. Para revogar uma chave antes disso, exclua-a no novo console do Amazon Bedrock. Cada invocação de modelo gera cobranças por token — consulte a tabela de preços do Amazon Bedrock para valores atualizados.
Próximos passos
Para quem quer explorar os modelos GPT-5.6 no Amazon Bedrock, a AWS sugere os seguintes passos iniciais:
- Abra o novo console do Amazon Bedrock, crie um projeto e avalie um modelo GPT-5.6 com seus próprios prompts.
- Execute o exemplo da Responses API com seus próprios dados.
- Adicione um ponto de quebra de cache explícito a um prefixo de prompt repetido e meça a taxa de acerto do cache.
- Avalie Sol, Terra e Luna nos seus workloads para escolher a variante que melhor se adequa ao seu perfil de custo e latência.
Para mais informações, consulte a documentação do Amazon Bedrock, os cards de modelo OpenAI no Amazon Bedrock, o guia de cache de prompts para inferência mais rápida e as cotas para o endpoint bedrock-mantle.
Fonte
Get started with OpenAI GPT-5.6 Sol, Terra, and Luna on Amazon Bedrock (https://aws.amazon.com/blogs/machine-learning/get-started-with-openai-gpt-5-6-sol-terra-and-luna-on-amazon-bedrock/)
Leave a Reply