Skip to main content

Flows

A flow is the conversational unit the AI runs for a given customer journey — "where is my order," a return request, a lead qualification, a warranty check. Everything the AI does inside that journey (what it asks, what it looks up, when it branches, when it hands off, when it closes) is defined by the flow's configuration.

You rarely edit these options in a form. In practice the team builds and changes flows by chatting with the Copilot — but understanding the options below helps you phrase requests precisely and read what a flow actually does.

How a flow is chosen​

When a customer message arrives, the AI decides which flow to run by matching the message against each flow's trigger description — a short prompt describing when this flow applies (for example, "customer is asking about the status or location of their order"). Write the description in terms of customer intent, not internal jargon.

  • A flow can be marked trigger-only, so it never starts from a plain customer message — it runs only when another flow routes into it (a transition) or an outreach event fires it (a WhatsApp template reply or an outgoing flow message).
  • A flow can carry an opening message that's sent when it starts, and general notes to the AI that stay in effect for the whole time the flow is active (tone, do's and don'ts, context the AI should keep in mind).

Objectives — the heart of a flow​

A flow is mostly a list of objectives. An objective is one thing the AI needs to do or know in the conversation. Objectives come in a few kinds, and mixing them is how you shape the dialogue.

KindWhat it does
Ask the customerThe AI asks a question and collects the answer (order ID, reason for return, an image).
InferredThe AI works the value out from the conversation and context without asking — its value description tells it how to extract or determine the value.
Data pointPulls a value into the conversation from a lookup — order status, days since delivery, customer address. See Data Points.
Execute actionPerforms a side effect — create a ticket in Freshdesk, cancel an order, send a notification. See Data Points.
ComputedA deterministic value calculated from other objectives already collected (no external call).
Human agentHands this step to a human — creates a child ticket and routes it to a team.

Asking the customer​

For an ask-the-customer objective, the key options are:

  • Ask instruction — how the AI should phrase the question. This is guidance, not a fixed script; the AI adapts it to the conversation.
  • Answer options — offer the customer a bounded set of choices instead of free text. Options can render as quick-reply buttons or a dropdown, and you can present a value differently to the customer than you store internally (a friendly label mapped to an internal value). In an email reply, options are written into the email as a numbered list, except Yes/No questions, which are asked as a plain question.
  • Special inputs — instead of text, ask for an address form, a location, a WhatsApp Flow form, or a product recommendation picker.
  • Deterministic answer matching — for bounded answers, map exact customer phrases to a value ("yes/yeah/yup" → yes) so the answer is captured reliably without relying on inference.
  • Ask at least once / skip conditions — force the question to be asked at least once, or skip it entirely when a condition is already satisfied.
  • Allowed values — constrain what counts as a valid answer, with a format or validation rule (for example, "a valid date in yyyy-mm-dd format").
  • Ask on channels — limit the objective to some customer channels. See Asking an objective only on some channels.

Asking an objective only on some channels​

Ask on channels limits an ask-the-customer objective to the channels you pick: WhatsApp, Email, Chat widget, Instagram, or Voice call. Leave it empty to ask on every channel. On a channel you leave out, the objective is skipped for that conversation: the AI doesn't ask it or infer it, and its own required condition and Ask at least once don't hold the flow back there. On the channels you pick, it works exactly as before.

Only limit an objective when it clearly isn't needed on the channels you leave out; asking an essential question is better than skipping it. For Yes/No confirmations in email, see Confirmations the customer already answered in email.

Because a skipped objective has no value on the channels it leaves out, anything that depends on it should treat a missing value as "not applicable":

  • A computed objective should stop only on the rejection value (for example, when the confirmation is "no"), not wait for a "yes".
  • Conditions and transitions on the normal path shouldn't require it to have a value. Only a correction branch, such as asking for a new address when the confirmation is "no", should depend on it.

Copilot sets Ask on channels only when you ask it to. When it does, it writes the dependent conditions to match, and it blocks a save if a computed objective, condition, or transition would wait forever for a channel-limited objective on a channel where it's skipped.

Confirmations the customer already answered in email​

