Skip to main content
This guide teaches you how to use the Ability Engine — Z360’s visual workflow builder — to design exactly how your AI agent handles customer conversations. By the end, you’ll be creating abilities that feel natural, collect the right information, and take action automatically. No technical background required. If you can describe how you’d train a new employee to handle a phone call, you can build an ability.

​
What Is the Ability Engine?

The Ability Engine is a visual tool where you create step-by-step instructions that tell your AI agent how to handle specific types of customer conversations. Think of it like training a new employee. When you hire someone, you don’t hand them a word-for-word script — you give them guidance. “When a customer calls about scheduling, ask them these questions, collect this information, then create an appointment.” The Ability Engine works the same way. You’re teaching your AI agent how to think through a conversation, not writing an exact script for it to read. Each set of instructions you create is called an ability. Your AI agent can have many abilities — one for each type of conversation it needs to handle. When a customer reaches out, the agent recognizes what kind of help they need and automatically selects the right ability to follow. Here’s the big picture of how it works:
  1. A customer reaches out with a request (via chat, email, phone, or SMS)
  2. Your AI agent recognizes what kind of help they need
  3. The agent selects the appropriate ability you’ve created
  4. The agent follows your step-by-step instructions
  5. The customer gets a helpful, natural conversation experience
Every ability follows a simple mental model: “When this happens, do that.”
  • When a customer wants to schedule an appointment → collect their information and create a booking
  • When a lead asks about pricing → qualify their needs and create a ticket for follow-up
  • When someone calls after hours → collect their message and assure them someone will call back

​
Key Concepts

​
The Four Parts of Every Ability

Every ability you create has four parts:
A clear title for this ability (e.g., “Appointment Scheduler”, “New Patient Intake”, “After-Hours Message Collector”). Avoid vague names like “Ability 1” or “Phone Calls.”
What this ability accomplishes. Write it like you’re explaining the ability to a colleague: “Helps customers schedule service appointments by collecting their preferred time, contact details, and the type of service they need.”
How the AI knows when to use this ability. Describe the customer’s intent in natural language. Good triggers describe what the customer is trying to do, not specific keywords. For example: “When a customer reports a service issue, needs a repair, has a problem with their system, or requests service assistance.” The AI understands context and meaning, so you don’t need to list every possible phrase.
The step-by-step conversation logic. This is the visual workflow you build using nodes.

​
Nodes: Your Building Blocks

Nodes are the individual steps in your flow. There are six types:
Where the conversation begins. Think of it as the entry door. Every ability has exactly one, it’s created automatically, and you can’t delete it. No configuration needed.Every ability begins with a Start node. It’s created automatically when you create a new ability, you can’t delete it, and it doesn’t need any configuration. Just connect it to whatever node comes next in your flow.
Collects information from the customer. Think of it as a question to ask. You write a prompt telling the AI what information to gather, and a variable name to save the answer.The Ask node is how your AI collects information from the customer. It has two fields:Prompt — Instructions for what to ask. This is guidance for the AI, not an exact script. The AI will phrase the question naturally based on your instructions.Save As — The variable name where the customer’s answer gets stored so you can use it later.Example:
  • Prompt: “Find out what issue the customer is experiencing. Ask them to describe what’s happening with their system. If they’re vague, ask follow-up questions to get specifics. Show empathy.”
  • Save As: issue_description
Tips for writing great Ask node prompts:Give context, not scripts. Tell the AI what information you need and why, not the exact words to say. Instead of “Say: What is your name?”, write “Ask the customer for their full name so we can create their service record.”Combine related questions. Use one Ask node for “full name” instead of separate nodes for first name and last name. The AI is smart enough to collect both naturally.Include fallback guidance. Tell the AI what to do if the customer isn’t sure: “If the customer doesn’t know the exact model number, ask them to describe what the unit looks like or where it’s located.”
Says something to the customer. Think of it as a statement to make. Use it for acknowledgments, confirmations, instructions, next steps, or closing messages.The Speak node communicates something to the customer without collecting information. Use it for:
  • Acknowledging what the customer said (“Thanks for sharing that, I understand the situation”)
  • Confirming information back to them (“Let me make sure I have this right…”)
  • Providing instructions or next steps (“Here’s what will happen next…”)
  • Delivering a closing message (“A technician will call you within the hour”)
