GPT-5.6 Chamada Programática de Ferramentas: o modelo agora escreve o código de orquestração

A chamada de função clássica segue um loop que todo construtor de agentes conhece: o modelo solicita uma ferramenta, sua aplicação a executa, você envia o resultado de volta e o modelo solicita a próxima. Quatro ferramentas significam quatro viagens de ida e volta; quarenta ferramentas, quarenta. Cada passagem adiciona latência de rede e contexto reprocessado. Quando a OpenAI lançou o GPT-5.6 para disponibilidade geral em 9 de julho de 2026, também disponibilizou uma alternativa na Responses API: a chamada programática de ferramentas.

Experimente o Apidog hoje

Em vez de devolver chamadas de ferramentas uma por vez para sua aplicação executar em um loop, o modelo escreve JavaScript para orquestrar várias ferramentas. Esse código é executado em um ambiente V8 isolado e sem acesso à rede. Suas ferramentas continuam sendo a única forma de tocar sistemas externos, portanto o limite de segurança da chamada de função da OpenAI permanece no mesmo lugar. A mudança está no fluxo de controle: loops, condicionais e agregações deixam de morar na sua aplicação.

Isso também aumenta a exigência sobre sua API. Cada ferramenta pode ser chamada em rajadas, não apenas uma vez por turno. Esquemas precisos, erros estruturados, idempotência e limites de taxa passam a ser requisitos práticos. Neste guia, você verá o que mudou, como o loop clássico funciona, como preparar endpoints de ferramentas e como testá-los com o Apidog.

TL;DR

• O GPT-5.6 foi lançado em GA em 9 de julho de 2026, e a Responses API recebeu chamada programática de ferramentas.
• Em vez de uma chamada de ferramenta por viagem de ida e volta, o modelo escreve JavaScript para compor loops, condicionais e agregações.
• O código gerado roda em uma sandbox V8 isolada e sem rede. Ferramentas declaradas continuam sendo o único caminho para sistemas externos.
• A latência e o custo de tokens deixam de crescer linearmente com o número de chamadas no loop clássico.
• Consulte a referência da API da OpenAI para os parâmetros, limites de execução e timeouts atuais.
• Teste, simule e valide cada endpoint de ferramenta: uma ambiguidade de esquema pode ser repetida em um loop inteiro.

O que foi lançado em 9 de julho

O GPT-5.6 chegou como uma família de três níveis:

• gpt-5.6-sol para raciocínio mais profundo;
• gpt-5.6-terra para trabalho equilibrado;
• gpt-5.6-luna para volume rápido e econômico.

O alias gpt-5.6 direciona para Sol. Os três modelos são disponibilizados via API em autoatendimento após uma prévia limitada de duas semanas, encerrada quando a restrição de acesso foi suspensa em 8 de julho.

A família de modelos recebeu atenção no lançamento, mas a superfície da API é especialmente relevante para agentes. Segundo a cobertura do MarkTechPost e a documentação da OpenAI, a Responses API recebeu:

1. chamada programática de ferramentas;
2. multiagente em beta;
3. raciocínio persistido entre turnos;
4. configurações de detalhes de visão que preservam dimensões originais de imagem.

A chamada programática de ferramentas é o ponto principal: o modelo escreve JavaScript para orquestrar ferramentas, e esse código é executado em um ambiente V8 isolado, sem acesso à rede.

O loop que a chamada programática substitui

Este é o padrão clássico de chamada de função na Responses API:

import OpenAI from "openai";

const client = new OpenAI();

const tools = [
  {
    type: "function",
    name: "get_flight_status",
    description: "Return live status for a flight by IATA flight number.",
    parameters: {
      type: "object",
      properties: {
        flight_number: {
          type: "string",
          description: "IATA flight number, for example SQ317"
        }
      },
      required: ["flight_number"]
    }
  }
];

let response = await client.responses.create({
  model: "gpt-5.6",
  input: "Which of these 12 flights are delayed: SQ317, BA15, UA857...",
  tools
});

Quando o modelo precisa de dados, ele emite uma chamada de função. Sua aplicação executa a ferramenta, envia um item function_call_output e solicita uma nova resposta:

// Uma viagem de ida e volta por chamada de ferramenta.
while (hasFunctionCalls(response)) {
  const outputs = await executeToolCalls(response);

  response = await client.responses.create({
    model: "gpt-5.6",
    previous_response_id: response.id,
    input: outputs,
    tools
  });
}

Para consultar 12 voos, esse loop pode executar 12 iterações. Cada uma tem dois custos:

1. Latência: uma viagem de rede até a OpenAI, mais o tempo de inferência do modelo.
2. Tokens: os resultados das ferramentas entram no contexto, então chamadas posteriores podem reprocessar dados de chamadas anteriores.

Em fluxos com múltiplos agentes, esse custo se multiplica. Um agente com cinco etapas e dez chamadas de ferramenta por etapa pode resultar em cinquenta invocações de modelo.

O loop não é raciocínio. É infraestrutura de orquestração.

Como o modo programático muda o fluxo

