To Flow or Not to Flow, That Is the Question

You've seen the demo. Someone drags a few boxes onto a canvas, joins them with arrows, and a phone agent answers a call, asks a question, checks a calendar, books a job. It looks like the whole product. It looks great in a deck.

Then a plumber rings in halfway through and says "yeah nah, can you just get someone out to the leak on Tuesday, and while you've got me, the invoice from last month's wrong" — three things at once, none of them on the arrows — and the agent has nowhere to go.

That gap, between how a flow builder demos and how it behaves on a real call, is worth understanding before you build a business on one. We build flows ourselves, so this isn't a pitch against them. It's a note on when they're the right tool and when they turn into the thing you spend your weekends patching to fix the last call made.

Flows are the standard now — that's the easy part

Visual builders are how voice AI products look in 2026. Retell is built around a conversation-flow canvas of nodes and transitions, with separate node types for lines that must be said word-for-word versus lines the AI improvises. Voiceflow, Synthflow and a pile of open-source tools all ship the same drag-and-drop idea. If someone tells you every platform has a flow builder now, they're right.

Which is exactly the problem. When everyone ships the same thing, that thing stops being what sets you apart. It's the cost of getting in the door, not the reason anyone picks your service.

The bit nobody's saying out loud

Watch what the big platforms have actually done lately, because it's the opposite of "flows are taking over":

• Vapi killed its visual builder. As of 18 August 2026, its Workflows don't run anymore and you can't make new ones. It now points you at code-first setups instead. A market leader looked at the pure drag-and-drop graph and pulled it.
• Retell added a hybrid. Its "Flex Mode" bolts single-prompt flexibility onto the node graph — the best of both, in their words. You don't build that if the graph on its own was doing the job.
• Their own reviews name the wall: you outgrow a fixed node graph the second you're building a conversation it can't draw cleanly.

So flows didn't win. The industry shipped them, hit the ceiling, and started moving toward something else: a rigid frame around a flexible middle. Firm where it has to be, loose where it should be.

It was never flow versus prompt. It's a fixed frame around an adaptive conversation.

Where the graph fights you

The issue isn't that node graphs are rigid. Rigid is good when you need it. The issue is that most calls aren't flowcharts, and three things go wrong when you force them to be — none of which show up in a demo.

Compliance isn't optional. On any real call, two things have to happen no matter what: the recording disclosure gets said, and "take me off your list" stops the call and suppresses that number — from any point in the conversation, mid-sentence, three steps deep. Here that matters more than most places: the Privacy Act 2020 and the unsolicited-electronic-messages rules aren't optional, and a "please don't call again" that gets ignored is the kind of thing that ends up in front of the Privacy Commissioner. If those live as nodes on a canvas a customer can edit, someone will eventually draw a path that skips them. A builder that lets you ship a flow with no opt-out isn't a productivity tool. It's a complaint waiting to happen.

The write has to actually land. A node that says "log the job in the CRM" is trusting the model to fill every field right and fire it off. In a demo, where the tester speaks clearly and says the expected thing, it works every time. On real calls, in real accents, the model occasionally maps a field wrong or the write half-finishes, and nothing notices — because the graph trusted the node. A tidy canvas over a write that silently fails is worse than no canvas, because the person who drew it thinks it's working.

Some of the work happens before the conversation starts. Recognising a caller from their number — so the agent already knows it's Dave from the panelbeater's before it says a word — has to happen the instant the call connects, not as a step in the middle. A graph of the call has no natural spot for work that comes before the call. Make it a node and the caller hears the silence while the lookup runs. The fix lives outside the canvas — and once it does, the canvas isn't really the system anymore.

None of this is an argument against determinism. It's an argument for putting it in the right place: wrapped around the call as a frame that can't be edited away, not dropped inside it as boxes a customer can shuffle.

What we found building our own