Like the Ask node, the prompt is guidance for the AI — it will communicate the message naturally.
Performs an action like creating a ticket, submitting an inquiry, or calling an external tool. Think of it as an action to take.The Act node performs an action or calls a tool. This is where your ability actually does something beyond just talking. It has three fields:Action — Which action to perform (e.g., “Create Ticket”, “Submit Inquiry”, “Move Stage”).Inputs — The parameters the action needs, which can reference variables you’ve collected. For example, a Create Ticket action might use {customer_name}, {issue_description}, and {urgency_level} as inputs.Save As — A variable to store the action’s result (optional), so you can reference the outcome later in the flow.Z360 comes with these built-in actions:
  • Create Ticket — Creates a support ticket for follow-up. Key inputs: subject, description, priority.
  • Submit Inquiry — Submits or updates an inquiry in a pipeline. Inputs depend on the pipeline fields.
  • Move Stage — Moves an inquiry to a different stage within its pipeline. Key input: target stage.
  • Get Inquiry Fields — Retrieves information about an existing inquiry. Key inputs: pipeline name, identifier.
Beyond the built-in actions, you can also use external integrations (like Google Calendar to create events or check availability, Gmail to send emails or create drafts) and any custom actions or MCP tools you’ve configured in AI Studio → Actions.
Makes a decision based on information and branches the conversation in different directions. Think of it as a fork in the road.The Condition node evaluates information and branches the conversation into different paths. It has three fields:Variable — What to check (e.g., urgency_level).Operator — How to compare. Options include:
  • equals / == — is exactly
  • not equals / != — is not
  • contains — includes the text
  • > / < — greater than / less than
Value — What to compare against (e.g., “emergency”).The Condition node gives you three types of branches:
  • IF — the primary condition is true
  • ELIF — an alternative condition is true (you can have multiple)
  • ELSE — none of the above conditions were met
Always include an ELSE branch. This catches unexpected situations and prevents your flow from getting stuck. Even if you think every possibility is covered, things won’t always go as expected.An important tip: write conditions for intent, not exact words. Instead of checking if urgency_level equals “emergency” as an exact string, describe the condition in a way that captures the meaning. The AI evaluates conditions based on understanding, not rigid text matching.
The End node concludes the ability and returns control to the main agent. A few guidelines:
  • Always precede an End node with a Speak node — don’t let the conversation end abruptly
  • Be specific about the reason for ending (this helps with tracking and analytics)
  • You can have multiple End nodes for different outcomes (e.g., one for “ticket created successfully”, another for “customer decided not to proceed”)
When your AI collects information from a customer, it saves that information in variables so it can use it later. For example:
  • Customer says their name is “Maria” → saved as customer_name
  • Customer wants a “Tuesday appointment” → saved as preferred_day
  • Customer’s issue is “AC not cooling” → saved as issue_description
You reference saved variables later using curly braces: {customer_name}. For example, a Speak node could say: “Thanks, customer_name! Let me help you with that.”

​
Your First Ability: Step-by-Step Tutorial

Let’s build a real ability from scratch. We’ll use the example of an HVAC company that wants its AI agent to handle incoming service requests.
Before opening the Ability Engine, answer these questions:What’s the goal? Collect service request details from the customer and create a ticket for the service team.What information do we need?
  • What’s the issue? → issue_description
  • Customer’s name → customer_name
  • Customer’s phone number → customer_phone
  • How urgent is it? → urgency_level
Any decision points? Not for this first ability — we’ll keep it simple with a straight-through flow.What actions need to happen? Create a ticket with all the collected information.What should the customer know at the end? That their request has been submitted and when to expect a callback.
Go to AI Studio → Abilities and create a new ability.Name: Service Request CollectorDescription: Handles incoming service requests by understanding the customer’s issue, collecting their contact information, determining urgency, and creating a ticket for the service team to follow up.Triggers: When a customer reports a service issue, needs a repair, has a problem with their system, or requests service assistance.
Connect the following nodes in order:Start → connects to your first Ask node.Ask: Get Issue Description
  • Prompt: “Find out what issue the customer is experiencing. Ask them to describe what’s happening with their system. If they’re vague, ask follow-up questions to get specifics. Show empathy — they’re dealing with a problem.”
  • Save As: issue_description
