Agentarkitektur: værktøjs-ræsonnementsløkken
På denne side
Opdateret 3. november 2026: I
rechercher_produitmanglede nøglerneprixogstockanførselstegn, hvilket forårsagede enNameErrorved det første værktøjskald.
Agentarkitektur: værktøjs-ræsonnementsløkken
For at bygge effektive agenter skal du forstå deres interne arkitektur. En OpenAI-agent opererer på en ræsonnementsløkke: den modtager en opgave, tænker, bruger et værktøj, observerer resultatet og beslutter derefter, om den er færdig, eller om den skal fortsætte. Alt, hvad du gør herefter – erklæring af værktøjer, opsætning af sikkerhedsforanstaltninger, orkestrering af flere agenter – bygger på denne løkke.
Agentens livscyklus
Hver kørsel følger seks trin:
- Modtagelse: Agenten modtager brugerens besked og systeminstruktioner
- Ræsonnement: Modellen analyserer anmodningen og beslutter næste handling
- Værktøjskald: Om nødvendigt kalder agenten ét eller flere værktøjer
- Observation: Agenten modtager resultaterne fra værktøjerne
- Beslutning: Agenten beslutter, om den skal fortsætte (tilbage til trin 2) eller svare
- Svar: Agenten producerer sit endelige svar
Nøglen er løkken mellem trin 2 og 5, som kan køre flere gange. En agent kan kæde 5, 10 eller endda 20 værktøjskald sammen, før den producerer et endeligt svar, uden at du skriver en eneste linje orkestreringskode. Eksemplet nedenfor viser dette: to uafhængige værktøjer erklæres, og modellen beslutter, hvordan de skal kædes sammen.
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)
Spørgsmålet kræver to operationer, der ikke er eksplicit forbundet i koden. Agenten udfører automatisk to værktøjskald i rækkefølge: først rechercher_produit, derefter calculer_remise med den hentede pris. Denne kædning er en modelbeslutning, ikke din instruktion.
Intern struktur: elementer og beskeder
Responses API strukturerer hver interaktion som elementer (items). Ved at læse dem kan du se, hvad din agent faktisk har gjort. Tre typer optræder i samtalen:
message: en tekstbesked (fra brugeren eller agenten)function_call: et værktøjskald besluttet af agentenfunction_call_output: resultatet returneret af værktøjet
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
Gør det til en vane at spore denne løkke, hver gang en agent producerer et overraskende svar. Ni ud af ti gange viser anomalien sig i et function_call med uventede argumenter.
Parallelle kontra sekventielle kald
Ikke alle trin afhænger af hinanden. Når to kald er uafhængige, kan agenten beslutte at køre dem parallelt.
@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?"
)
Lyons vejr afhænger ikke af Paris’: SDK’et håndterer parallelisme automatisk og lancerer begge kald samtidigt, hvilket reducerer ventetiden. Sammenlign dette med salgseksemplet ovenfor, hvor rabatten skulle vente på prisen: her påtvinges sekvensen af sig selv.
Parameteren max_turns
En autonom løkke kan i værste fald aldrig stoppe: agenten kalder et værktøj, resultatet får den til at kalde et andet, og så videre. Sikringen er en enkelt parameter.
result = Runner.run_sync(
agent,
"Full catalog analysis",
max_turns=10 # Maximum 10 loop iterations
)
Hvis agenten rammer grænsen, stopper den med de resultater, den har opnået hidtil. I produktion er dette en essentiel sikkerhedsforanstaltning: det sætter loft over både svartid og omkostninger.
Vigtige pointer
- En agent kører i en løkke: ræsonnement → værktøj → observation → beslutning
- Denne løkke kan udføres flere gange, før der produceres et svar
- Modellen beslutter automatisk, hvilke værktøjer der skal kaldes, og i hvilken rækkefølge
- Uafhængige værktøjskald køres parallelt
max_turnsbegrænser antallet af iterationer af sikkerhedsmæssige årsager