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 tem um formato que todo construtor de agente conhece de cor. O modelo solicita uma chamada de ferramenta, sua aplicação a executa, você anexa o resultado e o modelo solicita a próxima. Quatro ferramentas, quatro viagens de ida e volta. Quarenta ferramentas, quarenta. Cada passagem adiciona latência de rede e contexto re-faturado. Quando a OpenAI lançou o GPT-5.6 para disponibilidade geral em 9 de julho de 2026, ela disponibilizou uma maneira de sair dessa rotina: a chamada programática de ferramentas na Responses API.

A ideia é direta. Em vez de retornar chamadas de ferramentas uma de cada vez para o seu código executar em um loop, o modelo escreve JavaScript que orquestra várias chamadas de ferramentas por si mesmo. Esse código é executado em um ambiente de execução V8 isolado, sem acesso à rede. Suas ferramentas continuam sendo a única maneira pela qual o código pode tocar o mundo exterior, então o limite de segurança que você já considera com a chamada de função da OpenAI permanece exatamente onde estava. O que muda é a orquestração: os loops, condicionais e agregação que costumavam residir na sua aplicação.

A mudança também recai sobre o seu lado da API. Cada ferramenta que você expõe agora é um contrato que o modelo pode chamar em rajadas de dezenas, em vez de uma chamada cuidadosa por vez. A precisão do esquema, os formatos de erro e o comportamento da taxa importam mais do que na semana passada. Este artigo aborda o que foi lançado, por que o loop antigo causa problemas, o que permanece o mesmo e como preparar seus endpoints de ferramentas com o Apidog antes de entregá-los ao modelo.

TL;DR

• O GPT-5.6 foi lançado em GA em 9 de julho de 2026. Em GA, a Responses API ganhou chamada programática de ferramentas, confirmada na documentação para desenvolvedores da OpenAI.
• Em vez de uma chamada de ferramenta por viagem de ida e volta, o modelo escreve JavaScript que compõe loops, condicionais e agregação sobre suas ferramentas.
• O código gerado é executado em uma sandbox V8 isolada, sem acesso à rede. Suas definições de ferramentas permanecem o único caminho para sistemas externos, então o limite de segurança não se move.
• A latência e o custo do token param de se acumular com o número de chamadas de ferramentas, que é onde os loops de agente clássicos sangram.
• O recurso tem dias; os parâmetros exatos de solicitação e os limites estão na referência da API da OpenAI, então leia-a antes de construir.
• Teste e simule cada endpoint de ferramenta antes que o modelo o orquestre; uma ambiguidade de esquema se torna um bug repetido em um loop.

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 e gpt-5.6-luna para volume rápido e econômico. O alias simples gpt-5.6 direciona para Sol. Todos os três são de autoatendimento via API sem restrição de plano, após uma prévia limitada de duas semanas que terminou quando a restrição de acesso foi suspensa em 8 de julho.

A família de modelos recebeu a maior parte da atenção no dia do lançamento, mas a nova superfície da API é a história maior para os construtores de agentes. De acordo com a cobertura de lançamento do MarkTechPost e a própria documentação da OpenAI, a Responses API ganhou quatro coisas em GA: chamada programática de ferramentas, uma versão beta multiagente, raciocínio persistido entre turnos e configurações de detalhes de visão que preservam as dimensões originais da imagem.

A chamada programática de ferramentas é o destaque. A OpenAI a descreve como o modelo escrevendo JavaScript para orquestrar chamadas de ferramentas, executado em um ambiente de execução V8 isolado, sem acesso à rede. O modelo deixa de ser um solicitante turno a turno e se torna o autor da camada de orquestração.

O loop que a chamada programática de ferramentas substitui

Aqui está a chamada de função clássica contra a Responses API, o formato que quase todo agente de produção usa hoje:

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
});

O modelo não pode responder sem dados, então ele emite uma chamada de função. Seu código executa a pesquisa, anexa um item function_call_output e chama a API novamente:

// Uma viagem de ida e volta por chamada de ferramenta. Este loop é o custo.
while (hasFunctionCalls(response)) {
  const outputs = await executeToolCalls(response); // seu código, sua infra
  response = await client.responses.create({
    model: "gpt-5.6",
    previous_response_id: response.id,
    input: outputs,
    tools
  });
}

Para 12 voos, esse loop pode ser executado 12 vezes, e cada iteração paga duas vezes. Primeiro em latência: uma viagem completa de ida e volta à rede para a OpenAI mais o tempo do modelo, serializado, porque a chamada N+1 depende do modelo ver o resultado N. Segundo em tokens: os resultados da ferramenta se acumulam no contexto, então as iterações posteriores reprocessam tudo o que as anteriores produziram. Encadeie agentes e o acúmulo fica feio: um agente de cinco etapas onde cada etapa envolve um loop de dez chamadas são cinquenta invocações de modelo faturadas.

