Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Multi-trins agent med ræsonnementssløjfe

Lektion 15 af 25 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Multi-trins agent med ræsonnementssløjfe
  2. Plan-udfør-mønsteret
  3. Selv-korrigerende agent
  4. Mønster: Kæde af specialiserede agenter
  5. Styring af ræsonnementsdybde
  6. Vigtige pointer

Multi-trins agent med ræsonnementssløjfe

De mest kraftfulde agenter stopper ikke efter et enkelt værktøjskald. De kæder flere ræsonnementstrin sammen, justerer deres strategi baseret på resultaterne og itererer, indtil de når deres mål. I denne lektion lærer du at bygge disse multi-trins agenter. Eksemplerne bruger GPT-5.6-familien: Hvor den tidligere generation krævede skift af modeller for at aktivere ræsonnement, styrer du nu denne adfærd via effort-indstillingen på din valgte model.

Plan-udfør-mønsteret

En multi-trins agent starter med at skabe en plan og udfører derefter hvert trin. Denne adskillelse er bevidst: Planlæggeren har ingen værktøjer og producerer en typet struktur, mens eksekutøren modtager denne plan som et køreplan og blot følger den. En vag anmodning som „forbered kvartalsrapporten for nøglekunder” bliver til en konkret sekvens af handlinger – spørg CRM’en, generér rapporten, send e-mailen – før nogen handling forsøges.

from agents import Agent, Runner, function_tool
from pydantic import BaseModel
import json

class PlanAction(BaseModel):
    steps: list[str]
    objective: str

planner_agent = Agent(
    name="Planner",
    instructions="""Du modtager en kompleks opgave. Opdel den i simple, ordnede trin.
    Hvert trin skal være en konkret, handlingsbar post.""",
    model="gpt-5.6-sol",  # Avanceret ræsonnement til planlægning
    output_type=PlanAction,
)

@function_tool
def search_crm(query: str) -> str:
    """Søger i CRM'en efter kundeoplysninger."""
    return json.dumps({"customers": [
        {"name": "Acme Corp", "revenue": 500000, "contract": "Enterprise"},
        {"name": "TechStart", "revenue": 50000, "contract": "Starter"},
    ]})

@function_tool
def generate_report(title: str, content: str) -> str:
    """Genererer en formateret rapport."""
    return f"Rapport '{title}' genereret succesfuldt ({len(content)} tegn)"

@function_tool
def send_email(recipient: str, subject: str, body: str) -> str:
    """Sender en e-mail."""
    return f"E-mail sendt til {recipient}: {subject}"

executor_agent = Agent(
    name="Executor",
    instructions="""Du udfører opgaver trin for trin.
    Brug tilgængelige værktøjer til at fuldføre hvert trin.
    Hvis et trin fejler, så prøv en alternativ tilgang.""",
    tools=[search_crm, generate_report, send_email],
    model="gpt-5.6-terra",
)

async def process_complex_task(task: str):
    # Trin 1: Planlæg
    plan = await Runner.run(planner_agent, task)
    print(f"Plan: {plan.final_output.steps}")

    # Trin 2: Udfør med planen som kontekst
    execution_instructions = f"""Udfør følgende trin i rækkefølge:
    {chr(10).join(f'{i+1}. {e}' for i, e in enumerate(plan.final_output.steps))}
    Mål: {plan.final_output.objective}"""

    result = await Runner.run(executor_agent, execution_instructions)
    return result.final_output

Selv-korrigerende agent

Planlægning er ikke nok: I den virkelige verden fejler værktøjer. Den anden form for sløjfe lader agenten opdage sine egne fejl og rette dem. Alt afhænger af en detalje, der ofte overses – værktøjet kaster ikke en undtagelse; det returnerer en læsbar fejlmeddelelse. Agenten læser den, indser, at den har glemt FROM-klausulen, omskriver sin forespørgsel og prøver igen, inden for grænsen på tre forsøg sat af dens instrukser.

from agents import Agent, Runner, function_tool

@function_tool
def execute_sql_query(sql: str) -> str:
    """Udfører en SQL-forespørgsel på databasen."""
    # Simulation: nogle forespørgsler fejler
    if "DROP" in sql.upper():
        return "FEJL: Destruktive forespørgsler er forbudt."
    if "SELECT" in sql.upper() and "FROM" not in sql.upper():
        return "FEJL: Ugyldig SQL-syntaks - mangler FROM."
    return json.dumps({
        "columns": ["name", "monthly_revenue", "region"],
        "rows": [
            ["Acme Corp", 45000, "Île-de-France"],
            ["TechStart", 12000, "Rhône-Alpes"],
        ],
        "result_count": 2
    })

