Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Overdragelser: Orkestrering af flere agenter

Lektion 12 af 25 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Overdragelser: Orkestrering af flere agenter
  2. Konceptet bag overdragelse
  3. Tilpasning af overdragelsesbeskrivelsen
  4. Overdragelser med kontekst
  5. Mønster: Treenet triage
  6. Gensidige overdragelser
  7. Sporing af overdragelser
  8. Vigtige pointer

Overdragelser: Orkestrering af flere agenter

En enkelt agent kan ikke gøre alt. Jo flere domæner du propper ind i ét sæt instrukser, jo mere modstridende bliver retningslinjerne, og jo mere udvandede bliver svarene. Overdragelser gør det muligt for en agent at delegere samtalen til en anden specialiseret agent. Dette er nøglemekanismen til at opbygge multi-agent-systemer, hvor hver agent excellerer inden for sit eget domæne.

Konceptet bag overdragelse

En overdragelse er en overførsel af kontrol fra én agent til en anden. Når Agent A overdrager til Agent B, tager Agent B over og genererer svaret. Runner håndterer denne overgang automatisk: du behøver ikke skrive eksplicit routeringslogik eller manuelt kalde den anden agent. I eksemplet nedenfor modtager triage-agenten en klage over en fakturabeløb, genkender domænet og giver stafetten videre. Kunden ser imidlertid kun én sammenhængende samtale.

from agents import Agent, Runner

billing_agent = Agent(
    name="Billing Agent",
    instructions="""You handle billing questions: invoices, payments,
    refunds, subscriptions. Respond precisely and professionally.""",
    model="gpt-5.6-terra",
)

technical_agent = Agent(
    name="Technical Agent",
    instructions="""You handle technical support: bugs, configuration,
    installation, troubleshooting. Provide step-by-step instructions.""",
    model="gpt-5.6-terra",
)

triage_agent = Agent(
    name="Triage Agent",
    instructions="""You are the first point of contact.
    Analyze the customer's request and transfer it to the appropriate agent.
    - Billing questions → Billing Agent
    - Technical questions → Technical Agent""",
    handoffs=[billing_agent, technical_agent],
    model="gpt-5.6-terra",
)

result = Runner.run_sync(
    triage_agent,
    "My latest invoice seems incorrect; the amount is too high."
)
# The triage agent hands off to the billing agent
print(f"Answered by: {result.last_agent.name}")
print(result.final_output)

Tilpasning af overdragelsesbeskrivelsen

Som standard bruger en overdragelse mål-agentens navn og instrukser. Dette fungerer fint, så længe navnene er beskrivende, men bliver risikabelt, når to agenter ligner hinanden. I disse tilfælde kan du tilpasse beskrivelsen for at guide routeringen ved at liste de specifikke scenarier, der skal udløse hver overførsel.

from agents import Handoff

triage_agent = Agent(
    name="Triage Agent",
    instructions="Transfer the request to the specialized agent.",
    handoffs=[
        Handoff(
            agent=billing_agent,
            description="Transfer for payment questions, invoices, refunds, and subscriptions.",
        ),
        Handoff(
            agent=technical_agent,
            description="Transfer for technical issues, bugs, and configuration help requests.",
        ),
    ],
)

Overdragelser med kontekst

En overførsel er kun nyttig, hvis den agent, der tager over, ved, hvad der foregår. Når en agent udfører en overdragelse, videregives samtalehistorikken til mål-agenten: den nye agent har adgang til alt, hvad der er blevet sagt hidtil, så kunden ikke behøver gentage sit problem. Derudover bærer typed kontekst strukturerede sessionsdata – kunde-ID, abonneret plan, tidligere tickets – og forbliver tilgængelig for den modtagende agents værktøjer.

from dataclasses import dataclass
from agents import Agent, Runner, RunContextWrapper, function_tool

@dataclass
class CustomerContext:
    client_id: str
    plan: str
    ticket_history: list[str]

@function_tool
def view_invoice(ctx: RunContextWrapper[CustomerContext], month: str) -> str:
    """Views the invoice for a given month for the current customer."""
    client_id = ctx.context.client_id
    return f"Invoice for {month} for {client_id}: €149.99 (plan {ctx.context.plan})"