In email, the AI can skip a Yes/No confirmation question set to Ask at least once, such as "Should the technician be sent to this exact address?", when the customer has clearly written every detail it would show in their own emails. It records the answer as "Yes", notes this in the ticket's activity, and moves the flow on in the same reply, so the next step (for example, creating the technician ticket) doesn't wait for another email.

It only skips when it is confident. The question is still asked if any detail came from an invoice, a saved address, an order, or a message from your team, if the customer gave more than one option or sounded unsure, or if the check isn't available. Chat channels such as WhatsApp always ask. This is turned on per workspace; contact support to enable it.

Presenting a WhatsApp Flow form​

A WhatsApp Flow form objective is an ask-the-customer objective that opens a published WhatsApp Flow instead of collecting each field through separate chat messages. The objective still has one normal objective value: the submitted form response completes that objective and the conversational flow continues to its next eligible objective.

Configure three parts together:

  • Ask instruction — frames the short message sent with the attached form. For a newly configured form, make this an invitation to complete the form; do not list every form field in chat.
  • WhatsApp Flow — the published Flow ID to attach.
  • Enabled channels — the customer channels that can render this interaction. WhatsApp is currently the only supported option and is selected by default for a new Flow form objective.

Channel eligibility applies to the whole objective, not only to its button. On email, Instagram, chat widget, voice, and other unsupported channels, the Flow form objective is skipped for that invocation: it is not inferred, is not counted as asked, and does not block a later eligible objective. A flow containing only skipped objectives can complete normally. Manual ticket creation also skips channel-scoped Flow form objectives even when the selected ticket source is WhatsApp; the manual form does not show those objective fields.

Skipping is temporary and is not saved as an objective skip policy. If the same customer journey later continues on WhatsApp, the objective can become eligible and present the form. Ordinary objectives work on every supported channel unless you limit them with Ask on channels.

Customer message compatibility​

New Flow form objectives frame the attached-form message from their Ask instruction. The Legacy: frame the message from Flow metadata setting additionally applies the Flow's saved customer-message instruction. Keep this enabled only when an existing form relies on that metadata for its wording.

Existing Flow form objectives remain backward compatible: when their newer channel/message settings are absent, they are treated as WhatsApp-only with legacy metadata messaging enabled. This preserves their WhatsApp wording while intentionally preventing the form from appearing in unsupported channels. Turning off the legacy setting changes message framing only; it does not change the attached Flow or its submitted data.

Prefilling form fields​

Field-level prefill maps one already-available objective value into one exact Flow field:

Flow screen: CONTACT
Flow field: phone_number
Source objective: customerPhone

When the form is sent, a valid customerPhone output is placed in the Flow's corresponding initial-data key (for example, prefill_CONTACT_phone_number). Values are passed as collected; a mapping does not transform or reformat them. If the source objective is missing, inactive, null, or a blank string, the target field stays blank and the form still opens.

For reliable prefilling:

  1. Make the target field prefill-ready in the WhatsApp Flow, then publish or republish the Flow. A task mapping cannot prefill a field whose Flow definition has no initial-data binding.
  2. Use the Flow's exact screen ID and field name in the mapping.
  3. Make the source objective available before the form objective runs. Prefilling reads the current task output; it does not ask, fetch, or calculate the source by itself.
  4. Keep the source value compatible with the Flow field type. No coercion is added at send time.

The library editor also offers Prefill with data for supported built-in customer values such as customer name, phone number, address, or PIN code. Use field-level mappings when the value comes from a specific task objective or when several fields need different task outputs.

When a form and its source objectives are reused as an Objective Collection, include every source named by its prefill mappings in that collection and keep those sources before the form objective.

Making objectives conditional​

Objectives don't have to be flat. Two mechanisms control when an objective applies:

  • Required condition — whether an objective must be completed, optionally depending on another objective's value. For example, "only require an invoice image when the reason is damaged."
  • Parent condition — activate a group of child objectives only when a parent objective meets a condition. This is how you build branches: ask the follow-up questions for "damaged" only when the customer said the item was damaged.

