Some phone tasks can't be left to improvisation. An order has to capture every item, the address, and a callback number, in order, on every call. Flowyte playbooks give your AI phone agent exactly that: a procedure it runs the same way every single time, while still sounding like a natural conversation. This guide walks through the walkthrough we recorded for Slice House, a neighborhood pizza shop, where we built two playbooks: one that takes an order and logs it to a Google Sheet, and one that recognizes a returning caller and reads back their last order.
Playbooks are tagged Advanced in the product for a reason. Most agents never need one. When you do, nothing else works as well.
Key Takeaways
- A playbook is a procedure: a fixed set of steps your AI phone agent runs in the same order on every call, instead of hoping the agent remembers each one.
- Reach for a playbook when a task has a fixed shape - several things to collect in order, with a branch or two. Most agents never need one; when you do, nothing else works as well.
- Playbooks are built from a few blocks: Collect gathers one input (spoken or keyed in on the phone keypad), Message speaks a line that can include anything already collected, and Branch only continues when a condition holds.
- The Assist drafts the whole playbook from one plain-English request, and every step stays yours to reword, reorder, or extend in the step editor.
- A playbook can call any of the agent's skills mid-procedure and use the result in later steps - that is how Slice House logs every order to Google Sheets and recognizes returning callers.
What Is a Playbook in an AI Phone Agent?
The walkthrough opens with the cleanest definition we have: "A skill is a single action. Knowledge is recall. A playbook is a procedure: a set of steps your agent runs the same way, every single time."
That three-way split matters. A skill does one thing, like booking an appointment or logging a row. Knowledge lets the agent answer questions from content you control. A playbook strings actions and questions together into a sequence with a guaranteed order. The agent still speaks naturally on every turn. The playbook just makes the sequence reliable.
Think of it as the difference between telling a new employee "be helpful on the phone" and handing them an order pad with numbered fields. Both sound human on the call. Only one guarantees the address gets written down.
When Should You Use a Playbook Instead of a Skill?
Reach for a playbook when a task has a fixed shape: a set of things to collect in order, with a branch or two, where you want to be sure every step happens instead of hoping the agent remembers. Taking a food order is the textbook case. So is an intake form, a refill request, or a warranty claim.
If the task is a single action, use a skill. If the caller just needs an answer, use knowledge. Here's the honest decision table:
| Skill | Knowledge | Playbook | |
|---|---|---|---|
| What it is | One action | Recall from your content | A multi-step procedure |
| Example | Book an appointment | "What are your hours?" | Take a complete order |
| When it runs | The agent decides in the moment | When a question matches | The same steps, in the same order, every call |
| Best for | Most agents, most tasks | Q&A about your business | Fixed-shape tasks where nothing can be skipped |
Most agents do their whole job with knowledge and a few skills. Playbooks are the Advanced tier of the agent studio, and you should treat them that way: a tool you pick up when a procedure genuinely has to run the same way every time.
What Are the Building Blocks of a Playbook?
There are only a few building blocks, and the walkthrough shows each one inside the Slice House order playbook:
- Collect gathers one input and waits for it. Each Collect step asks for a single thing, like "And what is a good phone number to reach you at?", and saves the answer into a named slot such as
phone. For numeric answers, callers can say the answer or press it on the keypad - the shipped say-or-press behavior means a phone number works either way. - Message has the agent say something, and it can drop in anything it has already collected. Slice House's confirmation line reads the items, the sides, pickup or delivery, the address, the name, and the phone number back in one natural sentence, all pulled from slots.
- Branch only moves the procedure forward when a condition holds. The order playbook checks an
order_confirmedvalue and only continues to logging once the caller has confirmed. One set of steps runs when the condition holds, another when it doesn't. - Call a skill runs one of the agent's skills mid-procedure and saves part of its result to use later. This is the binding step: whatever the skill returns becomes material a later Message or Branch can use.
That's the whole vocabulary. Steps are laid out top to bottom in the step editor, every one visible and editable, so you can read the entire procedure the way a caller will experience it.
How Do We Build an Order-Taking Playbook?
The Slice House build leans on the Assist, Flowyte's build copilot. You describe what you want in plain English, and it configures the account for you, using the same API a developer would. Here is the exact procedure from the walkthrough:
Describe the playbook to the Assist
Tell the Assist what the procedure should do, in one plain-English request. Ours was: build a playbook that walks the caller through an order - collect the items, the sides, pickup or delivery, the address, and their name and number, then read it back to confirm. A few seconds later, the playbook is there.
Review the steps in the step editor
Open the playbook and read it top to bottom. The Assist drafts a Start greeting, a chain of Collect steps (items, sides and drinks, pickup or delivery, delivery address, customer name, phone number), and a confirmation at the end. Every step is laid out in order, so you can audit the whole procedure at a glance.
Check each Collect step's prompt and slot
Click into a Collect step to see two things: the prompt (what the agent asks to capture this value) and the slot it saves into. Reword any prompt that doesn't sound like you. The slot names matter later, when you map collected values into a skill.
Read the order back with a Message step
The confirmation Message pulls every collected slot into one line: "You ordered {items} with {sides_or_drinks} for {pickup_or_delivery}. The delivery address is {delivery_address}, under the name {name}, and the phone number is {phone}." The agent speaks it as one natural sentence.
Gate the finish behind a Branch
Add a Branch that checks the caller actually confirmed. Only when order_confirmed holds does the playbook continue to logging; otherwise it loops back to fix the order. This is the step that makes the procedure trustworthy - nothing gets logged that the caller didn't approve.
Fine-tune anything the Assist missed
The Assist gets you most of the way there, but everything is yours. Click any step to reword a prompt, reorder it with the arrows, or add a step the Assist didn't think of. Describe it first, then make it exactly yours.
Try it in the tester before it takes a real call
Run a test conversation and watch the timeline as the agent walks the steps. When it behaves the way you want on the awkward calls, not just the easy ones, it's ready to publish.
How Does Every Order Get Logged Automatically?
Taking the order is only half of it. You want every order logged, and that's where integrations come in. You connect a tool once, for the whole organization, then add its actions to any agent as a skill.
Slice House uses Google Sheets. We connected it one time, then added a log-a-row skill that maps each thing the agent collects - the name, phone, the items, pickup or delivery, the ready time - straight to a column in the sheet. No code. Just mapping. When a caller places an order, it lands in the spreadsheet as a new row: name, number, the full order, pickup or delivery, the time. Every call captured automatically, with nobody copying anything down.
The spreadsheet is a stand-in for the demo. In real life that row is a record in your CRM or your order-management system. Google Calendar and Google Sheets connect the same way, and you can connect other tools with secure OAuth or webhooks - always the same pattern: connect once, then add actions as skills.
Need something that isn't on the list? Point a webhook at your own system to send the order anywhere, or do a data dip - a quick database lookup - to pull information in mid-call. If your business runs on it, your agent can reach it.
How Do You Recognize a Returning Caller?
The second playbook runs the other direction: reading information back to the caller. Picture a regular calling in. You want the agent to recognize who they are and know what they ordered last time.
We asked the Assist for a second playbook, this one for returning callers. It collects the caller's phone number into a phone slot, runs a look-up skill that finds their last order in the same Google Sheet, and reads it right back. One request, and the whole procedure is built, the same way we built the first.
This is where binding a skill's result pays off. The Call-a-skill step saves what the look-up returns - the customer's name, order details, sides - and the Message step that follows speaks it: "I found your last order, it was a large pepperoni and garlic knots. Would you like to reorder it, change something, or start fresh?"
In the tester, the caller says: "I'd like to reorder my usual, my number is 406-555-0100." The timeline shows the agent running the look-up skill, finding the order, and reading it back. From there the caller can reorder as-is, change something, or start fresh - and you're right back in the order playbook. A returning customer, recognized and handled in seconds. For a restaurant, that's the difference between a phone line that takes messages and one that runs the counter.
That's the whole pattern: lean on the Assist to build the procedure, refine it step by step in the editor, and wire in any system you need through an integration, a webhook, or a data dip.
Walkthrough transcript
Let's go deeper on one of the most powerful pieces of Flowyte - playbooks. A skill is a single action. Knowledge is recall. A playbook is a procedure: a set of steps your agent runs the same way, every single time.
Reach for a playbook when a task has a fixed shape - a set of things to collect in order, with a branch or two - and you want to be sure every step happens, instead of hoping the agent remembers. The agent still sounds natural. The playbook just makes it reliable.
We'll build two of them on a fresh agent: Slice House, a neighborhood pizza shop. One playbook to take an order and log it. One to recognize a returning caller and pull up their last order. And we'll connect a real Google Sheet to do it.
And we'll lean on the Assist to do the heavy lifting. This is your build copilot - describe what you want in plain English, and it configures the account for you, using the same API a developer would.
So I just tell it: build a playbook that walks the caller through an order - collect the items, the sides, pickup or delivery, the address, and their name and number, then read it back to confirm. A few seconds later, the playbook is there.
And here's what it built - the step editor. Every step is laid out in order, top to bottom. Most of these are Collect steps. Each one asks for a single thing and waits for the answer before it moves on.
There are only a few building blocks. Collect gathers one input and waits for it. Message has the agent say something, and it can drop in anything it's already collected. And Branch only moves the flow forward when a condition holds - like the caller confirming the order before it gets logged.
The Assist gets you most of the way there, but everything is yours to fine-tune. Click any step to reword a prompt, reorder it with the arrows, or add a step the Assist didn't think of. Describe it first, then make it exactly yours.
Now, taking the order is only half of it. We want every order logged. That's where integrations come in. You connect a tool once, for the whole organization, then add its actions to any agent as a skill.
Here we're using Google Sheets. We connected it one time, and added a log-a-row skill that maps each thing the agent collects - the name, phone, the items, pickup or delivery, the ready time - straight to a column in the sheet. No code. Just mapping.
And here's the important part: a spreadsheet is just our stand-in for the demo. Picture this going into your CRM, your order-management system, whatever you actually run. Google Calendar, or any other tool your business relies on - you connect them the exact same way: once, then add their actions as skills.
Need something that isn't on the list? It's just as easy. Point a webhook at your own system to send the order anywhere, or do a data dip - a quick database lookup - to pull information in. If your business runs on it, your agent can reach it.
So when a caller places an order, here's the payoff: it lands in the spreadsheet as a new row - and in real life, that's a record in your CRM or order system. Name, number, the full order, pickup or delivery, the time. Every call captured automatically, with nobody copying anything down.
Now let's go the other direction - reading information back to the caller. Picture a regular calling in. We want the agent to recognize who they are and know what they ordered last time.
So we ask the Assist for a second playbook - this one for returning callers. It collects the caller's phone number, calls our look-up skill to find their last order in the same sheet, and reads it right back. One request, and the whole flow is built - the same way we built the first.
Let's try it in the tester. The caller says: I'd like to reorder my usual, my number is four-oh-six, five five five, oh one hundred. Watch the timeline - the agent runs the look-up skill, finds the order, and reads it right back: a large pepperoni and garlic knots.
From there, the caller can reorder it as-is, change something, or start fresh - and you're right back in the order playbook. A returning customer, recognized and handled in seconds.
And that's the whole pattern. Lean on the Assist to build the flow, refine it step by step in the editor, and wire in any system you need - through an integration, a webhook, or a data dip.
And if you ever get stuck building one of these, we are always here to help - just email support at Flowyte dot com. Now go build something your agents run perfectly, every single time.
Common Questions
What is a playbook in Flowyte?
A playbook is a procedure: a set of steps your AI phone agent runs in the same order on every call. A skill is a single action and knowledge is recall; a playbook chains questions, messages, and skill calls into a sequence with a guaranteed order, while the agent still sounds natural on each turn.
When should I use a playbook instead of a skill?
Use a playbook when a task has a fixed shape: several things to collect in order, with a branch or two, where every step must happen. Taking a complete order, running an intake form, or processing a claim are good fits. If the task is one action, a skill is simpler and usually better.
Does my agent actually need a playbook?
Probably not at first. Playbooks are tagged Advanced in the product, and most agents do their whole job with knowledge and a few skills. Reach for a playbook only when a procedure genuinely has to run identically on every call - and when you do need that, nothing else works as well.
Can callers answer with the phone keypad instead of speaking?
Yes. Collect steps support say-or-press input, so a caller can speak their phone number or key it in on the keypad and the playbook captures it either way. That matters for numeric answers like phone numbers and order IDs, where keypad entry is often faster and more accurate.
How does a playbook connect to my own systems?
You connect a tool once for your whole organization, then add its actions to any agent as a skill. Google Sheets and Google Calendar connect this way, and you can reach other tools with secure OAuth or webhooks. For anything custom, point a webhook at your own system or use a data dip, a quick database lookup, to pull information in mid-call.
How much does it cost to run an agent with playbooks?
Flowyte uses prepaid credits, where 1 credit equals $0.01. Voice starts at $0.11 per minute pay-as-you-go, phone numbers are $2 per month each, and you start with free signup credits and no credit card required. Playbooks are included; see the pricing page for current plans.
Run It the Same Way, Every Time
Playbooks close the gap between an agent that usually gets it right and a procedure that always runs. Define the steps once, let Collect, Message, and Branch enforce the order, bind a skill's result where a step needs live data, and every call follows the same path from greeting to logged record.
Start where Slice House did: pick the one call type where a missed step costs you money, describe it to the Assist in a sentence, and refine the draft in the step editor. If you get stuck, email support@flowyte.com. Voice runs from $0.11 per minute, and you can build and test the whole thing on free signup credits before it ever takes a live call.
Build Your First Playbook
Describe the procedure in plain English, refine every step in the editor, and wire it to Google Sheets. Free credits at signup, no card required.
Start Building FreeAbout the Author
Flowyte Team
Product Team
The team behind Flowyte, the AI agent studio for phone and chat. We build the product, run it on our own phone lines, and write these guides from what we ship and test - not from theory.
