Agent-Tools: Aufrufe, Suche und Code

Mit GPT-5.6 haben wir Programmatic Tool Calling veröffentlicht – ein guter Zeitpunkt, um einen Überblick über die Agent-Tools zu geben und darüber, wie Modelle bei wachsender Tool-Nutzung fokussiert bleiben.

Fragt ein Support-Agent, warum Bestellung A-104 verspätet ist, könnte er die Bestellung einsehen, beim Spediteur anrufen und die Verzögerung erklären. Hinter diesem Austausch verbirgt sich eine Schleife: Das Modell fordert eine Aktion an, eine Laufzeitumgebung führt sie aus, und das Ergebnis wird zurückgegeben. Integrierte Tools, MCP, Skills, Tool Search und Programmatic Tool Calling verändern, was das Modell sieht und was zurückkommt.

1. Tool Calling 101: Das Modell fragt; die Anwendung handelt

Bei einer client-eigenen Funktion führt das Modell nicht Ihren Code aus. Es gibt einen Tool-Namen, JSON-Argumente und eine Aufruf-ID zurück. Ihre Anwendung prüft die Anfrage, führt die Funktion aus und gibt function_call_output mit derselben ID zurück.

Die client-eigene Tool-Schleife: Es findet keine externe Aktion statt, bis Ihre Anwendung Schritt 3 ausführt. Generiert mit GPT-Image-2 in Codex.

In Python übergibt die Rückgabe von function_call_output die Kontrolle zurück an das Modell:

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": "Gibt das zugesagte Lieferdatum für eine Bestellung zurück.",
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="Warum ist Bestellung A-104 verspätet?",
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)

Die Steuerung wiederholt diese Schleife, bis das Modell eine endgültige Nachricht zurückgibt. Strikte Schemata halten die Argumente wohlgeformt; der Ausführer prüft dennoch die Berechtigungen.

2. Die Tool-Ausführung kann an verschiedenen Orten stattfinden

Integrierte Tools, darunter Websuche, Dateisuche und gehostete Shell, können in der Infrastruktur von OpenAI ausgeführt werden. Ein entfernter MCP-Server stellt Tools bereit und führt sie remote aus; Responses unterstützt diese Server und von OpenAI bereitgestellte Konnektoren und fordert standardmäßig eine Genehmigung an, bevor Daten weitergegeben werden.

Ein Skill bündelt Anweisungen und Dateien. Hängen Sie ihn an die gehostete Shell an, und das Modell kann seine Prozedur befolgen oder seine Skripte ausführen. Es sieht zuerst den Namen, die Beschreibung und den Pfad des Skills und liest dann SKILL.md, wenn dieser ausgewählt wird.

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="Untersuche mit dem Incident-Skill, warum Bestellung A-104 verspätet ist.",
20)

Die Steuerung vereinheitlicht diese Oberflächen: MCP stellt entfernte Tools bereit, Skills liefern Prozeduren und Dateien, und die Steuerung bestimmt, wo Aufrufe ausgeführt werden.

3. Tool Search: Wenn der Kontext zur Einschränkung wird

Jede sichtbare Tool-Definition verbraucht Kontext. Namen, Beschreibungen und Schemata verbrauchen Eingabe-Token, ähnliche Tools werden schwerer unterscheidbar, und ein großer MCP-Katalog wird zu einem großen Prompt.

Tool Search ermöglicht es kompatiblen GPT-5.4-oder-neuer Modellen, zurückgestellte Definitionen nur bei Bedarf zu laden:

1shipping = {
2    "type": "namespace", "name": "shipping",
3    "description": "Tools zur Sendungsverfolgung und Lieferung.",
4    "tools": [{
5        "type": "function", "name": "get_delivery_eta",
6        "description": "Gibt die voraussichtliche Ankunftszeit für eine Bestellung zurück.",
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="Wann wird Bestellung A-104 ankommen?",
19    tools=[shipping, {"type": "tool_search"}],
20)

Gehostete Tool Search wählt aus den in der Anfrage deklarierten Tools aus; client-seitig ausgeführte Suche kann Tools für den aktuellen Mandanten oder das aktuelle Projekt zurückgeben. Die Suche fügt einen Schritt hinzu, daher profitieren kleine Kataloge möglicherweise wenig. Eine zurückgestellte Funktion gibt weiterhin ihren Namen und ihre Beschreibung preis, während ein Namespace oder MCP-Server mit einer kurzen Beschreibung beginnen kann. Geladene Tools werden angehängt, um das Cache-Präfix zu erhalten. Skills stellen Anweisungen und Dateien zurück; Tool Search stellt aufrufbare Schemata zurück.

4. Programmatic Tool Calling für vorhersagbare Multi-Tool-Arbeit

Direkte Aufrufe geben jedes Ergebnis an das Modell zurück. Das ist nützlich, wenn ein Ergebnis die nächste Entscheidung ändert, aber einfache Verknüpfungen, Filter und parallele Abfragen können den Kontext mit Daten füllen, die Code reduzieren könnte.

Programmatic Tool Calling ermöglicht es GPT-5.6, JavaScript zu schreiben, das in einer frischen, isolierten V8-Laufzeitumgebung ausgeführt wird. V8 führt JavaScript innerhalb von Chrome aus, aber dies ist kein Browser oder Node.js. Es unterstützt Top-Level-Await, Schleifen, Bedingungen und parallele Aufrufe, ohne Paketinstallation, direkten Netzwerkzugriff, allgemeines Dateisystem, Unterprozesse, Konsole oder persistenten Zustand.

Drei direkte Aufrufe im Vergleich zu drei parallelen Aufrufen in der isolierten V8-Laufzeitumgebung. Generiert mit GPT-Image-2 in Codex.

Wenn ein Programm eine client-eigene Funktion erreicht, pausiert es, während Ihre Anwendung den Aufruf ausführt; die Rückgabe seiner call_id und des Aufrufers setzt es fort. carrier_mcp kann ebenfalls zur Genehmigung pausieren, und output_schema teilt JavaScript mit, welche Felder es inspizieren kann.

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="Vergleiche Bestellung A-104 mit dem Spediteurstatus und gib Beweise für die Verzögerung zurück.",
12)

Programme können Funktionen und benutzerdefinierte Tools, MCP, apply_patch, Shell und Code-Interpreter aufrufen, jedoch nicht Websuche oder Dateisuche. Top-Level Tool Search muss ein zurückgestelltes Tool laden, bevor das Programm startet; ein laufendes Programm kann nicht nach Tools suchen.

Halten Sie Aufrufe direkt, wenn der nächste Schritt das Urteil des Modells, Genehmigung, Zitate oder einen Nebeneffekt benötigt. Verwenden Sie ein Programm, wenn klare Regeln es dem Code ermöglichen, ein kleineres Ergebnis zurückzugeben, ohne Beweise zu verlieren. Gehostete Ausführung ändert, wo die Arbeit läuft, Tool Search ändert, welche Definitionen in den Kontext gelangen, und programmatische Aufrufe ändern, welche Ergebnisse zurückkommen. Kombinieren Sie sie, wenn eine Evaluierung zeigt, dass die Korrektheit erhalten bleibt, während Token, Latenz oder Kosten verbessert werden.

Bonus: Lange Tool-Schleifen auf einer Verbindung halten

Wenn ein Agent wiederholt zwischen dem Modell und client-eigenen Tools wechselt, kann der Responses WebSocket-Modus den Fortsetzungs-Overhead reduzieren. Der Socket verbindet Ihre Steuerung mit Responses; er lässt Tools nicht schneller laufen. Er akzeptiert dieselben response.create-Felder für Funktionen, MCP, Tool Search und Programmatic Tool Calling, obwohl die Dokumentation nicht jede Kombination benchmarkt. OpenAI hat bei Rollouts mit 20 oder mehr Aufrufen eine bis zu 40 % schnellere Ausführung beobachtet, also messen Sie Ihren Workflow.

Probieren Sie es mit Ihrem Agenten aus

Machen Sie einen Appshot dieses Artikels, öffnen Sie Ihr Agent-Projekt in Codex und fügen Sie Folgendes ein:

Nutzen Sie diesen Artikel und die aktuelle Codebasis, um den Tool-Pfad dieses Agenten zu verbessern. Gruppieren Sie große oder selten genutzte Tools und aktivieren Sie Tool Search, um sie zurückzustellen. Finden Sie begrenzte Phasen, in denen Programmatic Tool Calling Aufrufe parallel ausführen und kompakte Ergebnisse zurückgeben kann. Behalten Sie semantische Entscheidungen, Genehmigungen, Zitate und Nebeneffekte als direkte Aufrufe bei. Vergleichen Sie beide Pfade hinsichtlich Korrektheit, Beweisabdeckung, Tool-Erfolg, Token, Latenz, Wiederholungen und Kosten, bevor Sie die Produktions-Routing ändern.