Ferramentas de Agente: Chamadas, Busca e Código

Com o GPT-5.6, lançamos o Programmatic Tool Calling, tornando este um bom momento para recapitular as ferramentas de agente e as maneiras de manter os modelos focados à medida que o uso de ferramentas cresce.

Pergunte a um agente de suporte por que o pedido A-104 está atrasado e ele pode ler o pedido, ligar para a transportadora e explicar o atraso. Essa troca esconde um loop: o modelo solicita uma ação, um runtime a executa e o resultado retorna. Ferramentas integradas, MCP, skills, Tool Search e Programmatic Tool Calling mudam o que o modelo vê e o que retorna.

1. Tool Calling 101: o modelo pede; a aplicação age

Com uma função de propriedade do cliente, o modelo não executa seu código. Ele retorna um nome de ferramenta, argumentos JSON e um ID de chamada. Sua aplicação verifica a solicitação, executa a função e retorna function_call_output com o mesmo ID.

O loop de ferramenta de propriedade do cliente: nenhuma ação externa acontece até que sua aplicação execute o passo 3. Gerado com GPT-Image-2 no Codex.

Em Python, retornar function_call_output devolve o controle ao modelo:

1import json
2from openai import OpenAI
3
4client = OpenAI()
5
6def get_order(order_id): return {"order_id": order_id, "promised_date": "2026-07-13"}
7
8order_tool = {
9    "type": "function", "name": "get_order", "strict": True,
10    "description": "Return the promised delivery date for an order.",
11    "parameters": {
12        "type": "object",
13        "properties": {"order_id": {"type": "string"}},
14        "required": ["order_id"], "additionalProperties": False,
15    },
16    "output_schema": {
17        "type": "object",
18        "properties": {
19            "order_id": {"type": "string"}, "promised_date": {"type": "string"},
20        },
21        "required": ["order_id", "promised_date"], "additionalProperties": False,
22    },
23}
24
25first = client.responses.create(
26    model="gpt-5.6", tools=[order_tool], input="Why is order A-104 late?",
27    tool_choice={"type": "function", "name": "get_order"},
28)
29call = next(item for item in first.output if item.type == "function_call")
30result = get_order(**json.loads(call.arguments))
31
32final = client.responses.create(
33    model="gpt-5.6",
34    tools=[order_tool],
35    input=[*first.output, {
36        "type": "function_call_output",
37        "call_id": call.call_id,
38        "output": json.dumps(result),
39    }],
40)
41print(final.output_text)

O harness repete esse loop até que o modelo retorne uma mensagem final. Schemas estritos mantêm os argumentos bem formatados; o executor ainda verifica as permissões.

2. A execução de ferramentas pode rodar em lugares diferentes

Ferramentas integradas, incluindo web search, file search e hosted shell, podem rodar na infraestrutura da OpenAI. Um servidor MCP remoto expõe e executa ferramentas remotamente; Responses suporta esses servidores e conectores mantidos pela OpenAI, solicitando aprovação por padrão antes de compartilhar dados.

Uma skill agrupa instruções e arquivos. Anexe-a ao hosted shell e o modelo pode seguir seu procedimento ou executar seus scripts. Ele primeiro vê o nome, a descrição e o caminho da skill, depois lê SKILL.md quando selecionada.

1carrier_mcp = {
2    "type": "mcp",
3    "server_label": "carrier",
4    "server_url": "https://example.com/mcp",
5    "allowed_tools": ["track_package"],
6    "require_approval": "always",
7}
8incident_shell = {
9    "type": "shell",
10    "environment": {
11        "type": "container_auto",
12        "skills": [{"type": "skill_reference", "skill_id": "skill_..."}],
13    },
14}
15
16response = client.responses.create(
17    model="gpt-5.6",
18    tools=[carrier_mcp, incident_shell],
19    input="Investigate why order A-104 is late using the incident skill.",
20)

O harness unifica essas superfícies: MCP expõe ferramentas remotas, skills fornecem procedimentos e arquivos, e o harness controla onde as chamadas são executadas.

3. Tool Search: quando o contexto se torna a restrição

Cada definição de ferramenta visível consome contexto. Nomes, descrições e schemas usam tokens de entrada, ferramentas semelhantes se tornam mais difíceis de distinguir e um grande catálogo MCP se torna um prompt grande.

O Tool Search permite que modelos compatíveis GPT-5.4 ou posteriores carreguem definições adiadas apenas quando necessário:

1shipping = {
2    "type": "namespace", "name": "shipping",
3    "description": "Order tracking and delivery tools.",
4    "tools": [{
5        "type": "function", "name": "get_delivery_eta",
6        "description": "Return the ETA for an order.",
7        "defer_loading": True,
8        "parameters": {
9            "type": "object", "required": ["order_id"],
10            "properties": {"order_id": {"type": "string"}},
11            "additionalProperties": False,
12        },
13    }],
14}
15
16response = client.responses.create(
17    model="gpt-5.6",
18    input="When will order A-104 arrive?",
19    tools=[shipping, {"type": "tool_search"}],
20)

O Hosted Tool Search escolhe entre as ferramentas declaradas na solicitação; a pesquisa executada pelo cliente pode retornar ferramentas para o tenant ou projeto atual. A pesquisa adiciona uma etapa, então catálogos pequenos podem ganhar pouco. Uma função adiada ainda expõe seu nome e descrição, enquanto um namespace ou servidor MCP pode começar com uma descrição curta. As ferramentas carregadas são anexadas para preservar o prefixo do cache. Skills adiam instruções e arquivos; Tool Search adia schemas chamáveis.

4. Programmatic Tool Calling para trabalho previsível com múltiplas ferramentas

Chamadas diretas retornam cada resultado ao modelo. Isso é útil quando um resultado altera a próxima decisão, mas junções, filtros e consultas paralelas simples podem preencher o contexto com dados que o código poderia reduzir.

O Programmatic Tool Calling permite que o GPT-5.6 escreva JavaScript que é executado em um runtime V8 novo e isolado. O V8 executa JavaScript dentro do Chrome, mas isso não é um navegador ou Node.js. Ele suporta top-level await, loops, condições e chamadas paralelas, sem instalação de pacotes, acesso direto à rede, sistema de arquivos de uso geral, subprocessos, console ou estado persistente.

Três chamadas diretas comparadas com três chamadas paralelas no runtime V8 isolado. Gerado com GPT-Image-2 no Codex.

Quando um programa atinge uma função de propriedade do cliente, ele pausa enquanto sua aplicação executa a chamada; retornar seu call_id e caller a retoma. carrier_mcp também pode pausar para aprovação, e output_schema informa ao JavaScript quais campos ele pode inspecionar.

1for tool in (order_tool, carrier_mcp):
2    tool["allowed_callers"] = ["programmatic"]
3
4response = client.responses.create(
5    model="gpt-5.6",
6    tools=[
7        order_tool,
8        carrier_mcp,
9        {"type": "programmatic_tool_calling"},
10    ],
11    input="Compare order A-104 with carrier status and return delay evidence.",
12)

Os programas podem chamar ferramentas de função e personalizadas, MCP, apply_patch, shell e code interpreter, mas não web search ou file search. O Tool Search de nível superior deve carregar uma ferramenta adiada antes do programa iniciar; um programa em execução não pode pesquisar ferramentas.

Mantenha as chamadas diretas quando o próximo passo precisar de julgamento do modelo, aprovação, citações ou um efeito colateral. Use um programa quando regras claras permitirem que o código retorne um resultado menor sem perder evidências. A execução hospedada muda onde o trabalho é executado, o Tool Search muda quais definições entram no contexto e as chamadas programáticas mudam quais resultados retornam. Combine-os quando uma avaliação mostrar que a correção se mantém enquanto tokens, latência ou custo melhoram.

Bônus: mantenha loops longos de ferramentas em uma única conexão

Se um agente alterna repetidamente entre o modelo e as ferramentas de propriedade do cliente, o modo WebSocket do Responses pode reduzir a sobrecarga de continuação. O socket conecta seu harness ao Responses; ele não faz as ferramentas rodarem mais rápido. Ele aceita os mesmos campos response.create para funções, MCP, Tool Search e Programmatic Tool Calling, embora a documentação não avalie todas as combinações. A OpenAI observou até 40% mais rapidez na execução em implantações com 20 ou mais chamadas, então meça seu fluxo de trabalho.

Teste com seu agente

Pegue um Appshot deste artigo, abra seu projeto de agente no Codex e cole:

Use este artigo e a base de código atual para atualizar o caminho de ferramentas deste agente. Agrupe ferramentas grandes ou usadas com pouca frequência e ative o Tool Search para adiá-las. Encontre estágios limitados onde o Programmatic Tool Calling pode executar chamadas em paralelo e retornar resultados compactos. Mantenha decisões semânticas, aprovações, citações e efeitos colaterais como chamadas diretas. Compare ambos os caminhos quanto à correção, cobertura de evidências, sucesso da ferramenta, tokens, latência, repetições e custo antes de alterar o roteamento de produção.