Conditions compare an objective's value using operators like equals / not equals, contains / not contains, greater than / less than, in (one of a set), matches a pattern, exists / has a valid value, or the API failed.

A required condition holds back what comes after it until its value is accepted. An email reply and the New Ticket form still ask the questions after it in the same round, so the customer or agent can answer them together. For example, an email asks for the reason for service and the product category at once. Asking ahead stops after a question whose answer can move the conversation to another flow, and before an action or a handoff to a team, because the questions after them may no longer apply. An answer given early is kept and used once the earlier answer is accepted. Lookups and actions still wait until then, and a question that only applies to a particular earlier answer appears once that answer is in.

Chat channels ask one question at a time.

Failure message for a required condition​

A required condition can have a Failure message: one plain sentence, written for the customer, that says why a value failing the condition can't be used. For example, "Returns can be raised only after the order is delivered." or "Use the 10-digit number printed at the top of your invoice." Set it on the condition under Child Conditions when you choose Required Condition, or ask Copilot to add it.

The failure message is used in two places:

  • New Ticket form: when an agent enters a value the condition rejects, the field turns red and shows the message. The check and the value entered are shown underneath.
  • Conversations: when the customer's answer is rejected, the AI explains the reason in its own words, in the customer's language, before asking again.

If you leave it empty, a reason is generated from the condition, such as Order status must be "delivered". Write your own when that wording would mean little to a customer, especially when another objective (for example an invoice lookup) does the check.

Handing a step to a human​

A human-agent objective creates a child ticket and routes it to a team. You can configure:

  • The customer-facing message shown when the step is handed off.
  • A hint for the agent in their console.
  • Whether the agent must record a resolution, an optional resolution hint, and whether that resolution is shared back with the customer as a note.

See Child & Interaction Tickets and Agent Assignement & Team for how the routed work behaves.

When an answer doesn't settle an objective​

Before asking an objective again, the AI works out why the customer's reply didn't settle it and asks accordingly:

  • They haven't answered yet (they asked something else): it replies to them first, then asks once more.
  • They answered, but it didn't work (a typo in an order ID, a wrong code, or a value a required condition rejects): it says what was wrong and asks again. For a rejected value it gives the condition's failure message. This also applies to standalone messages and WhatsApp Flow forms, which are otherwise sent again unchanged.
  • They gave only the part their request needs, for example "only the flat number changes" when asked for a full address: it doesn't repeat the question. It completes the value from details it already has and asks them to confirm. If it can't, it asks only for the missing part.
  • They say they already shared it: it finds the earlier value and confirms it.
  • They can't provide it: an optional objective is skipped and the flow continues. A required one is handed over (see below).

An objective is asked at most its Max asks times (default 3). If a required objective's answer is still rejected after that, the AI stops asking and hands the conversation over through Unable to Resolve. A flow that already routes on the ask count (an asked more than condition or transition on that objective) keeps its own handling.

Transitions — branching and early exit​

Transitions let a flow change course based on an objective's value:

  • Route to another flow — when the customer's answer means a different journey should take over (a return request that turns out to be a warranty claim).
  • Complete early — end the flow as soon as a condition is met, with its own completion message.
  • Send a reply and continue — drop in an extra message when a condition is met without leaving the flow.

Each transition names the objective to watch, the condition to evaluate (same operators as above), and where to go. A flow can also be set to only allow transitions — it never matches a plain customer message and only moves via routing.

Every flow a conversation passes through, including flows it moves through by a transition, is recorded on the ticket. To see a journey that branches across several flows as one group, create a use case for its entry flow.

Passive context​

Beyond objectives, a flow can include data points as passive context — values injected into the AI's context for the whole conversation without being collected step by step (for example, always having the customer's order count available). These are the same data points documented in Data Points; the difference is they're along for the ride rather than a step the AI works through.

Completion & handoff​

