Lesson 08 — A Triage-and-Handoff Agent

The OpenAI Agents SDK at its sweet spot: one triage front door, three specialists, ~120 lines of Python.

Agents Module 4 OpenAI Agents SDK Handoffs

Why this is the SDK's sweet spot

• Multiple specialist agents sharing a conversation — one triage front door plus three specialists.
• The triage agent picks the right specialist per ticket — routing decision driven by request content, not a hard-coded rule.
• Each specialist has its own small toolset and instructions — hyper-focused prompts, not a megaprompt that tries to be everything.
• Handoffs and guardrails are first-class — exactly what we'd write by hand otherwise, given to us for free.

Hits every condition on L07 Slide 11's “Pick it when” list.

The system we're building

Real example ticket: “My invoice for March is double what I expected and the auto-renewal won't turn off.”

The triage agent reads the ticket once and routes — the work happens inside the specialist that picks it up.

The four agents

The mocked toolset

• Each specialist gets 2 tools, all returning canned strings (mocked) so the lab is reproducible.
• Real integrations (Stripe, PagerDuty, your auth service) belong in production code — the agent shape is what this lesson is teaching.
• All 6 specialist tools are @function_tool-decorated normal Python functions — the same shape Module 2 used.

The triage instructions

You are the front-line triage agent for customer support. Read the ticket
and decide which specialist should handle it:
  - billing / refunds / invoices  -> hand off to Billing.
  - outage / errors / "not working" -> hand off to Technical.
  - login / password / account access -> hand off to Account.
Do NOT try to resolve the ticket yourself. Hand off on the first turn.

Triage's only job is routing. It has zero tools — the only thing it can do is call one of the three synthetic transfer_to_* handoff tools.

The handoff wiring

triage = Agent(
    name="Triage",
    instructions=TRIAGE_INSTRUCTIONS,
    model="gpt-4o-mini",
    handoffs=[billing, technical, account],
    input_guardrails=[block_pii],
)

Three handoff targets become three synthetic tools on triage: transfer_to_billing, transfer_to_technical, transfer_to_account. The LLM picks one per ticket.

The PII input guardrail

• Runs before the model sees the ticket.
• Cheap regex check for SSN / credit-card-shaped strings.
• Tripwire on hit → InputGuardrailTripwireTriggered exception with output_info={"reason": "pii_detected"}.
• Why at the triage layer? Because triage is the entry point — guardrailing here covers all 3 specialists for free.

A real run trace

ticket: "My invoice for March is double what I expected..."
[step 1] agent=Triage     tools=[transfer_to_billing]
[handoff] Triage -> Billing
[step 2] agent=Billing    tools=[lookup_invoice]
[step 3] agent=Billing    tools=[issue_refund]
[step 4] agent=Billing    tools=[]                     (final_output)

Turn 1 is purely a handoff; the work happens in turns 2–4 inside the Billing agent. result.last_agent.name == "Billing".

The Pydantic output type

class Resolution(BaseModel):
    ticket_summary: str
    specialist: str          # 'billing' | 'technical' | 'account'
    actions_taken: list[str]
    follow_up_needed: bool

Applied to each specialist agent via output_type=Resolution. Triage doesn't need one — it just hands off; whichever specialist answers fills in the type.

The last_agent audit trail

• result.last_agent.name tells you who resolved ("Billing" / "Technical" / "Account").
• result.new_items includes HandoffOutputItem records so you can reconstruct the routing decision after the fact.
• In production: ship these to your observability backend; alert on “triage handed off to the wrong specialist” patterns (caught by post-hoc QA on resolved tickets).

Cost and latency profile

• Triage call: ~$0.0005 (one decision, one synthetic tool call).
• Specialist resolution: $0.002–$0.01 typical.
• End-to-end: ~$0.005 / ticket with gpt-4o-mini. ~3–5 second latency.
• Compare: a single-agent Claude SDK build of the same workflow needs the model to mentally hold “I am billing right now” — handoffs let each specialist's instructions be hyper-focused, which empirically reduces per-ticket cost ~20–30%.

What's left to wire (Module 6 hook)

Recap & what's next

• Multi-specialist with shared conversation = SDK sweet spot. One triage + three specialists, all routed via typed handoffs.
• Handoffs are typed tool calls under the hood. Each handoffs=[other] entry compiles to a synthetic transfer_to_<name> tool the LLM picks like any other.
• Guardrails wrap the entry point. One PII check at triage covers every specialist downstream.