Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Överlämningar: Orkestrering av flera agenter

Lektion 12 av 25 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Överlämningar: Orkestrering av flera agenter
  2. Konceptet överlämning
  3. Anpassa beskrivningen av överlämningen
  4. Överlämningar med kontext
  5. Mönster: Treenig triage
  6. Ömsesidiga överlämningar
  7. Spårning av överlämningar
  8. Viktiga punkter

Överlämningar: Orkestrering av flera agenter

En enskild agent kan inte göra allt. Ju fler domäner du proppar in i en enda uppsättning instruktioner, desto mer kommer riktlinjerna att motsäga varandra och desto ljumskare blir svaren. Överlämningar låter en agent delegera konversationen till en annan specialiserad agent. Detta är nyckelmekanismen för att bygga system med flera agenter där varje agent excellerar inom sitt eget område.

Konceptet överlämning

En överlämning är en överföring av kontrollen från en agent till en annan. När Agent A lämnar över till Agent B, tar Agent B över och genererar svaret. Runnern hanterar denna övergång automatiskt: du behöver inte skriva explicit routningslogik eller manuellt anropa den andra agenten. I exemplet nedan tar triage-agenten emot ett klagomål om en fakturabelopp, känner igen domänen och lämnar över stafettpinnen. Kunden ser under tiden bara en sammanhängande konversation.

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)

Anpassa beskrivningen av överlämningen

Som standard använder en överlämning målagentens namn och instruktioner. Detta fungerar bra så länge namnen är beskrivande, men blir riskabelt när två agenter liknar varandra. I dessa fall kan du anpassa beskrivningen för att styra routningen genom att lista de specifika scenarier som ska utlösa varje överföring.

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.",
        ),
    ],
)

Överlämningar med kontext

En överföring är bara användbar om agenten som tar över vet vad som pågår. När en agent utför en överlämning skickas konversationshistoriken till målagenten: den nya agenten har tillgång till allt som sagts hittills, så kunden slipper upprepa sitt problem. Utöver detta bär typad kontext strukturerad sessionsdata – kund-ID, abonnemangsplan, tidigare ärenden – och förblir tillgänglig för den inkommande agentens verktyg.

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: Treenig triage

Överlämningar är inte begränsade till horisontell routning. De kan också återskapa eskaleringsstrukturen i en riktig supporttjänst. Här är ett produktionsmönster med tre nivåer: L1 hanterar rutinfrågor, överför avancerade konfigurationsproblem till L2, och L2 eskalerar arkitekturfrågor till L3. Observera att nivå 3 förlitar sig på en mer kapabel modell, eftersom den bara ser fall som redan filtrerats av de två föregående nivåerna.

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",
)

Ömsesidiga överlämningar

Kedjan kan också vara cirkulär: två agenter kan överföra kontrollen fram och tillbaka. Detta är typiskt när en presumtiv kund ställer en teknisk fråga under ett försäljningssamtal och sedan återgår till prissättning när hen blivit lugnad.

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]

Se upp för oändliga loopar: en skyddsmekanism eller max_turns rekommenderas. Utan denna gräns kan en tvetydig begäran få konversationen att studsa från en agent till en annan tills din kvot är uttömd.

Spårning av överlämningar

Slutligen behöver du veta vem som faktiskt svarade – både för att verifiera din routning och för dina supportstatistik. RunResult berättar vilken agent som slutligen producerade 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 till en vana att logga detta värde: om en triage-agent behåller kontrollen över förfrågningar som den borde ha överfört, kommer fördelningen av last_agent att avslöja problemet långt innan kundfeedback gör det.

Viktiga punkter

  • Överlämningar låter dig delegera konversationen till en specialiserad agent
  • Konversationshistorik skickas till målagenten
  • Använd Handoff(agent=..., description=...) för att styra routningen
  • Delad kontext (RunContextWrapper) är tillgänglig för alla agenter
  • result.last_agent.name indikerar vilken agent som slutligen svarade
  • Skydda ömsesidiga överlämningar med max_turns för att förhindra loopar