When the objectives are done, the flow's completion behavior decides what happens:

  • Completion prompt — instructs the AI what to tell the customer once the flow's objectives are complete, using everything it collected.
  • Run completion independently — send the completion message on its own rather than blending it with other replies.
  • Resolve or assign — automatically resolve the ticket, or hand it to a human on completion. By default a flow that isn't set to auto-resolve leaves a ticket for an agent.
  • Completion action — optionally run an execute action when the flow completes.
  • Follow-ups — schedule follow-up messages after completion.
  • Disposition presets — preset ticket disposition fields (category, sub-category, and other values) whenever this flow runs, so tickets are classified consistently.

After-completion follow-ups​

Use After-completion follow-ups in a flow's Transitions section when a customer needs different handling after an AI-resolved completion. The original flow completes and resolves its ticket normally; it does not wait for another message. Flows that always hand off on completion already have human ownership and do not use these rules.

For example, an exchange flow can share its self-service link and finish. If the customer later cannot change the size, cannot use the link, or asks for an exchange update, a follow-up rule can start a linked support flow that assigns an agent.

Each rule has:

  • When the customer says — describe the substantive follow-up messages that should start the linked flow. Include any prerequisites, such as the assistant having shared instructions, and exclusions, such as thanks, acknowledgements, or asking for the link again. The AI assesses the condition using the actual delivered completion reply and the conversation.
  • Start task — choose another active flow. It can be trigger-only so an initial customer request cannot start it directly.
  • Request identifier (optional) — choose the source objective containing the order or case identifier. The identifier is retained with the completion evidence to help distinguish the original request from a different order or case. Session-only objectives, such as verification codes, cannot be used as request identifiers and are not restored into the linked flow from saved completion evidence.

Only a follow-up about the same request can take this route. Thanks, acknowledgements, and messages that match no configured condition use the usual routing. Rules are opt-in; flows without them keep their existing behavior. Existing human ownership and explicit outreach or form triggers keep their normal handling.

Completion evidence remains attached to the ticket when the short-lived conversation session expires. Recovery considers the most recent completion, even when that flow started before another flow. Rules cannot recover missing evidence from conversations completed before the rule was enabled. Test the initial request through completion, then send the follow-up to verify both paths. You can also ask Copilot to configure and test these rules.

When a customer disputes an AI-resolved outcome​

When the AI resolves a flow (it completes with its completion message and auto-resolves, or ends early through a Complete & Resolve transition) and the customer replies that they don't accept the outcome, the account's Disputed Outcome setting decides what happens: the AI explains again why the outcome stands, then hands off to an agent after the account's number of disputes.

A flow can override that count and choose the team that takes the handoff:

  • For one early-exit branch — in the flow's transitions list, each Complete & Resolve transition shows If the customer disputes this, hand off after N disputes, to [team]. Use it when one refusal needs a different count or team, for example handing a refusal outside the return window to a review team on the second dispute.
  • For the flow's own completion — under Ticketing, a flow that auto-resolves shows the same setting for its completion message. Flows that hand off to an agent on completion don't need it.

Leave the count empty to follow the account setting. 0 never hands off (the AI keeps explaining the outcome), 1 hands off on the first dispute, up to 5. Without a team, the reopened ticket stays with its current team. You don't need extra questions such as "Do you accept this?" or ask-count loops to handle customers who insist; Copilot sets this override when you ask for something like "deny twice, then escalate to CRM L1".

When a customer corrects the answer behind a Complete & Resolve transition​

A Complete & Resolve transition ends a flow because of one answer, for example a serial number lookup that returned "not found". If the customer then gives a different answer, such as a new serial number or a photo of the label, and the transition's condition no longer holds, the flow picks up again: the AI asks the next question instead of repeating the closing message, and the AI-resolved ticket moves back to in progress rather than a second ticket being opened. A satisfaction survey still waiting to be sent for that ticket is cancelled.

The flow stays closed while the condition still holds, when the customer only disagrees without new information (see disputes), and for flows that completed through their own completion message. A transition that moves to another flow is not reopened this way. Conversations that ended before this behavior was available stay closed.

A closing message that asks the customer to re-enter or resend something still ends the flow until the customer actually answers. When a wrong answer should simply be asked again, keep the flow open instead: make the answer's question required on the lookup result and put the "not found" wording in that question.

Routing tasks​

