Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Architectuur van agenten: de redeneer-tool-lus

Les 2 van 25 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Architectuur van agenten: de redeneer-tool-lus
  2. De levenscyclus van een agent
  3. Interne structuur: items en berichten
  4. Parallelle versus sequentiële aanroepen
  5. De parameter max_turns
  6. Belangrijkste punten

Bijgewerkt op 3 november 2026: In rechercher_produit ontbraken de aanhalingstekens rond de sleutels prix en stock, wat bij de eerste tool-aanroep een NameError veroorzaakte.

Architectuur van agenten: de redeneer-tool-lus

Om effectieve agenten te bouwen, moet u hun interne architectuur begrijpen. Een OpenAI-agent werkt volgens een redeneerlus: de agent ontvangt een taak, denkt na, gebruikt een tool, observeert het resultaat en besluit vervolgens of de taak voltooid is of dat verdergaande actie nodig is. Alles wat u daarna doet—tools declareren, beveiligingsregels instellen, meerdere agenten orchestreren—bouwt voort op deze lus.

De levenscyclus van een agent

Elke uitvoering doorloopt zes stappen:

  1. Ontvangst: De agent ontvangt het gebruikersbericht en de systeeminstructies
  2. Redeneren: Het model analyseert het verzoek en bepaalt de volgende actie
  3. Tool-aanroep: Indien nodig roept de agent een of meer tools aan
  4. Observatie: De agent ontvangt de resultaten van de tools
  5. Beslissing: De agent beslist of deze doorgaat (terug naar stap 2) of antwoordt
  6. Antwoord: De agent produceert het definitieve antwoord

De kern is de lus tussen stap 2 en 5, die meerdere keren kan worden doorlopen. Een agent kan 5, 10 of zelfs 20 tool-aanroepen achter elkaar uitvoeren voordat een eindantwoord wordt gegeven, zonder dat u ook maar één regel orchestratiecode schrijft. Het onderstaande voorbeeld illustreert dit: er worden twee onafhankelijke tools gedeclareerd en het model beslist hoe deze te ketenen.

from agents import Agent, Runner, function_tool

@function_tool
def rechercher_produit(nom: str) -> str:
    """Searches for a product in the catalog."""
    # Simulation - in production, call your database
    catalogue = {
        "laptop-pro": {"prix": 1299, "stock": 45},
        "tablet-air": {"prix": 599, "stock": 120},
    }
    produit = catalogue.get(nom)
    if produit:
        return f"Produit {nom}: {produit['prix']}€, stock: {produit['stock']}"
    return f"Produit {nom} non trouvé"

@function_tool
def calculer_remise(prix: float, pourcentage: float) -> str:
    """Calculates the price after discount."""
    prix_final = prix * (1 - pourcentage / 100)
    return f"Prix après {pourcentage}% de remise : {prix_final:.2f}€"

agent = Agent(
    name="Sales Agent",
    instructions="You help customers find products and calculate discounts.",
    tools=[rechercher_produit, calculer_remise],
    model="gpt-5.6-terra",
)

# The agent will: 1) find the product, 2) calculate the discount, 3) respond
result = Runner.run_sync(
    agent,
    "What is the price of the laptop-pro with a 15% discount?"
)
print(result.final_output)

De vraag vereist twee bewerkingen die in de code niet expliciet aan elkaar zijn gekoppeld. De agent voert automatisch twee tool-aanroepen sequentieel uit: eerst rechercher_produit, vervolgens calculer_remise met de opgehaalde prijs. Deze ketening is een beslissing van het model, geen instructie van u.

Interne structuur: items en berichten

De Responses API structureert elke interactie als items. Door deze te inspecteren, ziet u wat uw agent daadwerkelijk heeft gedaan. Er komen drie typen voor in het gesprek:

  • message: een tekstbericht (van de gebruiker of de agent)
  • function_call: een tool-aanroep die door de agent is besloten
  • function_call_output: het resultaat dat door de tool wordt teruggegeven
result = Runner.run_sync(agent, "Find the tablet-air")

# Inspect the reasoning steps
for item in result.raw_responses:
    print(f"Type: {type(item).__name__}")
    # You'll see: message input → function_call → function_call_output → message output

Maak er een gewoonte van om deze lus te traceren wanneer een agent een verrassend antwoord geeft. In negen van de tien gevallen zit de afwijking in een function_call met onverwachte argumenten.

Parallelle versus sequentiële aanroepen

Niet alle stappen zijn van elkaar afhankelijk. Wanneer twee aanroepen onafhankelijk zijn, kan de agent besluiten ze parallel uit te voeren.

@function_tool
def obtenir_meteo(ville: str) -> str:
    """Gets the current weather for a city."""
    meteos = {"Paris": "18°C, sunny", "Lyon": "16°C, cloudy"}
    return meteos.get(ville, "Data unavailable")

agent = Agent(
    name="Travel Agent",
    instructions="You help plan trips.",
    tools=[obtenir_meteo, rechercher_produit],
    model="gpt-5.6-terra",
)

# The agent will call obtenir_meteo("Paris") and obtenir_meteo("Lyon") in parallel
result = Runner.run_sync(
    agent,
    "What's the weather in Paris and Lyon?"
)

Het weer in Lyon is niet afhankelijk van dat in Parijs: de SDK behandelt parallelisme automatisch en start beide aanroepen gelijktijdig, wat de latentie verlaagt. Vergelijk dit met het verkoopvoorbeeld hierboven, waar de kortingsberekening moest wachten op de prijs: daar legt de volgorde zich vanzelf op.

De parameter max_turns

Een autonome lus kan in het ergste geval oneindig doorgaan: de agent roept een tool aan, het resultaat zet de agent aan tot een volgende aanroep, enzovoort. De beveiliging hiervoor is een enkele parameter.

result = Runner.run_sync(
    agent,
    "Full catalog analysis",
    max_turns=10  # Maximum 10 loop iterations
)

Als de agent de limiet bereikt, stopt deze met de tot dan toe verkregen resultaten. In productieomgevingen is dit een essentiële veiligheidsmaatregel: het beperkt zowel de responstijd als de kosten.

Belangrijkste punten

  • Een agent werkt in een lus: redeneren → tool → observatie → beslissing
  • Deze lus kan meerdere keren worden doorlopen voordat een antwoord wordt geproduceerd
  • Het model beslist automatisch welke tools worden aangeroepen en in welke volgorde
  • Onafhankelijke tool-aanroepen worden parallel uitgevoerd
  • max_turns beperkt het aantal iteraties omwille van de veiligheid