Com a chamada programática de ferramentas, o modelo pode responder à mesma tarefa de voos escrevendo um pequeno programa JavaScript que:

1. percorre a lista de números de voo;
2. chama get_flight_status para cada item;
3. filtra voos atrasados;
4. classifica por duração do atraso;
5. retorna o resultado agregado.

A sandbox executa o programa. As ferramentas continuam fazendo o trabalho real, mas o fluxo de controle passa para o modelo.

Três propriedades tornam esse modelo viável:

• Execução isolada: o JavaScript roda em uma sandbox V8 sem acesso à rede.
• Ferramentas como única saída: todo efeito externo passa pelas ferramentas que você declarou.
• Fluxo de controle expressivo: loops, condicionais, agregações e saídas antecipadas podem ocorrer no mesmo ciclo de resposta.

	Chamada de função clássica	Chamada programática de ferramentas
Quem escreve o fluxo de controle	Sua aplicação	O modelo, em JavaScript
Viagens de ida e volta para N ferramentas	N, geralmente serializadas	Um ciclo de resposta
Onde a orquestração roda	Sua infraestrutura	Sandbox V8 isolada e sem rede
Como ferramentas são executadas	Seu código as invoca	Pela superfície de ferramentas declarada
Limite de segurança	Definições de ferramentas	Definições de ferramentas, inalteradas

O que permanece igual

Você ainda define ferramentas com nomes, descrições e parâmetros JSON Schema. O modelo só pode compor chamadas para ferramentas declaradas.

Em outras palavras, a pergunta de segurança continua a mesma:

O que este agente pode fazer nos meus sistemas?

A resposta é: apenas o que sua superfície de ferramentas permite.

No entanto, a qualidade do esquema passa a importar ainda mais. No loop clássico, uma descrição vaga pode gerar uma chamada inválida que você detecta antes da próxima iteração. No modo programático, a mesma ambiguidade pode entrar em um loop e ser repetida várias vezes.

Aplique os mesmos cuidados de saídas estruturadas:

• use tipos estritos;
• defina enum para conjuntos fechados;
• informe unidades e formatos nas descrições;
• marque como obrigatórios apenas campos realmente obrigatórios;
• valide entradas e respostas no endpoint.

Por exemplo, prefira um contrato explícito como este:

{
  "type": "object",
  "properties": {
    "date": {
      "type": "string",
      "format": "date",
      "description": "Data no formato ISO 8601: YYYY-MM-DD."
    },
    "currency": {
      "type": "string",
      "enum": ["BRL", "USD", "EUR"],
      "description": "Moeda de saída."
    }
  },
  "required": ["date", "currency"],
  "additionalProperties": false
}

Limites e perguntas em aberto

Essa capacidade é recente. Antes de reconstruir sua arquitetura de agentes, considere estas precauções:

• Os parâmetros de solicitação, limites de execução e comportamento de timeout devem ser confirmados na referência da API e no guia do modelo GPT-5.6.
• A depuração muda: quando a orquestração vivia no seu repositório, era possível usar breakpoints. Agora, parte do fluxo é gerada a cada solicitação.
• Registre a sequência de chamadas de ferramentas, argumentos, duração, respostas e falhas.
• Ainda não há histórico amplo de produção. As notas de Simon Willison sobre o GPT-5.6 podem ajudar a acompanhar testes independentes e limitações encontradas.
• Comece com ferramentas somente leitura. Observe a orquestração, compare tokens e latência com o loop anterior e só depois exponha ferramentas com efeitos colaterais.

Suas ferramentas agora são uma API para código gerado

No modelo clássico, uma ferramenta costuma ser chamada uma vez por turno, sob um loop criado por humanos. No modo programático, código gerado pode chamar ferramentas em rajadas, ramificar conforme as respostas e agregar os resultados.

Trate cada ferramenta como uma API consumida por um cliente automatizado.

1. Torne o esquema inequívoco

Documente unidades, formatos, limites e valores permitidos.

Evite:

{
  "date": "string"
}

Prefira:

{
  "date": {
    "type": "string",
    "format": "date-time",
    "description": "Data e hora em UTC no formato ISO 8601, por exemplo 2026-07-09T14:30:00Z."
  }
}

2. Retorne erros estruturados

Não responda 200 OK com uma mensagem de erro escondida em uma string. O código gerado precisa diferenciar sucesso, erro de validação, ausência de recurso e falha temporária.

Exemplo de resposta de erro:

{
  "error": {
    "code": "FLIGHT_NOT_FOUND",
    "message": "Nenhum voo encontrado para o número informado.",
    "details": {
      "flight_number": "SQ000"
    }
  }
}

Use códigos HTTP coerentes:

• 400 para entrada inválida;
• 404 para recurso inexistente;
• 409 para conflito;
• 429 para limite de taxa;
• 500 ou 503 para falhas do servidor.

3. Planeje rajadas e repetição

Doze chamadas que antes chegavam ao longo de um minuto podem chegar em uma única rajada. Antes de expor uma ferramenta, valide:

