Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Predaje: Orkestracija više agenata

Lekcija 12 od 25 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Predaje: Orkestracija više agenata
  2. Koncept predaje
  3. Prilagodba opisa predaje
  4. Predaje s kontekstom
  5. Obrazac: Triaža na tri razine
  6. Dvosmjerne predaje
  7. Praćenje predaja
  8. Ključne točke

Predaje: Orkestracija više agenata

Jedan agent ne može učiniti sve. Što više domena nagomilaš u jedan skup uputa, to se smjernice više međusobno proturječe, a odgovori postaju mlakiji. Predaje omogućuju agentu da delegira razgovor drugom specijaliziranom agentu. To je ključni mehanizam za izgradnju sustava s više agenata gdje svaki agent izvrsno djeluje u svom domenu.

Koncept predaje

Predaja je prijenos kontrole s jednog agenta na drugi. Kada Agent A preda razgovor Agentu B, Agent B preuzima kontrolu i generira odgovor. Runner automatski obrađuje ovaj prijelaz: ne moraš pisati eksplicitnu logiku usmjeravanja niti ručno pozivati drugog agenta. U primjeru ispod, agent za trijažu prima pritužbu na iznos računa, prepoznaje domenu i prosljeđuje palicu. Kupac, s druge strane, vidi samo jedan neprekidan razgovor.

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)

Prilagodba opisa predaje

Zadano, predaja koristi ime i upute ciljanog agenta. To dobro funkcionira sve dok su imena opisna, ali postaje rizično kada dva agenta izgledaju slično. U tim slučajevima možeš prilagoditi opis kako bi usmjerio rutiranje navođenjem specifičnih scenarija koji bi trebali pokrenuti svaki prijenos.

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

Predaje s kontekstom

Prijenos je koristan samo ako agent koji preuzima zna što se događa. Kada agent izvrši predaju, povijest razgovora prosljeđuje se ciljanom agentu: novi agent ima pristup svemu što je do sada rečeno, pa kupac ne mora ponavljati svoj problem. Uz to, tipizirani kontekst prenosi strukturirane podatke sesije – ID klijenta, pretplaćeni plan, prošle tikete – i ostaje dostupan alatima dolaznog agenta.

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

Obrazac: Triaža na tri razine

Predaje nisu ograničene na horizontalno usmjeravanje. One također repliciraju strukturu eskalacije stvarne službe za podršku. Evo proizvodnog obrasca s tri razine: L1 obrađuje rutinske upite, prosljeđuje napredne probleme konfiguracije na L2, a L2 eskalira teme arhitekture na L3. Imaj na umu da se razina 3 oslanja na sposobniji model jer vidi samo slučajeve koje su već filtrirale dvije prethodne razine.

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

Dvosmjerne predaje

Lanac može biti i kružan: dva agenta mogu međusobno prosljeđivati kontrolu. To je tipično kada potencijalni kupac postavi tehničko pitanje tijekom prodajnog razgovora, a zatim se, jednom uvjeren, vraća na pitanja cijena.

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]

Pazi na beskonačne petlje: preporučuje se zaštitna ograda ili max_turns. Bez ovog ograničenja, dvosmislen zahtjev može odbacivati razgovor od jednog agenta do drugog dok se tvoja kvota ne iscrpi.

Praćenje predaja

Konačno, moraš znati tko je zapravo odgovorio – i za provjeru usmjeravanja i za statistiku podrške. RunResult ti govori koji je agent na kraju proizveo odgovor.

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

Učini navikom bilježenje ove vrijednosti: ako agent za trijažu zadrži kontrolu nad zahtjevima koje je trebao proslijediti, distribucija last_agent otkrit će problem dugo prije povratnih informacija kupaca.

Ključne točke

  • Predaje ti omogućuju delegiranje razgovora specijaliziranom agentu
  • Povijest razgovora prosljeđuje se ciljanom agentu
  • Koristi Handoff(agent=..., description=...) za vođenje rutiranja
  • Dijeljeni kontekst (RunContextWrapper) dostupan je svim agentima
  • result.last_agent.name označava koji je agent konačno odgovorio
  • Zaštiti dvosmjerne predaje s max_turns kako bi spriječio petlje