Skip to content

Bananaflow MCP is live.

Read the docs

Call Flow Design: Diagrams for AI Voice Agents

Jaseem Abbas, founder of Bananaflow, in glasses and a dark top against a pale background.Jaseem Abbas

Published
Cover for "Call Flow Design: Diagrams for AI Voice Agents": a white isometric line diagram of a call flow where every path ends: a lit puck, the call starting, runs into one stage block, and from it a bold main path and two branches run on to three lit slabs, each with a check standing over it, beside a lit pill reading Every path ends, drawn over a soft, out-of-focus bellflower in muted aqua, its open bells blurred into veils, with a sky blue haze at one end and a dusty rose glow at the other.

A call flow diagram is a map of every stage, branch and exit a phone call can take, from the first ring to the last line. This guide shows how to design one for an AI voice agent, how it differs from an IVR menu tree, and how to draw the same call both ways. It covers business call flows, not telecom signalling diagrams (SIP, GSM).

Here is why the drawing matters. Meera in Nagpur calls a diagnostic lab to book a home sample collection for her father: a fasting blood sugar test, Saturday at 8 am. The old phone line asks her to press 2 for Marathi, then 1 for booking, then to key in her PIN code. It says "invalid entry", so she tries again, gets the same answer, and presses 0 into a queue. That is four key presses before she has said a word about what she wants. With an AI voice agent she says one sentence, and the agent books the slot. The lab, its numbers and its callers in this post are an example we made up. They are not customer data.

What is a call flow?

A call flow is the planned path a call follows, written down as a diagram. Designing it is part of conversation design.

Under the drawing sits a simple idea. The World Wide Web Consortium (W3C) defines SCXML as "a general-purpose event-based state machine language that combines concepts from CCXML and Harel State Tables", and CCXML was designed for call control in voice applications (W3C SCXML). In plain words, the call is in one state, an event happens (the caller answers, goes quiet, asks for a person), and a rule picks the next state.

The parts are the same for a menu or an agent: a start, stages, decisions, actions such as a lookup, a handoff to a person, and an end with an outcome code.

How is an IVR call flow different from an AI voice agent flow?

An IVR flow is a tree of menus where each key press picks a branch. An agent flow is a short chain of stages where the caller's own words, and your move rules, pick the next stage. The caller of an IVR fits the request to the menu. The caller of an agent just says it. If you are still choosing between the two, our guide to IVR versus voicebots covers which one suits your calls. This section covers only how each one is drawn.

Here is the Nagpur lab's home-collection line drawn both ways.

The Nagpur lab booking line drawn twice: as an IVR menu tree with numbered options and sub-menus, and as AI agent stages with move rules, a fallback and a handoff to staff.

The IVR version is the old system. It asks for a language (1 Hindi, 2 Marathi, 3 English), then shows a main menu (1 book a home collection, 2 report status, 3 test prices, 0 talk to us). The booking branch asks for a PIN code on the keypad. After two invalid entries it drops the caller into the queue. Count the levels: a caller who wants a Saturday morning slot presses at least four times first.

The agent version has no menu. It greets the caller, finds out what they need, and moves to the stage that handles it. The table shows what changes in the drawing (our own comparison).

  • In an IVR drawing: Menu node

    In an agent drawing
    Stage
    What changes for the designer
    A stage has one job and a set of exits, not a list of options to read out
  • In an IVR drawing: Key press or fixed word

    In an agent drawing
    Move rule in plain words
    What changes for the designer
    You write the condition, such as "the caller wants to book a home collection"
  • In an IVR drawing: "Invalid entry, please try again"

    In an agent drawing
    Fallback that rephrases
    What changes for the designer
    The agent asks the question another way and then offers a different route
  • In an IVR drawing: Depth: levels of sub-menus

    In an agent drawing
    Breadth: side requests handled in place
    What changes for the designer
    A price question inside the booking stage is answered, then the call returns to booking
  • In an IVR drawing: Business-hours check at the top

    In an agent drawing
    Business-hours check at the top
    What changes for the designer
    Same in both. Your phone system or carrier decides who answers outside hours
  • In an IVR drawing: Press 0 for an agent

    In an agent drawing
    Handoff rule
    What changes for the designer
    You decide when a person is needed, not when the caller finds the right key

What is a menu, and how big should it be?