analyst_agent = Agent(
    name="Data Analyst",
    instructions="""Du analyserer data ved at udføre SQL-forespørgsler.
    Hvis en forespørgsel fejler:
    1. Analyser fejlmeddelelsen
    2. Ret forespørgslen
    3. Prøv igen
    Maksimum 3 forsøg pr. forespørgsel.
    Brug aldrig DROP, DELETE eller TRUNCATE.""",
    tools=[execute_sql_query],
    model="gpt-5.6-terra",
    max_turns=10,  # Nok omdrejninger til korrektioner
)

result = Runner.run_sync(
    analyst_agent,
    "Hvad er den samlede omsætning pr. region?"
)

Bemærk, at forbuddet mod destruktive forespørgsler optræder to steder: i instrukserne og i værktøjskoden. Instrukserne guider modellen, men det er kun server-side-tjekket i værktøjet, der garanterer, at en DROP TABLE aldrig sniger sig igennem.

Mønster: Kæde af specialiserede agenter

Til komplekse arbejdsgange skal du kæde flere specialiserede agenter sammen i stedet for at belaste en enkelt agent med ethvert ansvar. Hvert led har en klar rolle: Indsamleren samler råmaterialet, analytikeren – udstyret med en ræsonnementsmodel – identificerer tendenser, og skribenten formatterer outputtet. Fordelen er både pædagogisk og operationel: Når den endelige rapport skuffer, ved du straks, hvilken af de tre agenter du skal rette.

from agents import Agent, Runner

collection_agent = Agent(
    name="Data Collector",
    instructions="Indsaml alle data nødvendige for analysen.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)

analysis_agent = Agent(
    name="Analyst",
    instructions="Analyser de indsamlede data og identificer tendenser.",
    model="gpt-5.6-sol",  # Avanceret ræsonnement til analyse
)

writing_agent = Agent(
    name="Writer",
    instructions="""Skriv en klar, struktureret rapport på engelsk
    baseret på den leverede analyse. Format: introduktion, nøglepunkter, anbefalinger.""",
    model="gpt-5.6-terra",
)

async def analysis_pipeline(question: str):
    # Trin 1: Indsaml data
    data = await Runner.run(collection_agent, question)

    # Trin 2: Analyser
    analysis = await Runner.run(
        analysis_agent,
        f"Analyser disse data: {data.final_output}"
    )

    # Trin 3: Skriv rapporten
    report = await Runner.run(
        writing_agent,
        f"Skriv en rapport baseret på denne analyse: {analysis.final_output}"
    )

    return report.final_output

Styring af ræsonnementsdybde

Alle disse sløjfer deler én egenskab: De stopper måske aldrig. Parameteren max_turns er din primære sikkerhedsforanstaltning, og du finjusterer den baseret på opgavens ambition. Tre omdrejninger er nok til en agent, der forventes at svare ved første forsøg; femogtyve er nødvendige til en udforskning, der spørger flere kilder, før den konkluderer.

# Konservativ agent: få omdrejninger
simple_agent = Agent(
    name="Simple Agent",
    instructions="Svar på én omdrejning hvis muligt.",
    model="gpt-5.6-terra",
)
result = await Runner.run(simple_agent, "Simpelt spørgsmål", max_turns=3)

# Kompleks agent: mange omdrejninger
research_agent = Agent(
    name="Deep Researcher",
    instructions="Udforsk alle vinkler før konklusion.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)
result = await Runner.run(research_agent, "Fuld Q1-analyse", max_turns=25)

Sæt denne værdi ved at observere dine spor i stedet for at gætte: Hvis dine faktiske eksekveringer afsluttes på seks omdrejninger, beskytter en grænse på femogtyve mod ingenting.

Vigtige pointer

  • Plan-udfør-mønsteret adskiller planlægning (ræsonnementsmodel) fra udførelse
  • En selv-korrigerende agent analyserer sine fejl og justerer sin strategi
  • Kæder af specialiserede agenter muliggør komplekse, vedligeholdelige arbejdsgange
  • max_turns styrer ræsonnementsdybden og beskytter mod uendelige sløjfer
  • Reserver avancerede ræsonnementsevner til planlægning og analyse