Relay: hand the call from agent to agent

The Relay pattern hands a voice call from one agent to the next, and each agent owns one phase. In a Relay, the call is a baton. A front desk agent answers and works out what the caller needs, then hands the call to an order taker. When the order is done, the order taker hands it to a payments agent. Each agent owns one phase completely, and once it hands off, it is gone.

This is the pattern for when phases are genuinely different jobs, not just different questions.

Use it when

• Phases need hard boundaries. The payments agent is the only one with card tools. The order taker cannot issue a refund because it does not have the tool, not because a prompt told it not to.
• Phases need a different model or voice. A fast, cheap model for routing. A stronger model for a tricky diagnosis. A different voice for the billing desk so the caller notices the change of department.
• Phases are long and self-contained. A twenty-minute technical support session has little reason to keep the front desk’s routing rules in context.

Avoid it when

Callers jump between topics. Every jump is a handoff, and handing back and forth costs time and makes the call feel like a phone tree. If the first agent should still be around after the phase ends, you want a Supervisor.

Latency

One handoff per transition, plus whatever it costs to prepare context for the next agent. You have three choices for that context, and they trade speed for continuity:

• Pass the full history. The next agent knows everything. Slowest to start and most tokens per turn.
• Pass a summary. One extra model call at handoff time, then a lean context.
• Pass nothing. Fastest, and the right call when the next phase genuinely does not need the past, like a satisfaction survey.

Build it on LiveKit

A handoff is a function tool that returns the next agent. Returning a tuple lets the current agent say something on the way out.

from livekit.agents import Agent, RunContext, function_tool


class Payments(Agent):
    def __init__(self, chat_ctx=None) -> None:
        super().__init__(
            instructions="Take payment for the confirmed order. Read back the total first.",
            chat_ctx=chat_ctx,
            tools=[charge_card, send_receipt],
        )


class OrderTaker(Agent):
    def __init__(self, chat_ctx=None) -> None:
        super().__init__(instructions="Take the food order. Confirm each item.", chat_ctx=chat_ctx)

    @function_tool()
    async def order_complete(self, ctx: RunContext):
        """Call when the caller has confirmed the full order."""
        return Payments(chat_ctx=self.chat_ctx), "Great, let me take payment for that."

LiveKit’s agents and handoffs guide covers context preservation in detail.

How it combines

Each agent in a Relay can use any other holding pattern inside its phase. A common production shape is a Supervisor at the front that hands off to a dedicated payments agent at the end. Pair the whole Relay with Bookends so the summary and CRM sync see every phase, not just the last one.