• limites de taxa;
• concorrência máxima;
• comportamento de retry;
• idempotência;
• paginação;
• timeout;
• limites de payload.

Para operações com efeitos colaterais, aceite uma chave de idempotência:

POST /payments
Idempotency-Key: 8f13c72a-8f9c-4c49-a2a9-7f0e0b5e2f71

4. Meça a latência por chamada

Uma ferramenta que leva oito segundos pode ser aceitável em uma operação isolada. Em um loop de doze iterações, ela passa a definir o tempo total da resposta.

Registre pelo menos:

tool_name
request_id
latency_ms
status_code
error_code
retry_count

Teste a superfície de ferramentas antes da produção

Antes de entregar ferramentas ao modelo:

1. defina ou importe a especificação de cada endpoint;
2. valide exemplos válidos e inválidos;
3. confirme que respostas correspondem ao esquema declarado;
4. teste limites de taxa e concorrência;
5. simule cenários de erro previsíveis;
6. registre chamadas e respostas para auditoria.

Com o Apidog, você pode definir ou importar contratos de API, enviar requisições de teste e usar o servidor de simulação integrado para retornar respostas baseadas em esquema. Isso permite exercitar a orquestração usando dados falsos e previsíveis antes de tocar em produção.

Outras funcionalidades GA em resumo

A chamada programática de ferramentas não chegou sozinha. Duas adições adjacentes da Responses API importam para arquiteturas de agentes:

• Multiagente, em beta: execução paralela de subagentes gerenciada pela API. É um recurso inicial, mais adequado para avaliação do que para dependência crítica.
• Raciocínio persistido: reutilização de contexto de raciocínio entre turnos por meio de reasoning.context, reduzindo trabalho repetido em sessões longas.

Esses recursos podem se complementar: um agente que preserva raciocínio entre turnos e também orquestra ferramentas em código pode reduzir trabalho redundante por tarefa.

Chamada programática de ferramentas vs. modo ultra

O lançamento também trouxe o modo ultra. Os dois recursos podem parecer similares porque ambos fazem mais por solicitação, mas resolvem gargalos diferentes.

O modo ultra é uma configuração multiagente que executa quatro agentes em paralelo por padrão, usando mais tokens para reduzir o tempo total. Segundo a OpenAI, ele eleva o Terminal-Bench 2.1 de 88,8% para 91,9%. Está disponível no ChatGPT Work nos planos Pro e Enterprise, e no Codex a partir do Plus.

A chamada programática de ferramentas é diferente:

• Modo ultra: paraleliza o raciocínio.
• Chamada programática de ferramentas: reduz viagens de ida e volta na execução de ferramentas.

Se seu gargalo é latência de chamadas de ferramenta, priorize a chamada programática. Se o gargalo é deliberação em problemas difíceis, avalie o modo ultra. Veja a análise completa no artigo sobre modo ultra do GPT-5.6.

FAQ

Preciso reescrever minhas definições de ferramentas existentes?

Não. As ferramentas mantêm o formato JSON Schema usado na chamada de função clássica. O trabalho recomendado é reforçar o contrato:

• adicione enum quando aplicável;
• defina formatos;
• documente unidades;
• torne descrições específicas;
• proíba propriedades extras quando necessário.

O JavaScript gerado pode acessar a internet?

Não. O código roda em um ambiente V8 isolado e sem acesso à rede. Ferramentas declaradas são o único meio de afetar sistemas externos.

Por isso, audite sua superfície de ferramentas com o mesmo cuidado aplicado a uma API pública.

Quais modelos GPT-5.6 suportam chamada programática de ferramentas?

A OpenAI documenta essa capacidade na Responses API para a família GPT-5.6. Os três níveis — gpt-5.6-sol, gpt-5.6-terra e gpt-5.6-luna — são disponibilizados para contas de API em autoatendimento.

Confirme detalhes específicos por modelo na referência oficial antes de adotar um deles. Para configuração de chave e uma primeira solicitação, veja como usar a API GPT-5.6.

Qual é a diferença em relação ao interpretador de código?

O interpretador de código executa código como resultado final: análises, gráficos e transformações de arquivos.

Na chamada programática de ferramentas, o código existe para coordenar suas ferramentas declaradas. O resultado final são dados agregados das ferramentas, não o código em si.

Próximos passos

O loop de ida e volta era uma parte operacional de agentes que agora pode se tornar opcional. A orquestração muda para o modelo, mas a responsabilidade por APIs de ferramentas previsíveis, seguras e bem documentadas aumenta.

Comece com um fluxo de trabalho de leitura intensiva:

1. escolha uma tarefa que chama muitas ferramentas;
2. revise os esquemas das ferramentas;
3. valide respostas de sucesso e erro;
4. teste rajadas, limites de taxa e timeouts;
5. simule respostas antes de usar dados reais;
6. registre todas as chamadas geradas.

Passe seus endpoints pelo cliente de API e servidor de simulação do Apidog até que o contrato suporte entradas inválidas e chamadas em rajada. Quando o modelo começar a escrever código para suas ferramentas, ele deve encontrar uma superfície que você já testou.