Ten voice agent patterns, and how to pick one

Two voice agents can share the same model, the same voice and the same tools, and still behave nothing alike on a real call. One answers in half a second and handles a caller who changes their mind. The other goes silent for four seconds and asks for the phone number twice.

The difference is rarely the prompt. A voice agent pattern is a named way to arrange a phone call between a caller and one or more AI agents. It is the pattern: how the call is arranged. Who is holding the conversation right now, what is running next to it, and what happens before the first word and after the last.

We built this catalogue while designing the copilot inside ShipVoice Pro, which composes agents for agency clients. It names ten patterns, in three families. Each one gets its own post with a diagram, the signals that tell you to use it, what it costs in latency, and how to build it on LiveKit Agents.

What counts as a pattern

A pattern changes how the call flows. Two agents built from the same tools behave differently because of their pattern.

A capability is something any pattern can use. Knowledge retrieval (RAG), caller memory, durable execution with Temporal, preemptive generation and thinking sounds all plug into every pattern, so none of them is one.

The test is simple. If you can add it to every pattern without changing who speaks, when, or who decides, it is a capability. If it changes any of those, it is a pattern.

Family one: who holds the call

At any moment of a call, exactly one of these is in charge. They nest: a Relay agent can itself be a Supervisor, and a Supervisor’s task can be a Guided Path.

1. Solo. One agent holds the whole call with one prompt and every tool.
2. Supervisor. One agent keeps the call and lends it to focused tasks that hand back typed results.
3. Relay. Control passes from agent to agent, and each one owns a phase.
4. Guided Path. The flow fixes the order of steps, and the caller can step back to fix an answer.

Family two: what runs beside the call

On a phone line, silence is the enemy. These patterns add a second line of work next to whoever is speaking. This is where voice agents differ most from chat agents.

5. Observer. A silent model reads the transcript and steers the speaking agent.
6. Talker and Thinker. A fast model answers every turn while a slow one plans.
7. Background Worker. A slow job leaves the turn and its result rejoins the call.
8. Scatter and Gather. One question fans out to several workers and the answers merge.

Family three: where the call begins and ends

These sit at the edges of the live conversation and move work out of it.

9. Bookends. Work that does not need the caller moves before the first word and after the last.
10. Warm Handover. The agent brings in a person, briefs them privately, then steps out.

Putting them together

Real agents rarely use one pattern. A restaurant line might look like this:

• Hold the call with a Supervisor that lends the call to a Guided Path for the order and a task for the delivery address.
• Run beside it an Observer that catches frustration and a missed upsell, and a Background Worker that checks the kitchen’s wait time.
• Wrap the edges with Bookends that recognise a regular before the first ring ends and text a receipt after the call, plus a Warm Handover to the manager for a complaint.
• Attach capabilities where they are needed: the menu as RAG on the order task, caller memory on the Bookends.

That is the order to decide in. Pick how the call is held, add what runs beside it, wrap the edges, then attach capabilities to whichever piece needs them.

Start with Solo

The LiveKit team gives the same advice in their workflows guide. Start with a single agent and a small set of tools. Split only when you hit a concrete limit. A prompt that keeps growing, phases that need different tools, multi-turn data collection, or callers who need to go back and fix something. Each of those signals points to one pattern in this catalogue, and the posts tell you which.