Ferramentas de Agente: Chamadas, Pesquisa e Código

Com o GPT-5.6, lançamos a Chamada Programática de Ferramentas, tornando este um bom momento para recapitular as ferramentas de agente e 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, Pesquisa de Ferramentas e Chamada Programática de Ferramentas mudam o que o modelo vê e o que retorna.

1. Noções Básicas de Chamada de Ferramentas: 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": "Retorna a data de entrega prometida para um pedido.",
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="Por que o pedido A-104 está atrasado?",
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 este loop até que o modelo retorne uma mensagem final. Esquemas estritos mantêm os argumentos bem formatados; o executor ainda verifica as permissões.

2. A execução da ferramenta pode ocorrer em diferentes lugares

Ferramentas integradas, incluindo pesquisa na web, pesquisa de arquivos e shell hospedado, podem ser executadas na infraestrutura da OpenAI. Um servidor MCP remoto expõe e executa ferramentas remotamente; o 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 shell hospedado e o modelo pode seguir seu procedimento ou executar seus scripts. Ele primeiro vê o nome, descrição e 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="Investigue por que o pedido A-104 está atrasado usando a skill de incidente.",
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. Pesquisa de Ferramentas: quando o contexto se torna a restrição

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

A Pesquisa de Ferramentas 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": "Ferramentas de rastreamento de pedidos e entrega.",
4    "tools": [{
5        "type": "function", "name": "get_delivery_eta",
6        "description": "Retorna a ETA para um pedido.",
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="Quando o pedido A-104 chegará?",
19    tools=[shipping, {"type": "tool_search"}],
20)

A Pesquisa de Ferramentas Hospedada 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; a Pesquisa de Ferramentas adia esquemas chamáveis.

4. Chamada Programática de Ferramentas 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 simples, filtros e consultas paralelas podem preencher o contexto com dados que o código poderia reduzir.

A Chamada Programática de Ferramentas 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 await de nível superior, 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 o 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 o pedido A-104 com o status da transportadora e retorne evidências de atraso.",
12)

Os programas podem chamar ferramentas de função e personalizadas, MCP, apply_patch, shell e interpretador de código, mas não pesquisa na web ou pesquisa de arquivos. A Pesquisa de Ferramentas 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, a Pesquisa de Ferramentas 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 soquete 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, Pesquisa de Ferramentas e Chamada Programática de Ferramentas, embora a documentação não avalie todas as combinações. A OpenAI observou até 40% de execução mais rápida em implantações com 20 ou mais chamadas, então meça seu fluxo de trabalho.

Experimente 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 a Pesquisa de Ferramentas para adiá-las. Encontre estágios limitados onde a Chamada Programática de Ferramentas 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.