Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Agentarkitektur: værktøjs-ræsonnementsløkken

Lektion 2 af 25 Opdateret 3. november 2026 Udvikler
På denne side
  1. Agentarkitektur: værktøjs-ræsonnementsløkken
  2. Agentens livscyklus
  3. Intern struktur: elementer og beskeder
  4. Parallelle kontra sekventielle kald
  5. Parameteren max_turns
  6. Vigtige pointer

Opdateret 3. november 2026: I rechercher_produit manglede nøglerne prix og stock anførselstegn, hvilket forårsagede en NameError ved 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:

  1. Modtagelse: Agenten modtager brugerens besked og systeminstruktioner
  2. Ræsonnement: Modellen analyserer anmodningen og beslutter næste handling
  3. Værktøjskald: Om nødvendigt kalder agenten ét eller flere værktøjer
  4. Observation: Agenten modtager resultaterne fra værktøjerne
  5. Beslutning: Agenten beslutter, om den skal fortsætte (tilbage til trin 2) eller svare
  6. 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 agenten
  • function_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_turns begrænser antallet af iterationer af sikkerhedsmæssige årsager