Back to all posts

Developer & technical insights November 20, 2026 11 min read

Conversation Design for Agentic AI (Writing for Agents Instead of Flowcharts)

by Melek Messoussi AI Product Specialist at Myna

Customers never stick to the script. Give your AI agent a goal and clear rules. Above real agent instructions and a messy request it handled.

TL;DR: For most of the history of chatbots, conversation design meant drawing flowcharts, with every question, answer and branch decided in advance. Agentic AI changes the job. Instead of drawing every path, you write the destination and the rules of the road: the goal, the information the agent needs, when to use each tool, what it must never do and when to hand over. The agent works out the route itself. This post explains the shift, breaks down what good agent instructions contain, and tests them in Myna with a customer who does everything a flowchart hates.

In the eighteenth century, sailors navigating without a reliable way to measure longitude often relied on a technique called dead reckoning, which meant estimating their position from their speed, heading and the time that had passed. It worked tolerably well as long as nothing unexpected happened, and rather badly when a current, a storm or a navigational error pushed the ship somewhere the calculation hadn’t anticipated. The breakthrough, when it came, was a way of finding out where you actually were, so that the plan could be adjusted to the sea instead of the other way round.

Chatbot flowcharts have a lot in common with dead reckoning. The designer works out in advance every question the bot will ask and every answer it expects, and draws the route from greeting to booking. As long as the customer answers the questions in order, using words the bot recognises, everything goes to plan. The moment they answer two questions at once, change their mind, or ask something the chart didn’t anticipate, the bot is somewhere the designer never drew, and the result is the familiar “Sorry, I didn’t understand that”.

Agentic AI is closer to navigating by the stars. The agent is given a destination and a set of rules, and works out where it is in the conversation at every turn, which changes what conversation design is about.

What flowcharts were really encoding

Traditional conversation design built its bots out of a few standard parts. Intents described what the customer wanted, such as “book appointment” or “check opening hours”, each trained on dozens of example phrases. Slots were the pieces of information the bot needed, such as a date or an email address. Flows joined them into a fixed sequence, and fallbacks caught everything that didn’t fit.

None of these ideas disappears with agentic AI. They simply change form, from things you draw to things you write.

Flowchart conceptWhat it becomes for an agent
Intent with training phrasesA goal, described in plain language, which the model understands however the customer phrases it
Slot filled by a specific questionRequired information the agent must collect, in whatever order the customer gives it
Flow of fixed stepsRules about what must happen before what, such as no booking before the email is collected
Branch for each answerGuidance on when to use each tool, so the agent picks the right action for the situation
Fallback for anything unexpectedBoundaries and handoff rules, so the agent knows what it won’t do and when to bring in a person

On the left, a flowchart with a fixed path from greeting to booking, where an out-of-order answer falls into a fallback. On the right, an agent given a goal, required information and rules, reaching the booking by whatever route the customer takes

The most important difference is in the last row. A flowchart fails closed, dropping anything unexpected into a fallback, whereas an agent fails open and handles the unexpected with the model’s judgement, which is usually sensible and occasionally creative in ways nobody wanted. Good conversation design for agents is largely about narrowing that judgement where it matters, without taking away the flexibility that makes agents worth using.

The anatomy of good agent instructions

Well-designed instructions tend to have the same few parts, whatever the agent does.

The parts of good agent instructions: a goal, required information, when to use each tool, rules, edge cases and handoff, with tone kept in a separate persona

  1. A goal: one or two sentences saying what a successful conversation achieves, such as “book cleanings and check-ups for patients, and answer their questions along the way”. The goal is what the agent falls back on when nothing else in the instructions covers the situation.
  2. Required information: what the agent must know before it can finish the job, such as the visit type and the patient’s email. Listing these separately, instead of scripting the questions, lets the agent skip anything the customer has already said.
  3. When to use each tool: a short line per tool, such as “suggest open times when the patient wants to book but hasn’t picked a time”. Tools without guidance get used at odd moments or not at all.
  4. Rules: the things that must always or never happen, written as plainly as possible. “Only say an appointment is booked once it has actually been booked” is a rule. “Be careful about bookings” isn’t.
  5. Edge cases: the situations that need a specific response, such as emergencies, complaints or requests the business can’t help with.
  6. Handoff: when the agent should bring in a person, and what it should tell the customer when it does.

Tone and personality are deliberately missing from that list. They’re better kept in a separate persona, so the voice stays consistent across every agent and the instructions stay focused on what the agent does. The post on persona design covers that side.

A habit that helps: write rules as things a colleague could check. “Never quote a price that isn’t in the knowledge base” can be verified by reading a transcript, while “be accurate about prices” can’t.

