Botmaker gives you two ways to automate your customer service. In Botmaker 2.0, you design the conversation block by block in Bot Designer: you define what the bot says, what it expects from the user, and where the conversation goes in each case. In Botmaker 3.0, you describe in natural language the goal you want to achieve, and a team of AI Agents, coordinated by an Orchestrator, decides step by step how to get there. Both approaches coexist on the platform. The difference lies in how you build and maintain your bot, not in what your business can achieve.

With this comparison, you can:

• Understand how each feature you already know from 2.0 works in 3.0.
• Identify what each way of working offers, depending on the type of process you automate.
• Recognize the 3.0 concepts (orchestrator, agent, Funnel, capabilities) based on what you already use.
• Take your first steps in 3.0 with a single agent, at your own pace.

Key concepts

Bot Designer (2.0): flow diagram interface where you build the conversation with color-coded blocks: bot responses (blue), user inputs (green), actions (orange), and conditions (yellow).

Master Bot and Multibot (2.0): features that let you have several chatbots specialized by topic and manage how they are organized and ranked relative to one another.

AI Instructions (2.0): generative block within a Bot Designer chatbot that achieves a goal in the conversation without you having to design every response. It was formerly called "AI Agent" and should not be confused with the AI Agents in 3.0.

Orchestrator (3.0): the entry point of your project. It receives messages from the channel, talks to the user in the tone you define, and decides which AI Agent to ask for help with each query. It's the only one that talks to the user.

AI Agent (3.0): a unit specialized in resolving a specific business goal (for example, booking an appointment or qualifying a lead). One agent equals one goal. It doesn't talk to the user directly: it completes its task and returns the result to the orchestrator.

Description (activation) (3.0): a short, natural-language phrase of about 10 to 15 words that states when an agent should be used. The orchestrator reads it to decide where to route each query.

Funnel (3.0): the process an agent follows to meet its goal. It's built with states, where each state is a step (for example, "Data request" or "Appointment confirmation").

Capabilities or Tools (skills) (3.0): resources the agent can use to carry out its process: logics, knowledge bases, integrations, MCP, and code actions.

Logic (3.0): an ordered sequence of steps within an agent, for when order matters. It's built with instruction, conditional, and loop blocks.

MCP (Model Context Protocol) (3.0): a standardized connector to an external system, such as a CRM, a calendar, or a database.

Human in the Loop (HITL) (3.0): a way of working in which the AI agent moves the case forward and a person validates, approves, or resolves an exception.

Token: the unit used to measure an AI model's processing. It's the basis of generative usage.

Comparison summary

Below, we explain each row in detail.

How each feature works in 2.0 and in 3.0

1. How you design your bot

In 2.0: you go to Menu → Chatbots, choose the chatbot, and build the main flow in Bot Designer. You add blocks with the + on the diagram's arrows and define every response, every user input, and every possible path. Besides the main flow, you set up alternative flows: disambiguation, when the bot doesn't understand, agents, notifications, video calls, and others.

In 3.0: you create an AI Agent, write in its Profile tab a description of when it should be used, and build its process in the Funnel tab with states. In each state you describe in your own words what should happen: what data to ask for, who resolves it, and how to behave. You don't draw every possible response: the agent interprets the conversation and decides the next step based on context.

If you'd rather not build the structure by hand, the AI Assistant (in the bottom right corner of Design AI agents) creates the agent from what you tell it, for example: "Create a sales agent that answers questions about the products and hands off to a human when the customer asks for it." Then you review and adjust what it generated.

What it gives you: when a process has many variations (questions out of order, changes of mind, data that all arrives at once), you don't need to anticipate every path in the diagram. You describe the goal and the agent adapts to the way each customer talks.

2. How bots are organized and where each query is routed

In 2.0: with Multibot you have several chatbots specialized by topic, and with Master Bot you manage how they're organized and ranked. The main link is bot + channel.

In 3.0: the main link becomes channel + orchestrator. Each channel connects to a single orchestrator, and the orchestrator has several agents assigned to it. You don't program the routing logic: the orchestrator reads each agent's description (activation) and picks the most suitable one. It can also consult more than one agent for the same response and switch from one agent to another as the conversation moves along.

The relationships are as follows:

• 1 channel = 1 orchestrator. This keeps conversations from getting mixed up.
• 1 orchestrator = N agents. There's no maximum number of agents per orchestrator.
• 1 agent = N orchestrators. You reuse the same agent across different channels without duplicating it.

What it gives you: the orchestrator plays a role similar to Master Bot's, but broader: besides routing, it converses, keeps your brand's tone, and synthesizes a single response from what each agent contributes.

3. How the bot understands what the user writes