Nada desse loop é inteligência. É encanamento, e até esta semana o modelo não tinha como escrever o encanamento por si só.

Como o modo programático muda o formato

Com a chamada programática de ferramentas, o modelo responde à pergunta do voo de forma diferente: ele escreve um pequeno programa JavaScript que percorre os doze números de voo, chama get_flight_status para cada um, filtra por status de atraso, classifica por duração do atraso e retorna o agregado. A sandbox executa esse programa. Suas ferramentas ainda fazem o trabalho real; o fluxo de controle em torno delas agora pertence ao modelo.

Três propriedades tornam isso viável em vez de alarmante:

• O tempo de execução é isolado. A OpenAI executa o JavaScript gerado em uma sandbox V8 sem acesso à rede. O código não pode buscar uma URL, abrir um socket ou exfiltrar nada por conta própria.
• As ferramentas são a única saída. Todo efeito externo é roteado através da superfície da ferramenta que você definiu. Se você não expôs uma ferramenta delete_record, nenhum código gerado pode excluir um registro.
• O fluxo de controle torna-se expressivo. Loops, condicionais, saídas antecipadas, agregação de resultados: padrões que antes levavam N viagens de ida e volta agora acontecem dentro de um único ciclo de resposta.

O que permanece o mesmo

Você ainda define ferramentas com nomes, descrições e parâmetros JSON Schema, exatamente como no código acima. O modelo só pode compor chamadas para as ferramentas que você declarou, o que significa que a pergunta "o que este agente pode fazer aos meus sistemas" tem a mesma resposta de antes: o que a sua superfície de ferramentas permite, e nada mais.

A qualidade do esquema importa mais agora, não menos. No loop clássico, uma descrição vaga de parâmetro produzia uma chamada ruim que você podia capturar e corrigir antes da próxima viagem de ida e volta. No modo programático, a mesma vagueza pode ser incorporada a um loop e repetida em cada iteração antes que você veja um único resultado. Os hábitos que você construiu para saídas estruturadas se transferem diretamente: tipos estritos, enums para conjuntos fechados, descrições que indicam unidades e formatos, campos obrigatórios que são honestamente obrigatórios.

Limites e perguntas em aberto

Esta capacidade tem dias de existência. Algumas precauções antes de você reconstruir sua pilha de agentes em torno dela:

• Os parâmetros de solicitação exatos, os limites de execução e o comportamento de tempo limite pertencem à referência da API e ao guia do modelo da OpenAI. Os nomes dos parâmetros podem mudar durante o polimento que se segue a qualquer lançamento de GA, então leia a referência antes de escrever código para o recurso.
• A depuração é uma nova superfície. Quando a orquestração vivia em seu repositório, você podia definir um breakpoint; agora parte do fluxo de controle é gerada nova a cada solicitação. Registrar a sequência de chamadas de ferramentas que o sandbox faz torna-se uma tarefa central de observabilidade.
• Não há histórico de produção ainda. As notas de Simon Willison sobre o GPT-5.6 no primeiro dia são um bom registro contínuo do que o teste independente revela; espere que arestas afiadas apareçam lá antes que a documentação oficial as mencione.
• Uma ordem de lançamento sensata: comece com ferramentas somente leitura, observe a orquestração gerada, verifique a contabilidade de tokens em relação ao seu loop antigo e só então exponha ferramentas com efeitos colaterais.

Suas ferramentas agora são uma API que o código de outra pessoa chama

Sob a chamada de função clássica, uma ferramenta era chamada uma vez por viagem de ida e volta, com um loop criado por humanos decidindo o ritmo e a ordem. Sob a chamada programática de ferramentas, o código gerado chama suas ferramentas em rajadas, ramifica-se em suas respostas e agrega sua saída. Cada ferramenta é um contrato de API consumido por um cliente escrito por máquina que você nunca revisa antes de ser executado.

Isso eleva o nível em quatro coisas:

• Precisão do esquema. Indique unidades, formatos e intervalos em cada descrição de parâmetro. Um formato de data ambíguo não é mais uma chamada ruim; é um loop delas.
• Formas de erro. O código gerado se ramificará em caso de falhas. Uma ferramenta que retorna 200 com uma mensagem de erro em uma string enganará qualquer orquestração escrita contra seu esquema. Retorne códigos de status honestos e corpos de erro estruturados.
• Idempotência e comportamento de taxa. Doze chamadas que costumavam chegar ao longo de um minuto podem agora chegar em uma única rajada. Saiba o que seu endpoint faz sob esse padrão antes que o modelo descubra por você.
• Latência. Uma ferramenta que leva oito segundos era tolerável uma vez por turno. Dentro de um loop de doze iterações, ela define seu tempo de resposta.

