Whatsable
A practical guide to building a WhatsApp bot that uses Make AI Agents, Google Sheets inventory lookups, and WhatsAble for messaging, with human escalation when your customer needs a real person.
What you will build
By the end of this guide you will have a working Make scenario where:
- A Make AI Agent receives WhatsApp messages through WhatsAble and reasons about the customer's request.
- The agent queries a Google Sheets spreadsheet (for example, a car rental fleet list) to answer availability questions on the spot.
- When the customer asks to speak to a person, or the agent hits a wall, it calls a human-notify tool that sends a WhatsApp message to your teammate with the context of the problem.
- A coexistence filter pauses the bot as soon as the human teammate replies, so the customer never gets two voices at once.
Loom note. The primary architecture in this article comes from a live WhatsAble configuration meeting (Axel Meta, September 2026) that walked through Make AI Agent tool assignment, WhatsAble send, and human escalation via a Make scenario. The Google Sheets car-rental example is an illustrative worked example drawn from Axel's verbal description and Make's public inventory how-to pattern. Screenshots reference only verified strings from that meeting.
Maia vs Make AI Agents: build-time and runtime are different things
Before you wire anything, clear up the naming. People search for "Maya agent" or "Make Maya WhatsApp," but the official spelling is Maia and it is not the same product as Make AI Agents.
| Maia by Make | Make AI Agents (+ Sub-Agents) | |
|---|---|---|
| What it is | A build-time conversational co-worker inside Make's Scenario Builder | Runtime agents that reason, pick tools, and call them during scenario execution |
| When it runs | While you are designing or editing a scenario | Every time a scenario triggers (a new WhatsApp message, a schedule, a webhook) |
| What it produces | A visible scenario on the canvas, complete with modules, connections, and routes | Decisions: which tool to call, what to say, when to escalate |
| Sub-Agents | Can scaffold an agent that includes Sub-Agents | Sub-Agents are specialist agents added as tools, one nesting level deep |
| WhatsAble relationship | Can build a scenario that includes WhatsAble modules (same as any of 3000+ apps) | Calls WhatsAble modules at runtime to send or receive WhatsApp messages |
Maia helps you build the scenario. Make AI Agents run it. Do not collapse them into one SKU, and do not call Maia "the agent orchestrator." The orchestration happens at runtime through the AI Agent and its Sub-Agents.
If you see someone write "Maya" instead of "Maia," they mean the same builder product. The official spelling is Maia.
Official resources:
- Maia marketing page: make.com/en/maia
- Maia help article: help.make.com/introduction-to-maia-by-make
- Make AI Agents marketing: make.com/en/ai-agents
- Create your first AI Agent: help.make.com/create-your-first-ai-agent
- Sub-Agents spotlight: community.make.com/t/feature-spotlight-make-ai-sub-agents/112628
Set up WhatsAble as your WhatsApp channel
The WhatsApp side of this build uses the WhatsAble for WhatsApp Business app on Make's public marketplace. It is a verified listing, not a private invite.
Listing: make.com/en/integrations/whatsable-message (slug whatsable-message)
Why WhatsAble instead of Make's WhatsApp Business Cloud modules?
They are different channels. Make offers its own WhatsApp Business Cloud integration, but this guide uses WhatsAble modules exclusively. WhatsAble gives you a shared inbox, coexistence fields that tell your scenario whether a human teammate has replied, and a single API-key connection that works across triggers and actions. If you already use WhatsAble for other Make scenarios, you are adding the AI Agent layer on top of the same connection.
Install and connect
- In your Make scenario, click the + button and search for WhatsAble or WhatsAble for WhatsApp Business.
- Add a trigger. You have two options:
- Incoming Messages from console (Notifyer System) receives only inbound customer messages. This is the simpler choice if your scenario is purely reactive.
- Incoming & Outgoing Messages from console (Notifyer System) receives both directions. You will need a filter after the trigger (covered in the coexistence section below) to avoid processing your own outbound messages in a loop.
- When prompted, create a connection by entering your WhatsAble API key. The trigger also creates a webhook endpoint inside Make. Follow the WhatsAble Make docs for the exact steps.
Send a reply
To send a WhatsApp message back to the customer, add the Send WhatsApp Message action module from the same WhatsAble app. Map the phone number and message body from the trigger output or from the AI Agent's response.
Other useful WhatsAble actions:
- Schedule a follow-up Message for timed nudges (e.g. "still interested?").
- Update a Contact to tag the conversation with labels or metadata.
- Get delivery status of a message for read/delivered confirmation.
The "(Notifyer System)" label you see in module names is the live chrome in Make's UI. In your scenario narrative, the product is WhatsAble.
Add Google Sheets inventory tools (illustrative car-rental example)
Not from the Loom. This section is an illustrative worked example based on Axel's verbal description and Make's public inventory how-to. The Loom configuration meeting focused on tool assignment, WhatsAble messaging, and human notify. The car-rental scenario shown here demonstrates the Sheets pattern with the same architecture.
Imagine you run a small car-rental business. You keep fleet availability in a Google Sheets spreadsheet with columns like:
| car_id | model | status | location | available_from | available_to |
|---|---|---|---|---|---|
| 001 | Toyota Corolla | available | Airport | 2026-09-20 | 2026-10-15 |
| 002 | VW Golf | rented | Downtown | 2026-09-25 | 2026-10-01 |
| 003 | Ford EcoSport | available | Airport | 2026-09-18 | 2026-10-10 |
A customer messages your WhatsApp number: "Do you have anything free at the airport from September 22 to 28?"
Wire the Sheets tools into your agent
Make AI Agents call tools. A tool can be a single module or an entire sub-scenario. For inventory lookups:
Option A: Module as tool. Attach Google Sheets > Search Rows directly as a tool on your Make AI Agent module. The agent sends the search criteria (location, date range); the module returns matching rows. This is the fastest setup for simple lookups.
Option B: Scenario as tool. Create a separate scenario with Scenario Inputs (location, date_from, date_to) that searches the sheet, filters available cars, and returns structured results via Return output. Then add that scenario as a tool on your agent. This is cleaner when the lookup involves multiple steps (searching, filtering, formatting a list).
Either way, the agent receives the rows and composes a natural-language reply: "We have a Toyota Corolla and a Ford EcoSport at the Airport for those dates. Want me to hold one for you?"
You can also add an Update Rows tool so the agent can mark a car as "held" or "reserved" after the customer confirms, then send a WhatsApp confirmation through the WhatsAble Send module.
This same pattern works for hotel rooms, appointment slots, product SKUs, or any inventory you keep in Sheets. The spreadsheet columns are illustrative. Adapt them to your business.
Human escalation: when the bot should step aside
Not every conversation should stay with the agent. A customer might ask something the agent cannot answer, or explicitly say "let me talk to a person." This is where the human-notify path comes in.
What the Loom showed
In the configuration meeting, the Make AI Agent was set up with two named tools:
whatsablefor sending WhatsApp messages through WhatsAble.Conectar con Humanfor escalating to a human teammate.
The Conectar con Human tool calls a Make scenario that sends a notification to a teammate with context about the conversation. The scenario uses a WhatsApp template named Mano humana problema uno and expects three parameters:
name: the customer's name or identifier.problem: a short description of what the customer needs help with.comments: any additional context the agent has gathered during the conversation.
whatsable (WhatsApp send) and Conectar con Human (human escalation).
Mano humana problema uno with parameters name, problem, and comments.
How to build the human-notify path
You have several documented approaches. Pick the one that fits your team:
1. Prompt the agent to escalate.
In the AI Agent's system prompt, instruct it: "If the customer asks to speak to a person, or if you cannot resolve the request, call the Conectar con Human tool with the customer's name, a summary of the problem, and any relevant comments." The agent decides when to escalate based on its reasoning.
2. Use a Sub-Agent as the escalation specialist. Create a Make AI Sub-Agent dedicated to human escalation. The parent agent delegates to it when the conversation hits a boundary. The Sub-Agent calls the notify scenario, sends a message to the customer ("I'm connecting you with a teammate"), and pauses.
3. Send a WhatsApp message to a teammate's phone number. Use the Send WhatsApp Message action to send directly to a teammate's personal or work WhatsApp number. This is a simple alert: "Customer [name] needs help with [problem]." No new module or invented API required; it is the same Send action pointed at a different number.
4. Label and update the contact.
Use the Update a Contact action to add a label like needs-human to the contact record. Your team can filter by that label in the WhatsAble inbox. Combine this with the WhatsApp notification for redundancy.
These paths are not mutually exclusive. The Loom setup combines prompt-driven escalation (the agent decides), a scenario tool call (structured parameters), and a templated WhatsApp message to the teammate.
What is NOT documented: There is no dedicated "Send message to human" or "Handoff" module in the WhatsAble Make app. Human notification is built from the same Send, Update, and labeling modules you already have. The intelligence is in the agent's prompt and tool configuration, not a special product toggle.
Coexistence: pause the bot when a human replies
Once your teammate takes over a conversation, the AI Agent needs to stop auto-replying. Otherwise the customer sees two voices, the bot and the human, overlapping.
Set up the dual trigger + filter
If you are using the Incoming & Outgoing Messages from console (Notifyer System) trigger (which catches messages in both directions), add a Filter module immediately after the trigger.
Important Make detail: a Filter continues when its condition is true. So you set the Filter to continue only for customer inbound, not for the "stop" case.
Preferred Filter (continue when customer inbound):
Continue when: incoming_message = trueOptionally tighten so bot-originated noise is also dropped:
Continue when: incoming_message = true
AND was_message_by_human = falseWhen a teammate replies from the WhatsApp app, the event usually has incoming_message = false and/or was_message_by_human = true (and often send_by = "WhatsApp App"). Those executions fail the Filter, so the AI Agent path does not run and the bot does not pile an auto-reply on top of the human.
Alternative: Router (stop/branch)
If you prefer Ken's "stop/branch" wording, put a Router after the dual trigger instead of a single Filter:
- Route Human / outbound when
incoming_message= false AND (was_message_by_human= true ORsend_by="WhatsApp App") → leave this route empty (no AI Agent modules). - Route Customer inbound when
incoming_message= true → Make AI Agent + WhatsAble Send.
Same fields, same outcome: only customer inbound reaches the agent.
Why this matters
Without this Filter (or Router), every time your teammate sends a message through the WhatsApp app, the dual trigger fires, the AI Agent treats it like a new customer message, and it sends an automated reply on top of the human. The customer gets confused. The teammate gets frustrated.
If you are using the Incoming Messages only trigger, you do not need this outbound Filter, but you should still consider a Router or conditional path that checks whether was_message_by_human was recently true on a previous message for that contact, so the agent does not jump back in during an active human conversation.
Safe fields:
incoming_message,send_by, andwas_message_by_humanare the documented coexistence fields on WhatsAble message events. Do not invent additional fields.
Optional: scaffold the scenario with Maia
If you prefer a conversational starting point, you can ask Maia to wire the scenario for you. Open the Scenario Builder, start a conversation with Maia, and describe what you want:
"Build a scenario triggered by incoming WhatsApp messages through WhatsAble. Add a Make AI Agent that has two tools: one that searches a Google Sheets spreadsheet for car availability, and one that calls a sub-scenario to notify a human teammate via WhatsApp when the customer needs help. Include a filter after the trigger so the agent does not process outbound messages from teammates."
Maia will lay out the modules on the canvas. Review what it built, fill in the connections (WhatsAble API key, Google Sheets authorization, teammate phone number), run the scenario once, and adjust.
This is a scaffold, not a finished product. You will still need to:
- Configure the AI Agent's system prompt with your business rules.
- Map the correct Sheets columns and ranges.
- Set the human-notify template parameters (
name,problem,comments). - Test the coexistence filter with a real teammate reply.
Maia does not make WhatsAble native. WhatsAble appears in Maia's module catalog because it is a public app on Make's marketplace. Maia can insert WhatsAble modules the same way it inserts any of 3000+ apps. There is no special "Maia + WhatsAble" product integration.
Things this guide does NOT cover
To keep the scope honest:
- WhatsAble Agent Skills and the native AI chatbot. WhatsAble has its own AI chatbot product (on Pro and Agency plans) with built-in human handoff and Agent Skills. That is a different surface from Make AI Agents. This guide focuses on Make-side agents with WhatsAble as the WhatsApp channel. The two approaches can coexist, but configuring WhatsAble's native AI is outside this article's scope.
- Click-to-WhatsApp ad attribution. If you want to track CTWA ads through Make, see Track Click-to-WhatsApp ads in Make (separate guide).
- Meta WhatsApp Business Cloud modules. Make also has first-party WhatsApp Business Cloud modules. This guide uses WhatsAble modules exclusively. They are different channels with different connections and features.
FAQ
Is it "Maya" or "Maia"?
The official spelling is Maia (Maia by Make). "Maya" is a common misspelling. They refer to the same build-time conversational co-worker inside Make's Scenario Builder.
Can Maia build my WhatsAble scenario automatically?
Maia can scaffold a scenario that includes WhatsAble modules, the same way it can include any app from Make's 3000+ catalog. But you still need to authorize your WhatsAble API key, configure the AI Agent's prompt, and test the flow. Maia helps you build faster; it does not replace configuration.
Does the car-rental example come from the Loom?
No. The Loom configuration meeting covered Make AI Agent tool assignment, WhatsAble messaging, and human escalation. The car-rental inventory example is illustrative, based on Make's public inventory how-to pattern adapted for WhatsAble.
What if I only want inbound messages, no outbound in my trigger?
Use the Incoming Messages from console (Notifyer System) trigger instead of the dual Incoming & Outgoing trigger. You skip the coexistence filter for outbound, but you may still want logic to detect when a human is actively handling a conversation.
Can I use Google Sheets and a CRM together?
Yes. Add both as tools on your AI Agent. For example: Sheets for real-time inventory, and a CRM module (HubSpot, Pipedrive, etc.) for customer records. The agent picks the right tool based on the conversation.
What happens if the AI Agent and a human both reply at the same time?
Without the coexistence Filter (or Router), the customer gets two overlapping messages. With a Filter that continues only when incoming_message = true (optionally also was_message_by_human = false), teammate outbound fails the Filter and the bot path does not run. Set this up before going live.
Links and resources
WhatsAble:
- WhatsAble + Make integration hub: whatsable.app/integrations/make
- WhatsAble Make modules documentation: docs.whatsable.app/guides/notifyer-system/make-overview
- Public Make listing: make.com/en/integrations/whatsable-message
Make AI / Maia:
- Maia by Make: make.com/en/maia
- Introduction to Maia: help.make.com/introduction-to-maia-by-make
- Make AI Agents: make.com/en/ai-agents
- Create your first AI Agent: help.make.com/create-your-first-ai-agent
- Build AI Agents (inventory how-to): make.com/en/how-to-guides/build-ai-agents
- Sub-Agents spotlight: community.make.com/t/feature-spotlight-make-ai-sub-agents/112628
Related WhatsAble guides: