Strumenti per agenti: chiamate, ricerca e codice

Con GPT-5.6, abbiamo rilasciato il Programmatic Tool Calling, rendendo questo un buon momento per fare il punto sugli strumenti per agent e sui modi per mantenere i modelli concentrati man mano che l'uso degli strumenti cresce.

Chiedi a un agente del supporto perché l'ordine A-104 è in ritardo e potrebbe leggere l'ordine, chiamare il corriere e spiegare il ritardo. Questo scambio nasconde un ciclo: il modello richiede un'azione, un runtime la esegue e il risultato viene restituito. Strumenti integrati, MCP, skill, Tool Search e Programmatic Tool Calling cambiano ciò che il modello vede e ciò che viene restituito.

1. Tool Calling 101: il modello chiede; l'applicazione agisce

Con una funzione di proprietà del client, il modello non esegue il tuo codice. Restituisce un nome dello strumento, argomenti JSON e un ID di chiamata. La tua applicazione verifica la richiesta, esegue la funzione e restituisce function_call_output con lo stesso ID.

Il ciclo dello strumento di proprietà del client: nessuna azione esterna viene eseguita finché la tua applicazione non esegue il passaggio 3. Generato con GPT-Image-2 in Codex.

In Python, restituire function_call_output restituisce il controllo al modello:

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": "Restituisce la data di consegna promessa per un ordine.",
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="Perché l'ordine A-104 è in ritardo?",
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)

L'infrastruttura ripete questo ciclo finché il modello non restituisce un messaggio finale. Schemi rigorosi mantengono gli argomenti ben formati; l'esecutore verifica comunque i permessi.

2. L'esecuzione degli strumenti può avvenire in luoghi diversi

Strumenti integrati, tra cui web search, file search e shell ospitata, possono essere eseguiti nell'infrastruttura di OpenAI. Un server MCP remoto espone ed esegue strumenti in remoto; Responses supporta questi server e i connettori gestiti da OpenAI, richiedendo approvazione per impostazione predefinita prima di condividere dati.

Una skill raggruppa istruzioni e file. Allega la skill alla shell ospitata e il modello può seguirne la procedura o eseguirne gli script. Prima vede il nome, la descrizione e il percorso della skill, poi legge SKILL.md quando viene selezionata.

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="Investiga perché l'ordine A-104 è in ritardo usando la skill per incidenti.",
20)

L'infrastruttura unifica queste superfici: MCP espone strumenti remoti, le skill forniscono procedure e file, e l'infrastruttura controlla dove vengono eseguite le chiamate.

3. Tool Search: quando il contesto diventa il vincolo

Ogni definizione di strumento visibile occupa contesto. Nomi, descrizioni e schemi utilizzano token di input, strumenti simili diventano più difficili da distinguere e un ampio catalogo MCP diventa un prompt enorme.

Tool Search consente ai modelli compatibili GPT-5.4 o successivi di caricare definizioni differite solo quando necessario:

1shipping = {
2    "type": "namespace", "name": "shipping",
3    "description": "Strumenti per il tracciamento degli ordini e la consegna.",
4    "tools": [{
5        "type": "function", "name": "get_delivery_eta",
6        "description": "Restituisce l'ETA per un ordine.",
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 arriverà l'ordine A-104?",
19    tools=[shipping, {"type": "tool_search"}],
20)

Hosted Tool Search sceglie tra gli strumenti dichiarati nella richiesta; la ricerca eseguita dal client può restituire strumenti per il tenant o progetto corrente. La ricerca aggiunge un passaggio, quindi i cataloghi piccoli potrebbero trarne poco beneficio. Una funzione differita espone comunque il suo nome e la sua descrizione, mentre un namespace o un server MCP può iniziare con una breve descrizione. Gli strumenti caricati vengono aggiunti in coda per preservare il prefisso della cache. Le skill differiscono istruzioni e file; Tool Search differisce schemi chiamabili.

4. Programmatic Tool Calling per lavori multi-strumento prevedibili

Le chiamate dirette restituiscono ogni risultato al modello. Questo è utile quando un risultato modifica la decisione successiva, ma semplici join, filtri e ricerche parallele possono riempire il contesto con dati che il codice potrebbe ridurre.

Programmatic Tool Calling consente a GPT-5.6 di scrivere JavaScript che viene eseguito in un runtime V8 fresco e isolato. V8 esegue JavaScript all'interno di Chrome, ma questo non è un browser o Node.js. Supporta await di primo livello, cicli, condizioni e chiamate parallele, senza installazione di pacchetti, accesso diretto alla rete, filesystem generico, sottoprocessi, console o stato persistente.

Tre chiamate dirette confrontate con tre chiamate parallele nel runtime V8 isolato. Generato con GPT-Image-2 in Codex.

Quando un programma raggiunge una funzione di proprietà del client, si mette in pausa mentre la tua applicazione esegue la chiamata; restituire il suo call_id e chiamante la riprende. carrier_mcp può anche mettersi in pausa per l'approvazione, e output_schema dice a JavaScript quali campi può ispezionare.

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="Confronta l'ordine A-104 con lo stato del corriere e restituisci le prove del ritardo.",
12)

I programmi possono chiamare strumenti funzione e personalizzati, MCP, apply_patch, shell e code interpreter, ma non web search o file search. Tool Search di primo livello deve caricare uno strumento differito prima che il programma inizi; un programma in esecuzione non può cercare strumenti.

Mantieni le chiamate dirette quando il passaggio successivo necessita del giudizio del modello, approvazione, citazioni o un effetto collaterale. Usa un programma quando regole chiare consentono al codice di restituire un risultato più piccolo senza perdere prove. L'esecuzione ospitata cambia dove viene eseguito il lavoro, Tool Search cambia quali definizioni entrano nel contesto e le chiamate programmatiche cambiano quali risultati vengono restituiti. Combinali quando una valutazione mostra che la correttezza viene mantenuta mentre token, latenza o costo migliorano.

Bonus: mantieni lunghi cicli di strumenti su una singola connessione

Se un agente passa ripetutamente dal modello agli strumenti di proprietà del client, la modalità WebSocket di Responses può ridurre il sovraccarico di continuazione. Il socket collega la tua infrastruttura a Responses; non fa funzionare gli strumenti più velocemente. Accetta gli stessi campi response.create per funzioni, MCP, Tool Search e Programmatic Tool Calling, anche se la documentazione non confronta ogni combinazione. OpenAI ha osservato fino al 40% di esecuzione più rapida in rollout con 20 o più chiamate, quindi misura il tuo flusso di lavoro.

Provalo con il tuo agente

Prendi un Appshot di questo articolo, apri il tuo progetto agente in Codex e incolla:

Usa questo articolo e il codebase corrente per aggiornare il percorso degli strumenti di questo agente. Raggruppa strumenti grandi o usati di rado e abilita Tool Search per differirli. Trova fasi delimitate in cui Programmatic Tool Calling può eseguire chiamate in parallelo e restituire risultati compatti. Mantieni decisioni semantiche, approvazioni, citazioni ed effetti collaterali come chiamate dirette. Confronta entrambi i percorsi per correttezza, copertura delle prove, successo degli strumenti, token, latenza, tentativi e costo prima di modificare il routing di produzione.