Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Programmatic Tool Calling: door het model georkestreerde tools

Les 5 van 12 Bijgewerkt op 5 november 2026 Gemiddeld
Op deze pagina
  1. Wat er verandert
  2. Inschakelen in de Responses API
  3. Wat uw applicatie ontvangt
  4. Taken identificeren die baat hebben
  5. Probeer het zelf
  6. Belangrijkste punten

Status per 5 november 2026. De GPT-6-familie erft de API-mogelijkheden van GPT-5.6, waaronder Programmatic Tool Calling. De Agents API schakelt dit standaard in (Les 10). OpenAI raadt aan de modelkaart te controleren voordat u deze functie inschakelt.

Om te begrijpen wat Programmatic Tool Calling toevoegt, moet u eerst kijken naar de kosten van klassieke function calling. Het model vraagt een tool-uitvoering aan, uw code voert deze uit en het resultaat gaat terug naar het model, dat het leest en de volgende stap bepaalt. Eén round-trip is geen probleem. Tien round-trips voor één taak is een ander verhaal: elke stap voegt latentie toe en elk tussenresultaat – zelfs als het omvangrijk of irrelevant is voor het eindantwoord – passeert terug door de context van het model en wordt gefactureerd in tokens. Bij tool-zware taken domineren deze round-trips zowel de latentie als de kosten.

Wat er verandert

Programmatic Tool Calling werd geïntroduceerd met GPT-5.6 op 9 juli 2026 in de Responses API. In plaats van tools één voor één aan te vragen, schrijft het model een klein JavaScript-programma om ze te coördineren. Het kan oproepen parallel starten, lussen en voorwaarden gebruiken, en tussenresultaten binnen de uitvoeringsomgeving houden. Alleen het gereduceerde resultaat – datgene dat relevant is voor de volgende stap – keert terug naar de context.

Neem bijvoorbeeld een gepagineerde API. Bij klassieke function calling traverseert elke pagina met resultaten de context, zodat het model kan beslissen of het de volgende moet aanvragen. Met Programmatic Tool Calling schrijft het model een lus die door de pagina’s iterert, optelt wat opgeteld moet worden, en rapporteert alleen de totalen: minder tokens, minder latentie en minder orchestratiecode voor u om te onderhouden.

OpenAI voert elk programma uit in een verse, geïsoleerde V8-omgeving. Er is geen Node.js, geen pakketinstallatie, geen directe netwerktopgang, geen algemeen bestandssysteem en geen staat die bewaard blijft tussen programma’s. Het programma interacteert alleen met de wereld via de tools die u eraan blootstelt. Voor de Responses API is dit gedrag compatibel met Zero Data Retention (ZDR), mits ZDR is ingeschakeld voor de organisatie of het project.

Inschakelen in de Responses API

Twee instellingen volstaan. U voegt de gehoste tool programmatic_tool_calling toe aan het verzoek en specificeert vervolgens wie elke in aanmerking komende tool mag aanroepen met allowed_callers: ["direct"] (het standaardgedrag, waarbij het model de tool zelf aanroept), ["programmatic"] (alleen een programma mag deze aanroepen), of beide. De documentatie raadt ook aan de uitvoer van elke functie te beschrijven met output_schema, zodat de gegenereerde code op de velden ervan kan vertrouwen.

from openai import OpenAI

client = OpenAI()

tools = [
    {
        "type": "function",
        "name": "read_stock",
        "description": "Returns an object with sku (text) and units (number).",
        "parameters": {
            "type": "object",
            "properties": {"sku": {"type": "string"}},
            "required": ["sku"],
            "additionalProperties": False,
        },
        "output_schema": {
            "type": "object",
            "properties": {"sku": {"type": "string"}, "units": {"type": "number"}},
            "required": ["sku", "units"],
            "additionalProperties": False,
        },
        "allowed_callers": ["programmatic"],
    },
    {"type": "programmatic_tool_calling"},
]

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Check stock for SKUs A12, B07, and C33 and flag those under 10 units.",
    tools=tools,
)