Ask: Get Customer Name
  • Prompt: “Ask the customer for their full name.”
  • Save As: customer_name
Ask: Get Phone Number
  • Prompt: “Ask for the best phone number to reach them for scheduling the service visit.”
  • Save As: customer_phone
Ask: Determine Urgency
  • Prompt: “Assess how urgent the issue is. Ask if the system is completely non-functional, if there’s a safety concern (like a gas smell or water flooding), or if it’s something that can wait a day or two. Categorize as emergency, urgent, or routine.”
  • Save As: urgency_level
Act: Create Ticket
  • Action: Create Ticket
  • Subject: “Service Request - issue_description”
  • Description: Use the collected variables to populate the ticket details
  • Priority: “If urgency indicates immediate need, set to ‘high’. Otherwise, ‘normal’.”
Speak: Confirmation
  • Prompt: “Thank the customer by name. Confirm that their service request has been submitted. Tell them a team member will reach out within [timeframe based on urgency]. Ask if there’s anything else they need.”
EndThat’s it — you’ve built your first ability!

​
Real-World Examples

Name: New Patient IntakeDescription: Qualifies new patient inquiries by collecting required information and scheduling consultations. Handles both insured and cash-pay patients.Flow:
  • Start → Ask what brings them in → Condition: are they interested in booking?
    • IF interested → Ask about insurance → Condition: payment type
      • IF insurance → Ask for insurance details → Act: Create ticket for insurance verification → Speak: confirmation → End
      • ELSE cash pay → Ask for basic contact info → Act: Create ticket for cash consultation → Speak: confirmation → End
    • ELSE not ready → Act: Create nurture ticket → Speak: “No problem, we’re here when you’re ready” → End
Name: Emergency Triage HandlerDescription: Evaluates plumbing requests to determine if they’re emergencies or routine issues, and routes them accordingly.Flow:
  • Start → Ask to describe the issue → Ask to assess urgency → Condition: emergency or routine?
    • IF emergency → Ask for location/address → Act: Create URGENT priority ticket → Speak: “A plumber will call you within 15 minutes” → End
    • ELSE routine → Ask for contact information → Act: Create standard priority ticket → Speak: “We’ll get back to you within 24 hours” → End
Name: Appointment Reschedule HandlerDescription: Handles patient requests to cancel or reschedule appointments. Applies cancellation policy when the request is within 24 hours.Flow:
  • Start → Ask to verify patient identity → Ask: cancel or reschedule? → Speak: explain cancellation policy → Ask: is this within 24 hours of the appointment? → Condition: within 24 hours?
    • IF yes → Ask: do they want to proceed with the cancellation fee? → Condition: proceed?
      • IF yes → Act: Create ticket with fee noted → Speak: confirmation → End
      • ELSE no → Speak: “No problem, we’ll keep your original appointment” → End
    • ELSE no (more than 24 hours away) → Ask for preferred new time → Act: Create reschedule ticket (no fee) → Speak: confirmation → End

​
Best Practices

​
Think Like You’re Training an Employee