The W3C's VoiceXML 2.0 recommendation defines a menu as "a convenient syntactic shorthand for a form containing a single anonymous field that prompts the user to make a choice and transitions to different places based on that choice". It also defines a nomatch event for low recognition confidence (W3C VoiceXML 2.0). A "no match" is the IVR's word for a fallback.

If you do keep a menu anywhere in your flow, the Nielsen Norman Group's guidelines for phone-tree systems give the clearest rules (NN/g: The UX of Phone-Tree Systems):

  • Limit each menu and submenu to 4 or 5 choices, and make them distinct. Their bad example is a government menu that used the word "tax" in 5 of its 9 first-level options.
  • Use the same keys for "repeat" and "go back", and let callers choose before the menu finishes.
  • Say the task first, then the number: "for refunds, press 2".

For the words an IVR plays, see our guide to call center scripts and our IVR script examples in English and Hindi. For a short definition, see the glossary entry for IVR.

What are the 6 steps of the call flow process?

There are six steps: set the goal, split the call into stages, write the move rules, plan the fallbacks, decide the handoff, and design the ending. This is the method we use, and the order matters because each step gives the next one something to work on. There is no industry standard for the steps of a call flow, and the vendor lists you will find online differ.

The six design steps in order: goal, stages, move rules, fallbacks, handoff and ending.
  1. Goal: pick one call and one result, and list every way it can end.
  2. Stages: split the call into the fewest stages that each have one job.
  3. Move rules: write, in plain words, what moves the call from each stage to the next.
  4. Fallbacks: decide what happens on silence, an unclear answer or a failed lookup.
  5. Handoff: decide when a person takes over and what happens if they cannot.
  6. Ending: close every path with a last line and an outcome code.

The vocabulary comes from our voice agent prompt guide: a stage is one part of the call, and a move rule says when the call goes to the next stage. This post is about the shape of the call. The words inside each stage are in the prompt guide.

Step 1: What is the goal, and how can the call end?

The goal is one call with one result, plus the full list of ways it can end. For the Nagpur lab, the call is "inbound home-collection line", and the result is "a booked slot". The other endings are a report status given, a price given, a callback, a transfer to staff, and a wrong number. Write all of them down first, because each one will become an outcome code. Our guide to call disposition codes has a ready list to start from.

If you have not yet chosen the call, do that first. Step 1 of our build guide is about picking one call and one outcome.

Common mistake: a goal that is really three goals, such as "handle all calls to the lab". Start with booking, and add the rest once it works.

Step 2: How do you split the call into stages?

Split the call into the fewest stages that each have one job. Typical jobs are: greet, understand the need, do the task, read back, and close. A stage that needs two jobs is really two stages. A stage that only says one sentence usually belongs inside its neighbour.

The Nagpur lab has six: greet and find the need, book, report, price, handoff and end. The caller says what they need in their own language, and the agent follows it. The full list is in the text version below.

Rules every stage needs, such as language, no medical advice and one question at a time, go in the shared prompt, once. The prompt guide explains where each rule lives, so this post does not repeat it.

Common mistake: one giant stage that tries to do the whole call, or ten tiny stages that hand the call over in the middle of a sentence.

Step 3: What are the move rules between stages?

A move rule is a condition in plain words that moves the call from one stage to the next. Write one for every exit from every stage, and check two things: each stage has at least one exit, and no two rules from the same stage can both be true at once.

From "Greet and find the need" in the Nagpur flow:

  • "The caller wants to book a home collection" moves to Book.
  • "The caller asks about a report" moves to Report, and a price question moves to Price.
  • "The caller asks for a person, raises a medical question, or complains" moves to Handoff.

Side requests are where an agent flow beats a menu. If the caller asks "what does the sugar test cost?" in the middle of booking, the Book stage answers it from the price list and carries on. The prompt guide defines the move rule and shows how to word one.

Common mistake: two rules that can both be true, such as "the caller wants to book" and "the caller is ready to pay". The agent then picks one, and not always the same one. Make rules about different things, and put the most specific one first.

Step 4: What are the fallbacks?

A fallback is what the call does when the normal path fails. Plan one for silence, an answer the agent did not understand, a tool that fails, and the third failed try. The agent-flow version of "invalid entry, try again" is a fallback that changes something: it rephrases the question, then offers a different route, and only then gives up gracefully. Where the call goes after that is call routing: to a person, a queue or another agent.

For the Nagpur lab the rule is two rephrased tries, then an offer of a callback. If the calendar tool fails, the agent says it cannot see the slots right now and offers a callback, and it never invents a time.