Writing it in Myna

In Myna, an agent’s instructions live in its Agent Node, in Workflow Studio or the simple view. Here are the instructions for a booking agent at a fictional dental clinic, Bright Smile Dental, organised into a goal, guidance for each tool and rules.

The node instructions for the Bright Smile Dental booking agent in Myna, with a Goal, a When to use each tool section and a Rules section

The required information is kept out of the instructions and set up as qualifications, which the agent collects with its Ask Qualification tool. Each qualification has a goal, which tells the agent what it’s trying to find out, and the booking tools can be locked until every required qualification has been answered. That moves the rule “don’t book before you have the visit type and email” out of the prose and into the system, where it can’t be ignored.

Two qualifications, visit type and email address, with the booking tools locked until both are answered

Testing it with a messy customer

The real test of conversation design is a customer who doesn’t follow the script, so we tested the agent in the Playground, Myna’s test environment, with the kind of conversation that breaks flowcharts.

The first message gives almost everything at once, out of order and in lowercase: “hey its maria lopez, need a check up sometime thursday afternoon if you have anything, email is maria.lopez@example.com”. A flowchart would typically ask for the name, then the visit type, then the email, regardless of what the customer had already said. The second message changes the plan: “actually can we make it a cleaning instead? and a bit later if possible, like 3”.

The Playground conversation: the agent notes the check-up details and email from the first message and offers Thursday at 12:00, then, when the patient switches to a cleaning at 3, updates the visit and books Thursday at 3:00 PM, with the appointment shown in the demo contact's details

The agent picked up the name, visit type, email and preferred day from the first message, skipped every question that had already been answered, and offered the first free slot on Thursday afternoon. When the patient changed the visit type and the time, it updated both and booked 3:00 PM, and the appointment appeared in the demo contact’s details on the right, which confirms the booking really happened and wasn’t just described.

No branch in the instructions describes “a patient who gives everything at once and then changes two things”. The agent handled it because the instructions describe the goal, the information needed and the rules, and leave the route to the agent.

What we’d still tighten

Reading the transcript closely, two small things are worth improving, which is typical of what conversation design looks like once an agent is working.

  • It booked the changed time without asking again: the patient asked for “a bit later, like 3”, and the agent took that as a yes. That’s reasonable here, but some businesses would prefer an explicit confirmation, and if so, it belongs in the rules: “confirm the final time before booking if the patient changed it”.
  • It opened with “Absolutely”: a small thing, but a common one. If the business doesn’t want that voice, the fix belongs in the persona, where the rest of the agent’s voice is set.

A test script worth stealing

Before an agent goes live, run it through conversations like these, and read what it did as well as what it said.

TestWhat a well-designed agent does
Gives everything in one messageUses what it was given and only asks for what’s missing
Changes their mind halfwayUpdates what changed without starting over
Asks two things at onceAnswers both, or answers one and comes back to the other
Asks about something the business doesn’t doSays so plainly and offers what it can do
Asks for a personHands over without arguing
Describes an emergencyFollows the emergency rule immediately
Tries to get it to skip a required stepPolitely holds the line
Writes in a completely different styleUnderstands them anyway, and keeps its own voice

Dead reckoning worked until the sea did something unexpected, and flowcharts worked until the customer did. Agentic AI shifts conversation design from drawing every route to describing the destination, the rules of the road and the hazards to avoid, and then checking, conversation by conversation, that the agent gets there.

That’s a different skill from building flows, and in some ways a more demanding one, since vague instructions produce vague agents. But it’s much closer to how you’d brief a capable new colleague, and the agents that come out of it can handle customers as they actually are, which is to say out of order, in lowercase and changing their minds.

Frequently asked questions

What is conversation design for agentic AI?

It is the practice of defining how an AI agent should handle conversations by writing its goal, the information it needs, when to use each tool, the rules it must follow and the boundaries it must respect, instead of drawing every path a conversation could take. The agent then works out the path itself, within those limits.

How is designing for agents different from designing chatbot flows?

Chatbot flows are decision trees, where every question, answer and branch is drawn in advance and the customer has to follow them. Agents are given objectives and rules, and can handle customers who answer out of order, change their minds or ask several things at once, which flows struggle with.

What should AI agent instructions include?

A clear goal, the information the agent must collect, guidance on when to use each tool, the rules it must never break, what to do in emergencies or edge cases, and when to hand the conversation to a person. Tone and personality are usually better kept in a separate persona.

How do you test conversation design for an AI agent?

By sending it the conversations most likely to go wrong, such as customers who give everything in one message, change their minds, ask about things the business doesn't do, or get frustrated, and reading what the agent did as well as what it said.

Sign up free