In 2.0: the bot recognizes what the user writes through triggers and natural language blocks. When a message activates more than one option, the disambiguation flow steps in; when it doesn't match anything, the when the bot doesn't understand flow does. If you turn on generative mode in Identity and preferences, you add general natural language and content bases to answer messages that weren't understood.

In 3.0: the agent interprets the intent of the message based on the goal you gave it. You don't need to load word variations or set up a separate flow for every unexpected situation. The models are also multimodal: they understand text, audio, images, and video. For example, if a customer sends a photo of a promotion over WhatsApp, the agent understands its content to take the order.

What it gives you: less maintenance of triggers and variations, and consistent responses even when the customer writes in a way you didn't anticipate.

4. How you set personality, tone, and language

In 2.0: the generative identity is set up in the Identity and preferences menu of each bot.

In 3.0: tone, style, and restrictions are defined once, on the orchestrator, and every agent inherits them. This keeps different agents from receiving contradictory instructions. In the Tone and style section you define the tone (formal, informal, friendly, or technical), response length, personality, and language; you can also enable dynamic buttons. In the Restrictions section you describe what it must not say or promise (for example, don't mention competitors or don't give quotes).

As for language: you can set a specific one or ask it to adapt to the user's. If someone writes in English, it replies in English; if they write in Spanish, it replies in Spanish. It goes by how the person writes, not by the phone number's country code.

What it gives you: you serve customers in several languages without building one bot per language. And if you want to sound different on each channel, you create another orchestrator (for example, a more casual one for Instagram) and reuse the same agents.

5. How user data is stored

In 2.0: you ask for data with input blocks (natural language, buttons, lists, forms, or carousel) and store it in variables to use later in the flow.

In 3.0: the bot has conversational memory: it remembers what was said throughout the conversation without you telling it to store each piece of data. When a step needs specific information, you add it in the state's What data is required when reaching this state? section in the Funnel. The agent asks for it, and the data becomes available to the following states. If you'd rather it ask for each item one at a time, conversationally and not like a form, say so in the orchestrator's tone and style.

Variables are still there, with a different role: you use them when data needs to go out to, or come in from, an external system, that is, in integrations and code actions.

What it gives you: less setup for the conversational side and fewer variables to maintain.

6. How the bot answers with your content

In 2.0: with generative mode on, you use content bases, for example to answer messages the flows can't interpret.

In 3.0: you upload your bases in the agent's Knowledge tab. They accept PDF, DOC, XLSX, or TXT documents, or a web page URL. You can also add them to a specific state from Instructions for the agent, if that content only applies to one step of the process.

What it gives you: each agent only consults the content that's relevant to it, which makes its answers more accurate.

7. How you connect other systems and run actions

In 2.0: you use action blocks (the orange ones in Bot Designer) and code actions within the flow.

In 3.0: you connect everything from the agent's Tools (skills) tab. There you add:

• Integrations such as Google Sheets or Google Calendar. First you integrate the service with the project (you link the account, once), and then you connect it to the agent, choosing which actions it can use.
• MCP, to connect tools from external systems such as a CRM or a database.
• Code actions, for custom integrations.
• Logics, for step sequences (see the next item).

For each resource, you write when it will be used by the agent. Why it matters: the agent decides which tool to use based on that description. "When the patient requests an appointment and has already provided their details" works much better than "For appointment topics."

What it gives you: the agent decides when to use each tool based on the conversation, without you having to place the action at a fixed point in the diagram. Botmaker 3.0 also lets you automate internal processes that aren't conversational, such as entering invoices or running administrative routines across your CRM, your ERP, and your spreadsheets.

8. How you keep control when order matters

In 2.0: you use condition blocks (the yellow ones) to branch depending on whether a condition is met, for example, the user's language.

In 3.0: when you need the agent to follow steps in an exact order, you create a logic. Logics are built with three types of block:

• Instruction: a directive to the agent, such as "Ask the patient for their ID number." It's the most commonly used.
• Conditional: branches based on a condition, such as "If the insurance plan is X, show the premium time slots."
• Loop: repeats steps over a set of items. It's rarely used in conversation.

You'll get better results with several small boxes, each holding one instruction, rather than one large box with several chained instructions, because the model processes separate instructions better.

What it gives you: you keep control of the steps that need to follow an order. You combine the agent's flexibility with rule-based sequences wherever you need them.

9. How a person steps in

In 2.0: you set up the agent flow (user waiting, no agents available, user assigned, close conversation) and hand the conversation off to live chat.

In 3.0: in each Funnel state, in the Who resolves this step? section, you choose one of three options:

• AI Agent: the agent resolves the step autonomously.
• Human in the Loop: the agent moves forward and a person validates or approves. Ideal for approvals, complaints, or sensitive cases.
• Human agent: a person resolves the step from start to finish, with no AI involvement.

