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 concept | What it becomes for an agent |
|---|---|
| Intent with training phrases | A goal, described in plain language, which the model understands however the customer phrases it |
| Slot filled by a specific question | Required information the agent must collect, in whatever order the customer gives it |
| Flow of fixed steps | Rules about what must happen before what, such as no booking before the email is collected |
| Branch for each answer | Guidance on when to use each tool, so the agent picks the right action for the situation |
| Fallback for anything unexpected | Boundaries and handoff rules, so the agent knows what it won’t do and when to bring in a person |

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.

- 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.
- 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.
- 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.
- 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.
- Edge cases: the situations that need a specific response, such as emergencies, complaints or requests the business can’t help with.
- 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 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.

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 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.
| Test | What a well-designed agent does |
|---|---|
| Gives everything in one message | Uses what it was given and only asks for what’s missing |
| Changes their mind halfway | Updates what changed without starting over |
| Asks two things at once | Answers both, or answers one and comes back to the other |
| Asks about something the business doesn’t do | Says so plainly and offers what it can do |
| Asks for a person | Hands over without arguing |
| Describes an emergency | Follows the emergency rule immediately |
| Tries to get it to skip a required step | Politely holds the line |
| Writes in a completely different style | Understands them anyway, and keeps its own voice |
Navigating by the stars
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.