Architectuur van agenten: de redeneer-tool-lus
Ezen az oldalon
Bijgewerkt op 3 november 2026: In
rechercher_produitontbraken de aanhalingstekens rond de sleutelsprixenstock, wat bij de eerste tool-aanroep eenNameErrorveroorzaakte.
Architectuur van agenten: de redeneer-tool-lus
Om effectieve agenten te bouwen, moet je hun interne architectuur begrijpen. Een OpenAI-agent werkt volgens een redeneerlus: hij ontvangt een taak, denkt na, gebruikt een tool, observeert het resultaat en beslist vervolgens of hij klaar is of moet doorgaan. Alles wat je daarna doet—tools declareren, bewaking instellen, meerdere agenten orchestreren—bouwt voort op deze lus.
De levenscyclus van een agent
Elke uitvoering doorloopt zes stappen:
- Ontvangst: De agent ontvangt het gebruikersbericht en de systeeminstructies
- Redeneren: Het model analyseert het verzoek en beslist over de volgende actie
- Tool-aanroep: Indien nodig roept de agent een of meer tools aan
- Observatie: De agent ontvangt de resultaten van de tools
- Beslissing: De agent beslist of hij doorgaat (terug naar stap 2) of antwoordt
- Antwoord: De agent produceert zijn definitieve antwoord
De kern is de lus tussen stap 2 en 5, die meerdere keren kan draaien. Een agent kan 5, 10 of zelfs 20 tool-aanroepen achter elkaar uitvoeren voordat hij een definitief antwoord geeft, zonder dat jij een enkele regel orchestratiecode schrijft. Het onderstaande voorbeeld toont dit: er worden twee onafhankelijke tools gedeclareerd en het model beslist hoe ze 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 gekoppeld zijn. De agent voert automatisch twee tool-aanroepen sequentieel uit: eerst rechercher_produit, daarna calculer_remise met de opgehaalde prijs. Deze ketening is een beslissing van het model, geen instructie van jou.
Interne structuur: items en berichten
De Responses API structureert elke interactie als items. Door ze te lezen, zie je wat je agent daadwerkelijk heeft gedaan. Drie typen verschijnen in het gesprek:
message: een tekstbericht (van de gebruiker of de agent)function_call: een tool-aanroep waar de agent toe beslistfunction_call_output: het resultaat dat de tool teruggeeft
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. Negen van de tien keer duikt de afwijking op 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 beslissen 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 hangt niet af 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 op de prijs moest wachten: daar legt de volgorde zich vanzelf op.
De parameter max_turns
Een autonome lus kan in het ergste geval nooit stoppen: de agent roept een tool aan, het resultaat zet hem aan tot nog een aanroep, enzovoort. De beveiliging is één enkele parameter.
result = Runner.run_sync(
agent,
"Full catalog analysis",
max_turns=10 # Maximum 10 loop iterations
)
Als de agent de limiet bereikt, stopt hij met de tot dan toe verkregen resultaten. In productie is dit essentiële veiligheid: het begrenst zowel de responstijd als de kosten.
Főbb megállapítások
- Een agent draait in een lus: redeneren → tool → observatie → beslissing
- Deze lus kan meerdere keren draaien voordat er een antwoord komt
- Het model beslist automatisch welke tools het aanroept en in welke volgorde
- Onafhankelijke tool-aanroepen worden parallel uitgevoerd
max_turnsbeperkt het aantal iteraties uit veiligheidsoverwegingen