The words for silence and unclear answers are in the prompt guide's section on how to handle silence, unclear answers and endings. This step is only about deciding where each failure goes on the map.

Common mistake: no fallback after the second unclear answer, so the agent loops on the same question.

Step 5: When does a person take over?

Decide three things: when the call goes to a person, what that person is told, and what happens when the transfer cannot be done. Our guide to warm versus cold transfers explains the options.

Check the carrier first. Transfer to a person works on Twilio, Plivo, Telnyx, Cloudonix and Asterisk, and the call transfer glossary entry explains what a transfer is. If your carrier is not one of those, or nobody picks up, the flow needs a different exit: take the caller's name and number, say when someone will call back, and end with a callback code.

Common mistake: a handoff with no plan B, so the caller waits on a line nobody answers.

Step 6: How should every path end?

Every path ends on a closing line and an outcome code. No path just stops. For the lab, the Book stage ends with a read-back, then "Your sample will be collected on Saturday at 8 am. Anything else?", then a goodbye, and the code is "booked".

This is where step 1 pays off. Each ending on the diagram should map to a code in your list, so reports never show "unknown". See call disposition codes for how to name them.

Common mistake: a path with no code, or one code shared by two endings, so a manager cannot tell a booked call from a dropped one.

What does a call flow look like for an Indian business?

Here is the Nagpur lab flow in full, as plain text. The lab and its numbers are made up, and the stage names are ours. Copy it, rename the stages for your own business, and use it as the first draft of your diagram. It names the tools each stage needs: a calendar lookup and booking in Book, a booking lookup in Report, an attached price list in Price, and transfer to a person in Handoff.

FLOW: Home-collection line (inbound)
GLOBAL RULES (shared prompt): follow the caller's language; no medical advice; one question at a time

1. GREET AND FIND THE NEED
   -> wants to book           => 2. BOOK
   -> asks about a report     => 3. REPORT
   -> asks a test price       => 4. PRICE
   -> asks for a person, medical question, complaint => 5. HANDOFF
   FALLBACK: two rephrased tries, then offer a callback => 6. END (callback)

2. BOOK (area, test, slot, read back)
   -> booked                  => 6. END (booked)
   -> changes their mind      => 6. END (not booked)
   -> asks a price            => answer, stay in BOOK
   FALLBACK: slot taken, offer next two; calendar down, offer a callback

3. REPORT (look up by booking number)
   -> status given            => 6. END (report given)
   FALLBACK: not found after one retry => 5. HANDOFF

4. PRICE (from the price list)
   -> price given             => 6. END (price given)
   -> wants to book           => 2. BOOK
   FALLBACK: not in the list => 5. HANDOFF

5. HANDOFF (to staff)
   -> person picks up         => 6. END (transferred)
   FALLBACK: no pickup or no carrier support, take name and number => 6. END (callback)

6. END: closing line, then outcome code

Count the exits. Every stage has at least one, every path reaches stage 6, and stage 6 always sets an outcome code. That is the check from step 3 and step 6, done on paper.

What does an outbound call flow look like?

Here is a shorter example, for an outbound call. A Surat apparel brand calls buyers to confirm cash on delivery (COD) orders. The stages are: check that a person answered, check it is the buyer, confirm the order and address, and close. The ending codes are confirmed, cancelled, address changed and callback.

Outbound adds a step at the very start that an inbound flow does not have: the call may have reached voicemail or an automated menu, not a person. That is a status of the call, so the flow ends it before the agent starts talking. Bananaflow detects voicemail and IVR before the agent speaks, as described on our telephony page. The wrong-person case needs its own exit, so no order details are read to a stranger. Our guide to COD order confirmation calls has the script, so this post does not repeat it.

Where Bananaflow fits

Bananaflow is an AI voice agent platform with a visual workflow builder. A flow is a set of nodes (Start Call, Agent, Global, End Call, QA, API trigger and webhook) joined by transitions that you write in plain words, and a transition can loop back to an earlier step. Each Agent node has its own objective, tools and knowledge base files, and a Global node sets the persona and tone once. That maps to the drawing in this post: an Agent node is a stage, a transition is a move rule, and the Global node holds the shared rules.

Build with AI can draft the nodes, prompts, transitions and tools from a plain description, and you can test by voice or text in the browser, with the active node highlighted. Drafts, published versions and a side-by-side diff keep live edits safe. See the workflow builder page for the details.

