Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Perdavimai: kelių agentų orchestravimas

Paskaita 12 iš 25 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Perdavimai: kelių agentų orchestravimas
  2. Perdavimo koncepcija
  3. Perdavimo aprašymo pritaikymas
  4. Perdavimai su kontekstu
  5. Šablonas: trijų lygių triažas
  6. Abipusiai perdavimai
  7. Perdavimų stebėjimas
  8. Svarbiausi punktai

Perdavimai: kelių agentų orchestravimas

Vienas agentas negali padaryti visko. Kuo daugiau sričių sugrūdi į vieną instrukcijų rinkinį, tuo labiau gairės prieštarauja viena kitai, o atsakymai tampa vis blankesni. Perdavimai leidžia agentui perduoti pokalbį kitam specializuotam agentui. Tai pagrindinis mechanizmas kuriant daugiagentines sistemas, kuriose kiekvienas agentas puikiai išmano savo sritį.

Perdavimo koncepcija

Perdavimas – tai valdymo perėjimas nuo vieno agento prie kito. Kai Agentas A perduoda valdymą Agentui B, Agentas B perima iniciatyvą ir sugeneruoja atsakymą. „Runner“ šį perėjimą valdo automatiškai: tau nereikia rašyti aiškios maršrutizavimo logikos ar rankiniu būdu kviesti antrojo agento. Toliau pateiktame pavyzdyje triažo agentas gauna skundą dėl sąskaitos sumos, atpažįsta sritį ir perduoda estafetę. Tuo tarpu klientas mato tik vieną vientisą pokalbį.

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)

Perdavimo aprašymo pritaikymas

Pagal nutylėjimą perdavimas naudoja tikslinio agento pavadinimą ir instrukcijas. Tai veikia gerai, kol pavadinimai yra aprašomieji, tačiau tampa rizikinga, kai du agentai atrodo panašiai. Tokiais atvejais gali pritaikyti aprašymą, kad nukreiptum maršrutizavimą, išvardydamas konkrečius scenarijus, kurie turėtų suaktyvinti kiekvieną perdavimą.

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

Perdavimai su kontekstu

Perdavimas naudingas tik tada, kai jį perimantis agentas žino, kas vyksta. Kai agentas atlieka perdavimą, pokalbio istorija perduodama tiksliniam agentui: naujasis agentas turi prieigą prie visko, kas buvo pasakyta iki šiol, todėl klientui nereikia kartoti savo problemos. Be to, tipizuotas kontekstas perneša struktūrizuotus sesijos duomenis – kliento ID, prenumeratos planą, ankstesnius bilietus – ir lieka prieinamas gaunančio agento įrankiams.

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

Šablonas: trijų lygių triažas

Perdavimai neapsiriboja horizontaliu maršrutizavimu. Jie taip pat atkuria tikros pagalbos tarnybos eskalacijos struktūrą. Štai gamybinis šablonas su trimis lygiais: L1 tvarko įprastas užklausas, sudėtingesnes konfigūracijos problemas perduoda L2, o L2 architektūros temas eskaluoja L3. Atkreipk dėmesį, kad trečiasis lygis remiasi pajėgesniu modeliu, nes jis mato tik tuos atvejus, kurie jau buvo atrinkti dviejų precedingų pakopų.

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

Abipusiai perdavimai

Grandinė taip pat gali būti ciklinė: du agentai gali perduoti valdymą vienas kitam atgal ir pirmyn. Tai tipiška situacija, kai potencialus klientas užduoda techninį klausimą pardavimų pokalbio metu, o tada, nuramintas, grįžta prie kainodaros.

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]

Saugokis begalinių kilpų: rekomenduojama naudoti apsauginę ribą arba max_turns. Be šio apribojimo, dviprasmiška užklausa gali mėtyti pokalbį nuo vieno agento prie kito, kol išseks tavo kvota.

Perdavimų stebėjimas

Galiausiai tau reikia žinoti, kas iš tikrųjų atsakė – tiek maršrutizavimui patikrinti, tiek pagalbos statistikai rinkti. RunResult nurodo, kuris agentas galiausiai sugeneravo atsakymą.

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

Įprask registruoti šią reikšmę: jei triažo agentas toliau valdo užklausas, kurias turėjo perduoti, last_agent pasiskirstymas atskleis problemą gerokai anksčiau nei klientų atsiliepimai.

Svarbiausi punktai

  • Perdavimai leidžia deleguoti pokalbį specializuotam agentui
  • Pokalbio istorija perduodama tiksliniam agentui
  • Naudok Handoff(agent=..., description=...), kad nukreiptum maršrutizavimą
  • Bendras kontekstas (RunContextWrapper) yra prieinamas visiems agentams
  • result.last_agent.name nurodo, kuris agentas galiausiai atsakė
  • Apsaugok abipusius perdavimus naudodamas max_turns, kad išvengtum kilpų