The most important mindset for building abilities: you’re teaching, not scripting. You don’t write exact lines for the AI to say — you give it guidance on how to handle the situation, what information to collect, and what actions to take. The AI handles the natural conversation part on its own.
Start and end with Speak nodes. Open with a warm acknowledgment and close with clear next steps. Don’t let conversations begin or end abruptly.Give context in your prompts. Instead of “Ask for name”, write “Ask the customer for their full name so we can create their service record.” The more context you give, the more naturally the AI communicates.Use natural acknowledgments between steps. After a customer shares information, the AI should acknowledge it before moving to the next question. You can guide this in your prompts: “After they describe the issue, acknowledge their situation with empathy before asking for their contact details.”Write descriptive variable names. Use customer_phone_number instead of phone or var1. Clear names make your flows easier to maintain and debug.Always have an ELSE branch on conditions. Every Condition node should have an ELSE path that handles unexpected responses. This prevents the conversation from getting stuck.
Don’t create separate nodes for every tiny piece of information. If you need a name and email, one Ask node can collect both. The AI is smart enough to gather multiple related pieces of information naturally.Don’t overcomplicate with unnecessary conditions. Only add Condition nodes where the conversation flow genuinely differs. If both branches do roughly the same thing, you probably don’t need the condition.Don’t forget the ELSE branch. This is worth repeating — an uncovered scenario means the conversation breaks.Don’t leave Save As empty when you need the information later. If another node references a variable, make sure an earlier Ask node is saving to that exact variable name.Don’t write exact scripts. The AI works best when you give it intent and context. Writing word-for-word scripts makes the conversation sound robotic and removes the AI’s ability to adapt naturally.

​
Natural Conversation Checklist

Before you publish an ability, run through this checklist:
  • Does the opening feel warm and welcoming?
  • Are acknowledgments included after the customer shares information?
  • Does the flow avoid asking for the same information twice?
  • Are transitions between topics smooth?
  • Does the closing set clear expectations about what happens next?
  • Would this feel like talking to a helpful human?

​
Designing Abilities: The Blueprint Process

Before you start building in the Ability Engine, take a few minutes to answer these five questions on paper or in your head:
  1. What is the goal? What should be accomplished when this ability runs successfully?
  2. What information do you need? List every piece of data you need to collect from the customer.
  3. What are the decision points? Where might the conversation branch depending on what the customer says?
  4. What actions need to happen? Tickets to create? Emails to send? Calendar events to check?
  5. What should the customer know at the end? What are their clear next steps?
Once you have your answers: Start with the happy path. Build the simple, successful scenario first — the customer provides everything you need, no complications. Add branches where needed. Only add Condition nodes where the flow genuinely differs based on the customer’s response. Include error handling. What if the action fails? What if the customer gives unexpected answers? Your ELSE branches cover these cases. Test the complete flow. Walk through it as if you were the customer. Does every path feel natural? Does every branch reach an End node?

​
Troubleshooting

  • Are your nodes connected properly? Check that every node connects to the next one in the intended order.
  • Are your prompts clear? Vague instructions lead to unpredictable behavior.
  • Are you saving variables that you reference later? If an Act node uses {customer_name}, make sure an earlier Ask node saves to customer_name.
  • Is the Save As field filled in on your Ask node? If you don’t save the answer, the AI doesn’t remember it.
  • Is the variable name consistent? customer_name and customerName are treated as different variables. Pick one spelling and use it everywhere.
  • Is the variable name exactly the same as what you used in the Save As field? Even a small typo breaks the connection.
  • Are you writing conditions for intent, not exact words? The AI evaluates meaning, so “emergency” as a condition should match responses like “this is urgent” or “we need help right away.”
  • Are all required inputs provided? Check that every required field in the Act node has a value or variable reference.
  • Are the instructions clear? If you’re using variables as inputs, make sure they’re being saved correctly by earlier nodes.
  • Is the external service connected? If the action uses a third-party integration (like Google Calendar), verify it’s still connected in AI Studio → Actions.

​
Quick Reference

​
Node Summary

NodePurposeWhat to Configure
StartEntry point of the flowNothing — it’s automatic
AskCollect information from the customerPrompt (what to ask), Save As (variable name)
SpeakSay something to the customerMessage content/guidance
ActPerform an actionAction type, Inputs, Save As (optional)
ConditionBranch based on informationVariable, Operator, Value
EndConclude the conversationReason for ending

​
Condition Operators

OperatorMeaning
equals / ==Is exactly
not equals / !=Is not
containsIncludes the text
>Greater than
<Less than

​
Built-in Actions

ActionPurposeKey Inputs
Create TicketCreate a support ticket for follow-upSubject, description, priority
Submit InquirySubmit or update an inquiry in a pipelinePipeline-specific fields
Move StageMove an inquiry to a different pipeline stageTarget stage
Get Inquiry FieldsRetrieve information about an existing inquiryPipeline name, identifier