The IVR tree in this post is the old system, drawn for comparison. The agent flow in Bananaflow, which also works as an AI IVR, runs on what the caller says, and the business-hours check at the top of your call sits in your own phone setup.

What mistakes break a call flow?

Most broken flows break in the same eight ways, each cheap to fix on paper and costly after launch.

  • A menu with more than 4 or 5 options, or options that sound alike. This is the Nielsen Norman Group's guidance.
  • A stage with no exit, or two move rules that can both be true.
  • One giant stage, or ten tiny ones that hand off mid-sentence.
  • No fallback after the second unclear answer, so the agent loops.
  • A "talk to a person" branch the carrier cannot do, and no callback fallback.
  • An ending with no outcome code, so reports show "unknown".
  • No after-hours path, so a handoff has nobody to take it.
  • Editing the live flow instead of a draft, so a half-finished change takes real calls.

How do you test a call flow before it goes live?

Walk every exit between stages once, first by text and then by voice, then probe behaviour inside each stage. The diagram is your checklist. In the Nagpur flow that is every arrow in the text version above.

Walking the exits proves the shape is right. It does not prove the agent behaves well inside a stage, with accents, noise, interruptions and tricky numbers. For that, use our guide to how to test a voice agent, which has the test matrix, the case format and the scoring. Walk every exit between stages, then probe behaviour inside each stage, as the test guide explains.

What should you remember about call flow design?

  • Goal first: one call, one result, and every way it can end.
  • Stages with one job each, with shared rules in the shared prompt.
  • Move rules in plain words, with at least one exit per stage and no two that can both be true.
  • Fallbacks that change something, and a handoff with a plan B.
  • Every path ends on a closing line and an outcome code.
  • Test by walking every exit, then probe each stage as the test guide explains.

Start this week with your simplest call: write the goal and its endings, draw 4 to 6 stages, write the move rules, and walk each exit once.

FAQ

Frequently asked questions

  • What is a call flow diagram?

    A call flow diagram is a map of every stage, branch and exit a phone call can take, from the first ring to the last line. It shows what the caller hears, what decides the next step, where a person takes over and how the call ends. This answer covers business call flows, not telecom signalling diagrams such as SIP or GSM.

  • What are the steps of a call flow?

    There is no standard list. Our own method has six steps: set the goal and the outcome codes, split the call into stages, write the move rules between stages, plan the fallbacks, decide the handoff to a person, and design the ending. Draw them in that order and every stage ends up with an exit.

  • How many options should an IVR menu have?

    Four to five choices per menu and submenu, and each one should sound clearly different from the others. That is the guidance in the Nielsen Norman Group's usability guidelines for phone-tree systems. The same guidelines say to name the task first and the key second, as in "for refunds, press 2".

  • What is the difference between an IVR flow and a call flow?

    Every IVR has a call flow, but not every call flow is an IVR. An IVR flow is a tree of menus where the caller presses keys or says fixed words. A call flow is the wider idea: any map of how a call moves, including an AI voice agent that moves between stages on rules written in plain words.

  • Can an AI voice agent follow a fixed call flow?

    Yes. You draw the call as a few stages, give each stage one job, and write a move rule for every exit. Inside a stage the agent talks freely and handles side questions. Between stages it follows your rules, so the shape of the call stays fixed while the words do not.

  • Does an AI voice agent use press 1 menus?

    A voice agent does not need them. The caller says what they want, and the agent matches it to a stage. The flow is drawn with move rules, such as "the caller wants to book a home collection", instead of key presses. A press-1 menu belongs to the older IVR drawing.

  • What tool do you use to draw a call flow?

    Any diagram tool works for planning, even paper. The useful test is the drawing itself: every stage has a name, a job and at least one exit, and every path ends in an outcome code. A workflow builder is the better choice when the drawing is the thing that runs the call, because it cannot drift from what the agent does.

  • How many stages should a voice agent flow have?

    As few as will give each stage one job. Our Nagpur lab example uses six, including the handoff and the ending. A stage that needs two jobs is two stages, and a stage that only says one sentence usually belongs inside its neighbour. This is our advice, not a standard.

Written by

  • Jaseem Abbas, founder of Bananaflow, in glasses and a dark top against a pale background.

    Jaseem Abbas

    Founder, Bananaflow

    Jaseem founded Bananaflow to build voice AI that understands how people in India really speak, including the switch between languages in the middle of a call.

Similar articles

Bring us one process. We'll pilot it on your real calls, with your team as the fallback.

Plan a pilot