The vendors fighting over whether AI support should run on decision trees or open-ended reasoning are asking the wrong question. The right answer is both, in the same conversation, with the handoff invisible to the customer.
A deterministic workflow is a fixed if-then path the AI must follow step by step. A natural-language workflow is an instruction set the AI interprets and executes with its own reasoning. Deterministic flows win where a wrong step is a compliance or safety failure (identity verification, KYC, refunds above a threshold). Natural-language flows win where the customer's problem is open-ended and the right next step depends on context. The platforms that resolve the most regulated tickets in 2026 combine both inside a single interaction.
Use deterministic if-then workflows when the path is legally or financially load-bearing: identity checks, KYC, disclosures, dollar-threshold approvals, account closures.
Use natural-language agentic loops when the problem is open-ended: troubleshooting, multi-issue tickets, and anything where the next step depends on what the customer just said.
The failure mode of pure decision trees is brittleness. The failure mode of pure natural-language agents is unpredictability on the steps where being wrong is expensive.
The combined model hands the high-stakes sub-task to a deterministic flow and lets the agent reason around it, so one conversation gets both reliability and flexibility.
Lorikeet supports both natural-language workflows and deterministic structured workflows, combinable in one interaction, with all configuration written in plain English.
Last updated: June 2026
For most of the last decade, automated support meant decision trees. A customer picked from a menu, the bot followed a branch, and when the branch ran out the bot apologized and routed to a human. Large language models broke that model open. An agent can now read a messy, multi-part question and reason its way to an answer without a pre-drawn path. The reaction in some quarters has been to throw out structured flows entirely and let the model handle everything. That is an overcorrection. In a regulated business, there are steps where you do not want the model improvising, and steps where forcing it down a fixed path makes it worse. Knowing which is which is the whole skill. This guide explains the two workflow types, when each is the right tool, why the strongest deployments use both in a single conversation, and how that looks in practice.
What Is a Deterministic Workflow?
A deterministic workflow is a predefined sequence of steps and branches that the AI executes in a fixed order. Given the same inputs, it produces the same path every time. Think of it as a flowchart the agent is required to walk: check the customer's identity, if verified then proceed, if not then ask for a second factor, if that fails then escalate. The logic is explicit, inspectable, and repeatable.
The value of determinism is not that it is smart. It is that it is predictable. When a step is legally or financially load-bearing, predictable beats clever. If your KYC unlock flow must collect three specific identifiers in a specific order and refuse to proceed without them, you do not want a model deciding on the fly that two out of three is probably fine. You want the flow to enforce the rule, every time, in a way your compliance team can read before launch and an auditor can replay after.
Deterministic workflow: A fixed if-then-else path the AI is required to follow step by step, producing the same sequence of actions for the same inputs. Used for steps where a deviation is a compliance, safety, or financial failure.
In Lorikeet, these are called structured workflows. They are built as a graph of nodes and edges, each node a step or decision, configured in plain English rather than code. A structured workflow is the right home for the parts of a conversation where the business has a non-negotiable procedure: an identity check before any account change, a scripted disclosure before a financial action, a dollar-threshold block that requires human approval above a set amount.
What Is a Natural-Language Workflow?
A natural-language workflow is a set of instructions, written in plain language, that the AI interprets and carries out using its own reasoning. Instead of drawing every branch, you describe the goal, the constraints, the tools available, and the judgment calls, and the agent decides how to get there. Given the same inputs, it may take different but equally valid paths, the way a well-trained human agent would.
The value here is flexibility. Most real support tickets are not clean. A customer writes in about a failed transfer, mentions in passing that their card also got declined, and asks whether their address change went through. A decision tree built for failed transfers cannot gracefully handle the other two issues. A natural-language agent can read all three, prioritize, resolve what it can, and ask clarifying questions where it cannot. It adapts to the conversation instead of forcing the conversation into a predrawn shape.
Natural-language workflow: A plain-language instruction set the AI interprets and executes with its own reasoning and tool use, adapting the path to the specifics of each conversation rather than following a fixed branch structure.
In Lorikeet, these are called natural-language workflows, and like structured workflows they are configured in plain English. The agent reads the instructions, decides which tools to call and in what order, and reasons about edge cases the author never explicitly enumerated. This is what lets a single workflow handle the long tail of phrasings and combinations that a decision tree would need hundreds of branches to cover.
When to Use Deterministic If-Then Flows
Reach for a deterministic flow when the cost of a wrong step is high and the correct path is known in advance. The test is simple: if a compliance lead would need to sign off on the exact sequence before you ship, it belongs in a structured workflow.
Identity Verification and Authentication
Before the agent touches an account, it has to know who it is talking to. The verification sequence (what to ask, in what order, what counts as a pass, when to step up to a second factor, when to lock out) is a rule, not a judgment call. Encoding it as a deterministic flow means the agent cannot be talked out of a check by a persuasive or impatient customer, and the same standard applies on the easy tickets and the hard ones.
KYC and Regulated Onboarding
Know-your-customer steps exist because a regulator requires them. The set of documents, the order of collection, the disclosures that must be read, and the conditions under which an account can proceed are prescribed. A deterministic flow enforces the prescription. It also produces a clean record of exactly which steps ran, which is what you hand an examiner when they ask how a given account cleared onboarding.
High-Stakes and High-Dollar Actions
Refunds above a threshold, account closures, wire confirmations, and anything that moves real money or ends a relationship should run through a fixed path with explicit gates. A dollar-threshold block that requires human approval above a set amount is a deterministic rule. So is a scripted disclosure that must be delivered verbatim before a financial action. These are the steps where being clever is a liability and being predictable is the point.
Mandatory Disclosures and Scripted Language
When regulation or legal requires specific wording (a fee disclosure, a recording notice, a rights notification), the agent should not paraphrase it. A deterministic step that emits the exact approved language removes the risk of the model rewording something that is not supposed to be reworded.
When to Use Natural-Language Agentic Loops
Reach for a natural-language workflow when the problem is open-ended and the right next step depends on context the author cannot fully predict. The test: if you would struggle to draw the full flowchart because the branches are effectively unbounded, let the agent reason.
Troubleshooting and Diagnosis
Diagnosing why something is not working is inherently branching and context-dependent. The agent needs to form a hypothesis, check it, and adjust based on what it finds. A natural-language loop lets it investigate (read the account state, check recent transactions, look at error logs through a tool) and narrow toward the cause, rather than marching through a fixed checklist that may not match the actual problem.
Multi-Issue and Ambiguous Tickets
Real customers raise several things at once and rarely in a tidy order. A natural-language agent can parse a message that contains three problems and a question, decide what to handle first, resolve the parts it can, and ask a targeted clarifying question on the part it cannot. Forcing that into a single-issue decision tree produces the familiar failure where the bot fixates on one keyword and ignores the rest.
Long-Tail Questions and Edge Cases
There is a long tail of questions that are individually rare and collectively common. Building a deterministic branch for each is impractical. A natural-language workflow grounded in your knowledge base and tools handles the tail without an author having to anticipate every phrasing in advance.
Conversational Recovery
When a customer pushes back, corrects themselves, or changes their mind mid-conversation, a rigid flow has nowhere to go. A reasoning agent can absorb the new information and re-plan. This is the everyday flexibility that makes an AI feel like a competent agent rather than a phone tree.
Why Combining Both in One Interaction Wins
The argument framed as deterministic versus natural-language is a false choice. The strongest deployments do not pick one. They let a natural-language agent run the conversation and hand off the load-bearing sub-tasks to deterministic flows, then take the conversation back. The customer experiences one continuous interaction. Underneath, each part runs on the model best suited to it.
Consider a single ticket. A customer messages that their account is locked, they think their card was used fraudulently, and they want to know if their last payment went through. A natural-language agent reads all three concerns and sequences them. To unlock the account it needs to verify identity, so it invokes a deterministic identity-verification workflow that enforces the exact required checks. With identity confirmed, it reasons through the fraud concern, checks recent transactions through a tool, and finds the suspicious charge. To dispute it, it triggers a deterministic dispute-filing flow with the scripted disclosures and the dollar-threshold gate. Then it answers the payment question conversationally. One interaction, two deterministic sub-flows, continuous natural-language reasoning around them.
This is the structure that gets you both properties at once. The high-stakes steps are predictable, inspectable, and approvable by compliance before launch. The open-ended parts are flexible enough to handle the mess of real tickets. Neither pure approach delivers both. A pure decision tree cannot handle the multi-issue framing. A pure natural-language agent can handle the framing but you cannot guarantee it runs the identity check the same way every time, which is exactly the guarantee a regulated business needs.
There is a control benefit too. When the model is wrapped around deterministic flows for the dangerous steps, the surface area where an error becomes a compliance problem shrinks dramatically. The agent is free to reason where reasoning is safe and constrained where it is not. That is a more honest design than either extreme, because it matches the tool to the risk of each step rather than betting the whole system on one paradigm.
How to Decide Which Steps Get a Deterministic Flow
The design work is drawing the line between the two. A useful way to do it is to walk a real ticket and label each step by what a wrong move would cost. Steps where an error is a refund, a routing mistake, or a slightly clumsy answer can sit in the natural-language layer, because the agent recovering on the next turn is fine. Steps where an error is a disclosed-incorrectly notice, a missed identity check, or money moved without approval belong in a deterministic flow, because there is no acceptable margin for the agent improvising. The question is not "is this step important" but "if the agent gets this wrong once in a thousand times, is that a problem we can live with." If the honest answer is no, make it deterministic.
A second cut is auditability. Some steps you will be asked to account for later (which documents were collected, which disclosure was read, who approved a high-dollar action). Putting those in a deterministic flow gives you a clean, replayable record of exactly what ran, which is far easier to defend than reconstructing intent from a free-form reasoning trace. Steps no one will ever audit can stay in the flexible layer.
Keeping the Handoff Invisible to the Customer
The combined model only works if the customer never feels the seam. A handoff from reasoning to a deterministic flow should not read like the agent suddenly turned into a form. The natural-language layer carries the context into the deterministic step and back out, so the customer is not asked to repeat information the agent already has, and the conversation keeps its tone across the boundary. Done well, the structure is invisible: the customer experiences one capable agent, while underneath the system is quietly running a fixed procedure for the part that needs one and reasoning freely for the rest.
How Lorikeet Combines Deterministic and Natural-Language Workflows
Lorikeet is an AI customer support platform built for complex and regulated companies (fintechs, financial services, healthtech, insurance, gaming) where being wrong on the hard tickets carries real cost. It supports both workflow types and is designed for them to run together in one conversation.
Structured workflows are Lorikeet's deterministic flows: a graph of nodes and edges that enforce a fixed path for the steps that need one (identity verification, KYC, dollar-threshold approvals, scripted disclosures). They are built and edited in plain English, not code, and changes go through a draft-then-publish step so a reviewer can read the procedure before it goes live.
Natural-language workflows are the reasoning layer: plain-language instructions the agent interprets to handle open-ended problems, multi-issue tickets, troubleshooting, and the long tail. The agent decides which tools to call and adapts to the conversation.
Because both are configured the same way and run on the same engine, a natural-language workflow can hand off to a structured workflow mid-conversation and pick the thread back up, which is the combined model described above rather than two bolted-together systems. Two patterns make this safe to ship in a regulated setting. First, every interaction can be validated before launch through pre-launch adversarial simulations, so you test the bad paths (including the deterministic gates) before customers see them, not after. Second, Lorikeet runs across chat, email, voice with sub-1-second latency, SMS, and WhatsApp on the same workflow engine, so the deterministic-and-natural-language combination behaves the same regardless of channel. Coach, Lorikeet's analytics-and-QA agent, then evaluates 100% of resolved tickets after the fact, which is how you confirm the deterministic steps actually fired as intended at scale.
The honest limitation: a combined model takes more thought to design than dropping in a single chatbot. You have to decide which steps are load-bearing enough to deserve a deterministic flow and which should be left to reasoning, and that judgment is the work. The payoff is an agent that is flexible where flexibility helps and rigid where rigidity protects you. For complex, regulated support, that tradeoff is the right one.
If you are deciding where to use fixed flows and where to let the agent reason, see how Lorikeet combines deterministic and natural-language workflows in one interaction.
Key Takeaways
Deterministic workflows are fixed if-then paths the AI must follow; natural-language workflows are plain-language instructions the AI interprets with its own reasoning.
Use deterministic flows for load-bearing steps (identity, KYC, high-dollar actions, mandatory disclosures) where predictability beats cleverness.
Use natural-language loops for open-ended work (troubleshooting, multi-issue tickets, the long tail) where the next step depends on context.
The strongest deployments combine both in one conversation: the agent reasons freely and hands the high-stakes sub-tasks to deterministic flows.
Lorikeet supports structured and natural-language workflows together on one engine, configured in plain English, with pre-launch simulation and 100% post-facto QA.
Conclusion
The deterministic-versus-natural-language debate is really a question about risk. Some steps in a support conversation are too consequential to leave to improvisation, and some problems are too open-ended to force down a predrawn path. A design that treats every step the same way, whether by hardcoding everything into a decision tree or handing everything to a reasoning agent, gets the easy half right and the hard half wrong.
The model that holds up in regulated support matches the mechanism to the step: deterministic where being wrong is expensive, natural-language where the problem is unbounded, and a clean handoff between them inside a single interaction. That is the architecture worth building toward, and the one Lorikeet is built to run.