Some flows exist only to work out which flow comes next. For example, a "product issue" flow identifies the order and product, then routes to a mattress, accessory, or marketplace flow. Finishing such a flow on its own does nothing for the customer, so mark it as a Routing Task (under Ticketing).

A routing task ends only by moving to another flow through a transition, or through a Complete & Resolve transition. If no route matches, for example because order data was missing or a lookup failed, the flow does not complete with its completion message and the AI does not resolve the ticket. Instead:

  • the ticket goes to an agent in the flow's team, and the customer gets the usual message that an agent will get back to them;
  • the ticket timeline notes which routing values were missing, so you can see which part of the routing to fix.

Its completion instructions are never sent. Leave the box unchecked when finishing the flow is a valid outcome in itself, such as a flow that answers the customer's question and only routes in some cases. Copilot decides this when it builds or changes a flow that routes to other flows, and tells you in a Routing check note when a flow still needs that decision.

How the pieces shape the conversation​

Read together, the configuration is the conversation:

  1. The trigger description decides whether this flow runs at all.
  2. Objectives drive the turn-by-turn dialogue — what the AI asks, what it silently infers, what it looks up, and what it does.
  3. Conditions (required and parent) decide which objectives apply, so the customer only sees the questions relevant to their situation.
  4. Transitions reroute or end the flow the moment the situation changes.
  5. Completion decides how the journey ends — a message, a resolved ticket, or a handoff to a human.

Change any of these and the customer's experience changes accordingly — which is exactly what you're doing when you ask the Copilot to "add a follow-up question when the reason is damaged" or "route refunds over ₹5000 to the retention team."

What the AI reads on each turn of a flow​

Every customer message runs through the same steps, and each objective kind is filled in a different one:

  1. Choose the flow. The AI compares the message with the trigger description of every flow (and your FAQs) to decide what the customer wants. Many flows with overlapping descriptions make this choice harder.
  2. Read the conversation for objectives. For Ask the customer and Inferred objectives, the AI reads the conversation to fill or update their values. Their value descriptions, ask instructions and skip conditions are part of this step.
  3. Fill the other objectives without reading the conversation. Data point values come from a lookup (your order data, the customer record, a Custom API or a sheet). Computed values are calculated from values already collected. Execute actions call your systems. Image and PDF objectives are read from the file the customer sent, in a separate step. None of these ask the AI to interpret the conversation.
  4. Write the reply. The AI writes the next message using the flow's notes, the current step's instructions, transition and completion messages, and the values collected so far, by name and value.

What this means when you tune a flow:

  • The flow's AI workload grows with its Ask the customer and Inferred objectives and the length of their descriptions and instructions, plus long flow notes and messages.
  • A data point that no condition, transition or message uses adds little AI work, because only its short value reaches the reply step. It still runs its lookup and adds a value the AI sees, so remove it when nothing needs it.
  • Moving a yes/no judgment out of an inferred objective into a computed objective or a data point takes it out of step 2.
  • How often a flow runs matters as much as its size. A small flow that handles most of your conversations can account for more AI work than a large flow that rarely runs.

To see where each objective of a live flow gets its value, ask the Copilot, or use the live task view from an AI app connected through MCP.

Building & testing flows​

  • Add and edit flows conversationally with the Copilot — it can read every configured flow, explain how a journey is handled, and make changes for you.
  • Reuse common logic with the Objective Library — mark an objective as shared to import it into other flows. See Workflows → Data Library.
  • Reuse a group of objectives and its internal wiring with a live-linked Objective Collection. Linked members collect ticket values under the same objective params as ordinary flow objectives.
  • Try a flow before relying on it with the Test flow feature, and lock in behavior with automated test runs.
  • Workflows — the umbrella view of flows, the data library, samples, products, and stores.
  • Use Cases — group a journey's flows, then filter, view, and export its tickets.
  • Data Points — the values and actions a flow's objectives use.
  • Objective Collections — live-link reusable objective groups across flows.
  • Custom APIs — where flow lookups and actions get real data.
  • Copilot — build and change flows by chatting.
  • Testing — automated, repeatable tests with assertions and mocking.