É aqui que uma bancada de trabalho de API real ganha seu lugar. Defina ou importe a especificação de cada endpoint de ferramenta, envie solicitações de teste para ele e confirme se o esquema de resposta corresponde ao que sua definição de ferramenta promete. Em seguida, vá um passo além: simule a API da ferramenta para que você possa exercitar a orquestração com dados falsos previsíveis sem tocar na produção. Baixe o Apidog e seu servidor de simulação integrado servirá respostas formatadas por esquema para cada endpoint que você definiu, para que você possa entregar ao modelo uma superfície de ferramentas completa e observar como ele orquestra antes de tocar em um único registro real.

As outras funcionalidades GA em resumo

A chamada programática de ferramentas não foi lançada sozinha. Duas adições adjacentes à API de Respostas são importantes aqui:

• Multiagente, em beta: execução paralela de subagentes gerenciada pela API. Estágio inicial, vale a pena observar em vez de apostar.
• Raciocínio persistido: contexto de raciocínio reutilizado entre turnos via reasoning.context, para que sessões de agente longas parem de redescobrir as mesmas conclusões a cada turno.

Ambos se combinam com a chamada programática de ferramentas: um agente que mantém seu raciocínio entre turnos e escreve sua própria orquestração faz muito menos trabalho redundante por tarefa.

Chamada programática de ferramentas vs. modo ultra

O lançamento também trouxe o modo ultra, e os dois se confundem porque ambos fazem mais por solicitação. Eles resolvem gargalos diferentes.

Ultra é uma configuração multiagente que executa quatro agentes em paralelo por padrão, gastando mais tokens deliberadamente para reduzir o tempo real; de acordo com a OpenAI, ele eleva o Terminal-Bench 2.1 de 88,8% para 91,9%. Ele está disponível no ChatGPT Work nos planos Pro e Enterprise, e no Codex a partir do Plus. A chamada programática de ferramentas é uma capacidade da API onde um agente orquestra suas ferramentas em código. Ultra paraleliza o raciocínio; a chamada programática de ferramentas colapsa as viagens de ida e volta de execução. A análise completa está em nosso artigo sobre o modo ultra do GPT-5.6, mas a versão curta: se seu gargalo é a latência da chamada de ferramenta, você quer a chamada programática de ferramentas; se é o tempo de deliberação em problemas difíceis, você quer o modo ultra.

FAQ

Preciso reescrever minhas definições de ferramentas existentes?

Não. As ferramentas mantêm o mesmo formato JSON Schema mostrado no código acima, e as definições escritas para a chamada de função clássica são transferidas. O trabalho que vale a pena é aprimorá-las: adicione enums, especifique formatos e torne as descrições específicas o suficiente para que o código gerado não as interprete mal.

O JavaScript gerado pode acessar a internet?

Não. O código é executado em um ambiente de execução V8 isolado, sem acesso à rede, e suas ferramentas declaradas são a única maneira de afetar algo fora da sandbox. Isso torna sua superfície de ferramentas o modelo de risco inteiro, então audite quais ferramentas você expõe com o mesmo cuidado que daria a uma API pública.

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

A OpenAI documenta isso como a superfície da Responses API para a família GPT-5.6, e todos os três níveis (gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna) são de autoatendimento para qualquer conta de API. Verifique a referência da API para detalhes específicos de cada nível antes de se comprometer com um. Para configuração chave e um primeiro walkthrough de 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 o produto final: análises, gráficos, transformações de arquivos. A chamada programática de ferramentas gera código cuja única função é coordenar suas ferramentas declaradas; o produto final são os resultados agregados das ferramentas, não o código em si.

Onde isso te deixa

O loop de ida e volta era a parte menos interessante de cada agente que você enviou, e o GPT-5.6 o tornou opcional. A orquestração mudou para o modelo; a responsabilidade por APIs de ferramentas limpas, precisas e bem-comportadas mudou para você, com mais peso do que antes.

O próximo passo é concreto. Escolha um fluxo de trabalho com muita leitura, escreva ou aprimore os esquemas de ferramentas de que ele precisa e passe cada endpoint pelo cliente de API e servidor de simulação do Apidog até que o contrato resista a chamadas em rajada e entradas inválidas. Quando o modelo começar a escrever código para suas ferramentas, você vai querer que esse código leia de uma superfície que você já testou.