billing_agent = Agent(
    name="Billing Agent",
    instructions="You handle billing. Use the customer context.",
    tools=[view_invoice],
    model="gpt-5.6-terra",
)

triage_agent = Agent(
    name="Triage",
    instructions="Transfer to the right agent.",
    handoffs=[billing_agent],
    model="gpt-5.6-terra",
)

context = CustomerContext(
    client_id="cli_456",
    plan="Pro",
    ticket_history=["Ticket #001: Slow connection"]
)

result = Runner.run_sync(
    triage_agent,
    "Can you check my invoice for March?",
    context=context,
)

Mønster: Treenet triage

Overdragelser er ikke begrænset til horisontal routering. De kan også efterligne eskaleringsstrukturen i en rigtig supporttjeneste. Her er et produktionsmønster med tre niveauer: L1 håndterer rutinemæssige forespørgsler, overfører avancerede konfigurationsproblemer til L2, og L2 eskalerer arkitekturemner til L3. Bemærk, at niveau 3 stole på en mere kapacitetsstærk model, da den kun ser sager, der allerede er filtreret af de to foregående trin.

level3_agent = Agent(
    name="L3 Technical Expert",
    instructions="""You are a level 3 technical expert.
    You handle complex architecture and infrastructure problems.
    If you cannot resolve the issue, indicate that human escalation is necessary.""",
    model="gpt-5.6-sol",  # The most capable model for complex cases
)

level2_agent = Agent(
    name="L2 Technical Support",
    instructions="""You are a level 2 technician.
    You handle advanced configuration problems.
    If the problem is too complex, transfer to level 3.""",
    handoffs=[level3_agent],
    model="gpt-5.6-terra",
)

level1_agent = Agent(
    name="L1 Customer Support",
    instructions="""You are the first point of contact for customer support.
    Handle simple questions (password, account, navigation).
    Transfer technical problems to level 2.""",
    handoffs=[level2_agent],
    model="gpt-5.6-terra",
)

Gensidige overdragelser

Kæden kan også være cirkulær: to agenter kan overføre kontrol frem og tilbage. Dette er typisk, når en potentiel kunde stiller et teknisk spørgsmål under en salgssamtale og derefter vender tilbage til prisfastsættelse, når de er blevet beroliget.

sales_agent = Agent(
    name="Sales Agent",
    instructions="""You sell products. If the customer asks
    for technical support, transfer to the technical agent.""",
)

support_agent = Agent(
    name="Support Agent",
    instructions="""You provide technical support. If the customer
    wants to buy something, transfer to the sales agent.""",
)

# Bidirectional handoffs
sales_agent.handoffs = [support_agent]
support_agent.handoffs = [sales_agent]

Pas på uendelige løkker: en guardrail eller max_turns anbefales. Uden denne grænse kan en tvetydig forespørgsel få samtalen til at hoppe fra én agent til en anden, indtil din kvote er opbrugt.

Sporing af overdragelser

Endelig skal du vide, hvem der faktisk svarede – både for at verificere din routering og til dine supportstatistikker. RunResult fortæller dig, hvilken agent der i sidste ende producerede svaret.

result = Runner.run_sync(triage_agent, "I have a critical bug")

print(f"Initial agent: triage_agent")
print(f"Final agent: {result.last_agent.name}")
# Prints "Technical Agent" if triage worked correctly

Gør det til en vane at logge denne værdi: hvis en triage-agent fortsat beholder kontrollen over forespørgsler, den burde have overført, vil fordelingen af last_agent afsløre problemet længe før kundetilbagemeldingerne gør det.

Vigtige pointer

  • Overdragelser lader dig delegere samtalen til en specialiseret agent
  • Samtalehistorik videregives til mål-agenten
  • Brug Handoff(agent=..., description=...) til at guide routeringen
  • Delt kontekst (RunContextWrapper) er tilgængelig for alle agenter
  • result.last_agent.name indikerer, hvilken agent der endelig svarede
  • Beskyt gensidige overdragelser med max_turns for at forhindre løkker