Give Your AI Agent the Power to Message Humans on WhatsApp

The hard part of building useful AI agents in 2026 isn't intelligence. Frontier models are extraordinary. The hard part is reach — connecting the agent to the systems where work actually gets done, and to the people who need to know about it.

For over 3 billion people, that channel is WhatsApp — Meta confirmed it passed 3B monthly active users in 2025, making it the largest messaging platform in the world. Email open rates are around 20%. WhatsApp message open rates are 98% within an hour. In India, Brazil, Indonesia, Nigeria, and most of LATAM and Southeast Asia, WhatsApp is the communication layer.

This post is about giving any AI agent — Claude, GPT, your own custom one — the ability to message humans on WhatsApp. And making it as easy as adding a single line to a config file.

What unlocks when an agent can message humans

A non-exhaustive list:

• A customer support agent that handles inbound queries on WhatsApp 24/7, escalates to humans when needed, and remembers each user's history
• A monitoring agent that watches your infrastructure and WhatsApps the on-call engineer when something breaks
• A lead qualification agent that reaches out to new signups, has a short conversation, and books a meeting with the SDR
• A booking agent for clinics, salons, repair shops — confirms appointments via WhatsApp, sends reminders, handles reschedules
• A fulfillment agent that texts customers when their order ships, when it's delivered, or when something's delayed
• A founder's ops assistant in Claude Desktop that sends invoices to clients, pings the team about updates, or summarizes overnight signups on WhatsApp
• A voice agent (e.g. on LiveKit) that ends calls by sending a written summary on WhatsApp
• A coding agent (Cursor, Claude Code, Codex) that pings you on WhatsApp when a long-running build, migration, or scrape finishes

In each case, the bottleneck wasn't the AI. It was the missing channel.

What is MCP?

MCP (Model Context Protocol) is an open standard from Anthropic that's been quickly adopted across the agent ecosystem. Cursor, Claude Code, Claude Desktop, OpenAI Codex CLI, OpenAI Agents SDK, n8n, LangChain (via adapters), and a growing list of frameworks all support MCP.

An MCP server exposes a list of tools as typed function definitions. An MCP-compatible agent reads those definitions, decides which tool to call given the user's intent, fills in the arguments, and gets results back. The same MCP server works in every MCP-compatible runtime.

This means: install the WhatsApp MCP server once, and your agent works in every supported environment. No code changes per runtime.

The Gavi WhatsApp MCP server

@gaviwhatsapp/mcp is an open MCP server, listed on the Anthropic MCP Registry. It exposes these tools:

That set covers ~95% of what you'd ever want to do with WhatsApp programmatically.

How to give it to your agent

If your agent is Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "gaviwhatsapp": {
      "command": "npx",
      "args": ["@gaviwhatsapp/mcp", "--api-key", "gv_YOUR_KEY"]
    }
  }
}

Restart Claude Desktop. Now ask Claude to "WhatsApp my partner that I'll be 20 minutes late." It just works.

If your agent is Cursor, Claude Code, or OpenAI Codex CLI

Same config block, in their respective MCP config files. We have detailed walkthroughs:

• Cursor + WhatsApp MCP
• Claude Code + WhatsApp MCP
• OpenAI Codex + WhatsApp MCP

If your agent is built on OpenAI Agents SDK or LangChain

Both support MCP via adapters — you can attach @gaviwhatsapp/mcp and the WhatsApp tools become available to your agent. We have a dedicated guide: Adding WhatsApp tools to OpenAI Agents SDK and LangChain.

If your agent is custom (Anthropic API or OpenAI API directly)

You have two options. The cleanest is to call the MCP server programmatically:

import { Client } from '@modelcontextprotocol/sdk/client/index.js'
// connect to the gaviwhatsapp MCP server, list tools, expose them to your model

Or skip MCP entirely and just define WhatsApp tools manually in your agent loop, using the @gaviwhatsapp/whatsapp SDK inside the tool implementation. We walk through both patterns in our WhatsApp chatbot architecture guide.

If you don't want MCP at all

Just use the REST API or our SDKs. WhatsApp messaging is one HTTP call:

curl -X POST https://www.gaviventures.com/api/v1/messages/send \
  -H "Authorization: Bearer gv_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"to": "+919876543210", "text": "Hello!"}'

Full API docs.

Why "let the agent decide" beats hand-coded notifications

The traditional pattern for sending WhatsApp from an app is hardcoded:

if (orderStatus === 'shipped') {
  sendWhatsApp(user.phone, `Your order ${order.id} has shipped.`)
}

That works for known cases. But you'll add 50 of these ifs over a year, and each one will be inconsistent in tone, language, and edge-case handling.

When the agent decides:

[user message: "where's my order? I ordered it on Monday and it's Friday now"]
  → agent calls lookup_order(phone)
  → gets shipping status, ETA, tracking number
  → calls send_whatsapp with a tailored, contextual reply that addresses the user's actual frustration

Same delivery, much better UX. And you didn't write the message text — the agent generated it from the situation.

A real production stack

Here's what a production agentic WhatsApp app looks like in 2026:

┌─────────────────────────┐         ┌──────────────────────┐
│   Inbound WhatsApp msg  │ ──────→ │   Webhook handler    │
└─────────────────────────┘         └──────────┬───────────┘
                                               │
                                               ▼
                              ┌─────────────────────────────┐
                              │ Load conversation history    │
                              │ from DB (last 10 turns)      │
                              └────────────┬─────────────────┘
                                           ▼
                              ┌─────────────────────────────┐
                              │ Agent (Claude/GPT) with     │
                              │ tools:                      │
                              │  - send_whatsapp (MCP)      │
                              │  - lookup_order             │
                              │  - book_slot                │
                              │  - escalate_to_human        │
                              └────────────┬─────────────────┘
                                           ▼
                              ┌─────────────────────────────┐
                              │ Tool calls execute          │
                              │ → reply sent via WhatsApp   │
                              │ → conversation saved        │
                              └─────────────────────────────┘

Full code walkthrough: How to Build an AI Agent That Talks to Customers on WhatsApp.

Pricing

$9.99/mo flat from Gavi. No per-conversation fee, no per-tool-call fee, no markup on Meta's per-message charges (which are billed directly to your WhatsApp Business Account at Meta's published rates).

That's flat pricing aimed at developers building real products — not the per-conversation revenue model most "WhatsApp Business Suite" platforms run.

What to do next

1. Sign up at gaviventures.com — takes 30 seconds, free tier works for testing
2. Pick a runtime — your existing agent (Cursor, Claude Code, Claude Desktop, custom) probably already supports MCP
3. Add the config block above to your MCP config file
4. Ask your agent to send a test WhatsApp

Five minutes from "I read this post" to "my agent just texted me on WhatsApp."

Try it: gaviventures.com · GitHub · npm · MCP Registry