Tool-types die vanuit een programma kunnen worden aangeroepen, omvatten functies en aangepaste tools, MCP-tools, apply_patch, lokale of gehoste shell, en de code-interpreter. Voor een MCP-tool waar goedkeuring voor vereist is, pauzeert het programma totdat u toestemming verleent.

Wat uw applicatie ontvangt

Het antwoord blijft een standaard Responses-object met drie soorten elementen om te herkennen. Een program-element bevat het gegenereerde JavaScript. function_call-elementen corresponderen met uw functies die door dat programma zijn aangeroepen; hun caller-veld identificeert het aanroepende programma. Tot slot levert een program_output-element het eindresultaat van het programma op, met een status van completed of incomplete.

Uw applicatie voert het JavaScript nooit uit; OpenAI doet dat. U voert alleen uw eigen functies uit en retourneert elk resultaat in een function_call_output door het caller-veld ongewijzigd te kopiëren, zodat het juiste programma kan hervatten. U herhaalt dit totdat het antwoord geen uit te voeren oproepen meer bevat.

Wie voert wat uit Drie stappen: het model schrijft een JavaScript-programma dat OpenAI uitvoert in een geïsoleerde omgeving; uw applicatie voert de functies uit dat programma uit en retourneert de resultaten met het caller-veld intact; het programma levert een gereduceerd resultaat in program_output. PROGRAMMATIC TOOL CALLING Wie voert wat uit 1 Programma Geschreven door het model 2 Uw functies Uitgevoerd door u 3 Resultaat Gereduceerd program_output JavaScript draait bij OpenAI, nooit aan uw kant. Gevoelige schrijfbewerkingen blijven directe oproepen.
Gebaseerd op de Programmatic Tool Calling-gids in de OpenAI API-documentatie (november 2026).

Taken identificeren die baat hebben

Niet elke tool-integratie profiteert van migratie. De gids van OpenAI biedt een duidelijke regel: Programmatic Tool Calling is geschikt voor stappen waar de stroom voorspelbaar is en de code een kleiner, gestructureerd resultaat kan retourneren. Het is ontworpen om meerdere resultaten te filteren, samenvoegen, sorteren, dedupliceren, aggregeren of valideren, of om afhankelijke oproepen te ketenen waar de datastroom voorspelbaar is. Direct aanroepen blijft te verkiezen voor een enkele zoekopdracht of actie, voor adaptieve zoekopdrachten waarbij elk resultaat de volgende beslissing moet sturen, en voor finale citatievalidatie. Het blijft ook de standaardkeuze voor schrijfbewerkingen en acties die goedkeuring vereisen om een duidelijke autorisatiegrens te handhaven.

Het beslissingscriterium komt neer op één vraag: waar besteedt uw agent zijn tijd? Als het antwoord “wachten op tool round-trips” is, dan is Programmatic Tool Calling het eerste gebied om te evalueren. Als uw tool-aanroepen zeldzaam zijn en hun resultaten kort, houd dan uw huidige architectuur aan en richt uw inspanningen ergens anders op.

Probeer het zelf

Identificeer een kandidaat. Neem een stroom in uw agent die meerdere tools aanroept. Noteer voor elke stap het aantal oproepen, de grootte van de tussenresultaten en of het een lees- of schrijfbewerking is. Classificeer elke stap met behulp van de bovenstaande regel. Schrijf voor de meest veelbelovende stap een prompt die de toegestane tools specificeert, het verwachte resultaatformaat, de stopvoorwaarde, het maximum aantal retry-pogingen en wat een directe oproep blijft.

Officiële bronnen: Programmatic Tool Calling · GPT-6 gebruiken (OpenAI API-documentatie) · GPT-5.6 Aankondiging (OpenAI, 9 juli 2026)

Belangrijkste punten

  • Het model schrijft en voert JavaScript uit om zijn tools te coördineren in een geïsoleerde omgeving die door OpenAI wordt beheerd
  • Schakel het in met de tool programmatic_tool_calling en het veld allowed_callers op elke tool
  • Uw applicatie voert alleen zijn functies uit en retourneert het veld caller intact
  • Geef de voorkeur aan filtering, aggregatie of het ketenen van voorspelbare oproepen; direct aanroepen blijft de regel voor schrijfbewerkingen en goedkeuringen