We're saying this because we did it. We built a flow engine, put a real customer's first live calls through it, and watched people struggle to draw a normal conversation as a diagram. Callers don't follow arrows. Someone answers a question with a question, or rattles off three things at once, and you're back adding another branch, and another, until the diagram is doing a clumsy impression of a language model.

So we flipped the default. The key design choice was to stop treating the conversation as either a diagram or a single ubiquitous prompt, and build it out of skills instead. A skill is a self-contained unit of a job the agent can do — take a booking, log an enquiry, answer from a knowledge base, qualify a lead — each with its own idea of what it needs to collect and what to do once it has it. The agent picks up and sequences them itself as the call unfolds, the way a good receptionist moves between tasks without a script telling them which door to walk through next.

Around that, a fixed frame: the opening and its disclosures are pinned and come out the same every time; an always-on shield honours opt-out from any turn and can't be edited off; and in between, the skills do the work — the model listens, picks the right one, collects what it needs, confirms before it acts. Firm at the edges, flexible in the middle. Skills are what make the middle flexible without it turning into an unmanageable sprawl of branches — something that flows inevitably lead to. It is the same place Retell landed with Flex Mode and Vapi landed by walking away from Workflows. We just got there with our own testing in New Zealand first.

We didn't kill our flow engine — we right-sized it

Don't read "the graph fights you" as "never use a graph." Once skills carry the everyday calls, what's left is a real slice where a guaranteed path is the entire point — and for those, a flow is exactly what you want:

• Outbound campaigns — every call opens with the same pinned line and disclosures, follows a known shape, and can be reconstructed afterwards if anyone asks how a call went. Order matters for these calls.
• Structured inbound assistants that follow a set process — where a step genuinely has to gate the next one, and "the model decided to skip ahead" isn't acceptable.

For these call scenarios we developed dareena flow. It's a deliberate tool for the calls that need a fixed path — not the front door to every agent. Skills are what let it be that narrow: because they handle the everyday calls on their own, the flow engine doesn't have to stretch to cover conversations it was never suited to. (We wrote more about how skills work in Diverse Skills, One Prompt.)

Flows aren't dead. They're a 10% tool, not a 90% one — and knowing which 10% is the whole job.

If you're weighing up build versus buy

If you're an MSP, telco or software shop deciding whether to build a voice AI product or resell one, the flow question is a handy way to see where the easy part stops.

The canvas is the easy part. It stands up fast — React Flow gives you the drag-and-drop graph almost for free, a runtime like LiveKit or Pipecat handles the brutal real-time audio for you, and the model makes the transitions feel clever. You can have the demo done in a couple of days. But that demo is the commodity: it's what the big platforms already give away on their self-serve plans, telephony thrown in.

The hard part is everything the canvas sits on and doesn't give you: the frame that makes compliance unbreakable, the layer that makes a CRM write reliable, the caller lookups that make the agent sound like it already knows you, the billing that rates a minute right in NZD, the NZ carrier and number handling, an accent that doesn't make your customers wince, and the multi-tenant plumbing that lets you sell it under your own brand. That's the part that takes real time — and it's there whether you drew a flowchart or not.

So "should we build our own flow builder?" is usually the wrong question. The builder isn't what wins you the customer. What's underneath it is. Own that layer and a flow is a feature you add for the 10% of calls that need it. Skip it, and a lovely canvas over a shaky base is the fastest way to ship a demo that can't grow into a service.

The short version

Flows are the standard, and the big platforms are already moving past flow-as-everything toward a frame-around-conversation shape. The graph earns its keep when a guaranteed path is the value — outbound campaigns, audited structured assistants — and gets in the way the rest of the time. The design choice that makes that split work is skills: composable units of work the agent sequences itself, carrying the adaptive majority inside a fixed compliance frame. That's our default. dareena flow is the deliberately-scoped tool for the 10% that genuinely needs the rails.

To flow or not to flow isn't yes or no. You answer it one call type at a time — and answering it well is most of the craft.