If you choose Human in the Loop or Human agent, in Who attends? you select a support team or a specific person. Intervention requests arrive as cards in the tickets section.

What it gives you: you decide the level of human involvement step by step, not just for the whole conversation. According to Botmaker's internal testing, Human in the Loop can reduce manual work by up to 82%.

10. How you track each case

In 2.0: you follow conversations from the chats section.

In 3.0: every time an agent starts its Funnel, a ticket linked to the conversation is created. Tickets appear in a section below Chats and also from the agent itself. There you can see the process status, internal comments, linked conversations, and activity. You can view them as a list or as a Kanban board, where each column is a Funnel state, and move a ticket to another state manually as long as the process conditions are met. The ticket is unique and follows the case even when different agents are involved.

What it gives you: you can see what stage each business process is at, not just each conversation.

11. How you run actions without the customer writing in

In 2.0: you use the notification flow, linked to the campaigns and templates you set up in Notifications Engine.

In 3.0: from the agent's Automations tab you create actions that trigger on their own, in two ways:

• By time: at a specific moment or on a schedule (every hour, every Monday at 9 a.m., on the 1st of every month).
• By state change: when a conversation or ticket reaches a specific Funnel state.

For example: sending an appointment reminder 24 hours ahead, loading data into the CRM when an appointment is confirmed, or sending a satisfaction survey the day after the visit.

What it gives you: automatic actions stay tied to the agent's process and trigger based on the stage each case is at.

12. How you test and publish

In 2.0: you use the Test chat on the right side of Bot Designer, the play button on any block to test from that point, and Publish to choose which blocks go to production, along with their change history.

In 3.0: you go to the orchestrator and click Test, at the top right. Testing the orchestrator is equivalent to testing the complete bot. As you chat, you see the orchestrator's reasoning, and with View details you can tell which agent it routed to and which Funnel state it's in. Type @reset to clear the context and start from scratch.

In addition:

• Executions shows you the history of real conversations with the reasoning behind each one. End users don't see this reasoning, and only the project's authorized profiles can access it.
• History shows you previous versions of each agent in read-only mode. You can apply a version in development, to keep working on it, or in production, which is equivalent to publishing it.
• Changes are saved automatically and several people can edit at the same time. Going to production is still a separate action, with Publish.

What it gives you: you understand why the bot answered the way it did, which makes it easier to fine-tune.

13. How usage is measured

In 2.0: you work with your plan's model (per session, MAU, or DAU), plus generative usage if you use generative AI features.

In 3.0: the per-session, MAU, and DAU models work the same way, with generative usage by tokens added on top. Creating agents, orchestrators, or automations has no cost in itself: usage shows up when the agent runs and handles requests. You can see the breakdown by project, by model, and by function under Account → Products and usage, including how much each agent, each orchestrator, and Human in the Loop consume. The AI model can be selected per orchestrator or per agent.

What it gives you: you can attribute usage to each area of your business.

How do you know if 3.0 fits what you need?

If your bot follows a short, stable path, such as a menu of fixed options, Bot Designer gives you visual control of each block. Botmaker 3.0 tends to be a better fit when:

• Your customers ask for the same thing in many different ways, or give information in a different order.
• Your process has several stages you want to track end to end (for example, from inquiry to sale, or from request to confirmed appointment).
• You need a person to validate some steps, but not all of them.
• You serve customers in several languages or channels and want to keep the same team of agents.
• You want to connect external systems (calendar, CRM, spreadsheets) and have the bot decide when to use them.

A good starting point is to choose a single process, such as booking appointments or qualifying leads, and build it as an agent. That way you get to know this way of working with a concrete case.

Important considerations

• One orchestrator per channel: each channel connects to a single orchestrator. A single orchestrator, however, can have several channels.
• Per-channel memory: the bot remembers context within the same channel, but it doesn't recognize the same person on its own if they write in through another channel. To recognize them across channels, you need an external system (CRM or spreadsheet) that uses a piece of data as an identifier.
• Testing: you can't test an agent on its own; the complete bot is tested from the orchestrator. You can, however, test a logic in isolation.
• Duplicating agents or orchestrators: copying them isn't possible yet, so setup is done manually. You can, however, reuse the same agent across several orchestrators.
• Clear descriptions: routing quality and tool usage depend on the descriptions you write. The more specific they are, the better the bot decides.
• Token-based usage: usage depends on the selected model and how much work each agent does. Review it regularly under Account → Products and usage.
• Human in the Loop: at this stage, the person mainly acts as a validator or approver within the process, while the agent keeps handling the conversation with the user. This feature is evolving.

Remember to visit our Help Center for further information.