In one line. better-call-claude is an MCP server that routes inbound voice calls, SMS, and WhatsApp to a local Claude Code session, and lets Claude call or message you back when it needs a decision or finishes a task.
Coding agents are fast, but they are stuck behind the terminal. You start a long task, walk away, and either you poll a log file or you miss the moment it gets blocked and needs your input. The other failure mode: you want to assign something while you are away from your machine, on a commute, between meetings, and the only interface is typing into a chat window that requires you to be at your desk. better-call-claude gives Claude Code a real phone presence: a number you can ring from anywhere to start work, and that rings you back when it is done or stuck.
Figure 1. Left: a coding agent that can only be reached by sitting at a terminal. Right: the same agent reachable by phone, SMS, or WhatsApp, with context carried across channels.
Terms in 30 seconds
Domain engineers: skip ahead, this is orientation for everyone else.
- MCP (Model Context Protocol): the open protocol (Anthropic, Nov 2024) that defines how language models talk to external tools and data sources; donated to the Linux Foundation's Agentic AI Foundation, Dec 2025 (status as of June 2026). (modelcontextprotocol.io)
- MCP server: a small process that exposes tools over MCP; Claude Code loads it at startup and can call its functions as part of any task.
- Tailscale Funnel: a feature of the Tailscale VPN mesh that exposes a local port at a stable public HTTPS URL, without port-forwarding or a static IP. Free tier included.
- Baileys: an open-source library that speaks the WhatsApp Web protocol, letting you send and receive WhatsApp messages from a personal account without a business account or Meta approval.
- STT / TTS: speech-to-text (converting your voice to text) and text-to-speech (Claude speaking back). better-call-claude uses OpenAI Whisper for STT and the OpenAI TTS API for outbound voice.
Why this matters
- For solo developers and indie hackers: long-running agent tasks (refactors, test-suite runs, data pipelines) now report back by phone; you stop checking logs and start doing other work.
- For agentic tooling as a field: MCP (donated to the Linux Foundation's Agentic AI Foundation, Dec 2025) is the emerging standard for how agents talk to the outside world; a telephony MCP server is a concrete demonstration that the protocol is expressive enough to bridge the digital-physical gap.
- For the broader shift in developer tooling: coding agents today are terminal-local; the next wave of productivity requires them to be reachable across human communication channels without a separate orchestration layer.
🧭 If you only read this far: better-call-claude turns a coding agent that is only reachable by keyboard into one that can accept tasks and return status over any channel you already carry in your pocket.
The problem, for engineers who don't live in this space
Imagine you left your laptop running an overnight compile, and the only way to know if it finished, or hit an error, is to be sitting in front of it. Email notifications help a little, but they are one-way: you cannot reply to the notification and tell the build to try a different flag. Now replace "overnight compile" with a Claude Code session running a refactor across a large codebase. The problem is the same, and the state of the art is the same: watch the terminal, or lose the thread.
Here is the concrete version. You open Claude Code on your laptop, ask it to migrate a service to a new API, and step out for a meeting. Halfway through, it hits an ambiguous case, two possible approaches, and it cannot decide without your preference. It stops and waits. You come back an hour later to a paused session. Alternatively, it finishes the migration and you do not find out until you next open the terminal. Neither outcome is good when the agent could have just called you.
Figure 2. The current state: Claude Code can only block-and-wait or finish silently; there is no channel back to the developer when they are away from the terminal (red gap).
Why this is genuinely hard. The naive fix, "just send a push notification", is one-way and does not let you respond with context. A real fix needs bidirectional communication, carried over channels developers actually have open (phone, WhatsApp, SMS), with the conversation state preserved so Claude can pick up exactly where it left off regardless of which channel you reply on.
What exists today (and the gap)
| Approach | Inbound task assignment | Outbound status / blocking-input request | Speech (STT + TTS) | Multi-turn conversation | Cross-channel context | As an MCP server |
|---|---|---|---|---|---|---|
| Plain MCP notification servers | ❌ | ⚠️ one-way | ❌ | ❌ | ❌ | ✅ |
| Twilio-bot scripts (custom) | ⚠️ custom | ⚠️ custom | ❌ | ⚠️ partial | ❌ | ❌ |
| Email-the-human hooks | ❌ | ✅ one-way | ❌ | ❌ | ❌ | ❌ |
| Slack / Discord bots | ⚠️ text only | ✅ one-way | ❌ | ⚠️ no voice | ❌ | ❌ |
| better-call-claude | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
No existing approach delivers bidirectional voice, SMS, and WhatsApp, with full cross-channel context preservation, as a drop-in MCP server that Claude Code can use natively. The gap is not any single capability; it is the combination: structured as MCP tools so the agent controls the channel, not a sidecar process.
How it works
better-call-claude sits between your phone and your local Claude Code session, routing every signal through a Tailscale Funnel tunnel. It has four main parts:
- Provider layer: Telnyx or Twilio handles inbound and outbound voice and SMS; Baileys (the WhatsApp Web library) handles personal-account WhatsApp for free; hybrid mode mixes providers.
- Tunnel: Tailscale Funnel exposes the local MCP server (port 3333) at a stable public HTTPS URL; provider webhooks hit that URL.
- MCP server: the Bun + Hono process that receives webhooks, transcribes audio via OpenAI Whisper, synthesizes speech via OpenAI TTS, and exposes the full tool surface to Claude Code over MCP.
- Claude Code: the Claude session that invokes the MCP tools to speak, send messages, or check conversation history as part of its normal task execution.
Figure 3. Your phone reaches a telephony provider, which sends webhooks through Tailscale Funnel to the local MCP server (port 3333); Claude Code calls MCP tools to reply or initiate contact.
Provider layer
Telnyx is the recommended provider: voice and SMS at roughly 50% lower cost than Twilio, with a compatible webhook API. Twilio is supported for teams already on it. For WhatsApp, Baileys pairs with a personal account via a QR code scan, no Meta Business verification, no per-message fees, making it the practical default for individual developers. A hybrid configuration uses Telnyx or Twilio for calls and SMS alongside Baileys for WhatsApp, keeping all three channels available simultaneously.
Tunnel
Tailscale Funnel is free, stable, and requires no open ports or static IP. The provider webhooks reach the local server over Tailscale's encrypted network, which also means the server is not generally internet-accessible, only traffic routed through the Funnel endpoint reaches it. This is a meaningful security property: the phone number is the access control.
MCP server and tool surface
The server exposes thirteen MCP tools split across two domains. Voice tools: receive_inbound_call, initiate_call, continue_call, speak_to_user, end_call, get_call_status. Messaging tools: receive_inbound_message, send_sms, send_whatsapp, reply_to_conversation, get_conversation_history. Claude Code can call these at any point in a task, to ask a clarifying question mid-refactor, to announce completion, or to hand back a decision it cannot make alone.
Cross-channel context is maintained by the server: a task started on a voice call and continued over WhatsApp carries the same session state. Claude Code sees one conversation history regardless of which channel the human replied on.
The decisions that actually mattered
Tailscale Funnel vs. ngrok or a cloud relay
The fork. You need a stable public HTTPS URL that the telephony provider can reach. Several options exist: ngrok (free tier has random URLs that change on restart), a self-hosted relay, or a cloud-hosted server. Chosen. Tailscale Funnel. Trade-off accepted. Requires Tailscale to be installed and the user's machine to be in a Tailscale network, a non-trivial prerequisite for some users. In exchange: the URL is stable across restarts, it is encrypted end-to-end over Tailscale's network, and it is free. ngrok's random URLs would break the webhook registration every time the tunnel restarted; a cloud relay would move the MCP server off the local machine and away from the Claude Code session it needs to reach.
Baileys for personal WhatsApp vs. requiring a business account
The fork. WhatsApp Business API (via Twilio or Telnyx) requires Meta business verification, a registered phone number, and per-message fees. Most individual developers do not have a WhatsApp Business account. Chosen. Baileys as the default WhatsApp path, with a business-API option alongside it. Trade-off accepted. Baileys uses the WhatsApp Web protocol, which WhatsApp does not officially sanction for automated use; it can break when WhatsApp updates its client. In exchange, it removes all friction for the target user (a solo developer), scan a QR code once and WhatsApp is live, free, with no account approval needed.
MCP server (local) vs. hosted SaaS
The fork. Ship as a hosted service (managed phone numbers, managed tunnels) or as a local MCP server the developer runs themselves. Chosen. Local MCP server. Trade-off accepted. The developer must configure provider accounts, set environment variables, and run Tailscale, the setup is not one-click. In exchange, the architecture keeps all conversation data local; the agent's tasks and the content of calls never leave the developer's machine on their way to Claude.
Why this is new, and why it's significant
What's novel. better-call-claude is, to my knowledge, the first MCP server to give a coding agent a bidirectional voice, SMS, and WhatsApp presence, with cross-channel context preservation, so the agent can both receive task assignments and initiate contact with the developer as a first-class MCP capability, not a bolt-on script.
Why it's significant to the field. MCP (Model Context Protocol) was released by Anthropic in November 2024 and donated to the Linux Foundation's Agentic AI Foundation in December 2025 (status as of June 2026); it has rapidly become the de facto standard for how agents talk to tools. The protocol is designed to be expressive: an MCP server can expose any capability a process can provide. better-call-claude demonstrates that "phone presence" is a legitimate MCP capability class, that the agent side-channel problem is solvable at the protocol layer, not by wrapping agents in a separate orchestration system. That demonstration matters because the ecosystem is actively deciding which capability classes belong in the MCP surface; a working implementation anchors the conversation with something concrete and runnable.
The broader problem it addresses, coding agents that cannot communicate with their human collaborator except through the terminal, is an acknowledged friction point in the agentic-developer-tooling space. As MCP tooling matures and agents are trusted with longer-horizon tasks, the need for out-of-band human-in-the-loop communication becomes a prerequisite for safe autonomous operation, not a nice-to-have.
Standards and ecosystem alignment. This work is built on and aligns with:
- MCP (Model Context Protocol): the server is a conformant MCP server; all thirteen capabilities are exposed as standard MCP tools, discoverable by any MCP-compatible host.
- OpenAI Whisper: speech-to-text uses the Whisper API, a widely-adopted transcription standard in the agentic tooling ecosystem.
- Tailscale Funnel: the tunnel layer uses a production-grade, cryptographically secure network rather than ad-hoc port-forwarding, keeping the local server's attack surface minimal.
📌 Honest scope. better-call-claude runs as a self-hosted local MCP server and requires the developer to provision third-party telephony accounts (Telnyx or Twilio) and Tailscale. It is not a hosted service. The Baileys path uses the unofficial WhatsApp Web protocol and may require updates if WhatsApp changes its client. Call and message volume in production depends on telephony provider uptime and rate limits, which are outside the server's control.
See it run
# Add to your MCP config (Claude Code's ~/.claude/config.json or project-level)
# Environment variables: BETTERCALLCLAUDE_PHONE_PROVIDER, _PHONE_NUMBER,
# _USER_PHONE_NUMBER, _OPENAI_API_KEY, plus provider credentials.
# For WhatsApp-only via Baileys (no telephony account needed):
bun run baileys:pair
# Scan the QR code with WhatsApp on your phone, done.
# The MCP server starts automatically when Claude Code loads the config:
bunx better-call-claude
[better-call-claude] MCP server listening on :3333
[better-call-claude] Tailscale Funnel: https://yourhost.ts.net → localhost:3333
[better-call-claude] Provider: telnyx Number: +1-555-000-1234
[better-call-claude] WhatsApp: baileys (paired) # ← free personal account, no business approval
[better-call-claude] Tools registered: 13 # ← full voice + messaging surface in Claude Code
Once running, call the number from your phone. Claude Code picks up, transcribes your voice via Whisper, starts the task you described, and later calls or messages you back when it finishes or hits a decision point.
Figure 5. End-to-end sequence: you call the number, the provider webhook reaches the MCP server via Tailscale Funnel, Claude Code starts work, and later calls or messages you back via initiate_call or send_whatsapp.
🔬 Go deeper. The thirteen MCP tools and their parameters are defined in the server's tool registration layer;
receive_inbound_callandinitiate_callare the two that anchor the inbound and outbound voice paths respectively. See the repository for the current implementation. (github.com/sns45/better-call-claude)
What's next
Near-term: richer mid-call interaction (hold, transfer between channels mid-task) and a smoother first-run setup that pre-validates provider credentials and Tailscale connectivity before the first call. better-call-claude is one piece of in8's agentic-developer-tooling series, alongside dear-claude, which addresses a different facet of the human-agent collaboration problem. The shared thesis across the series is that coding agents need human-reachable side channels to be trusted with longer-horizon work; telephony is the most universally available channel, which is why it is the right place to start.
Appendix / references
- Repository: github.com/sns45/better-call-claude
- Related in this series: dear-claude · tickettok
- MCP (Model Context Protocol): modelcontextprotocol.io, Anthropic, Nov 2024; donated to the Linux Foundation's Agentic AI Foundation, Dec 2025
- Tailscale Funnel: tailscale.com/kb/1223/funnel
- Telnyx: telnyx.com, recommended voice/SMS/WhatsApp provider
- Twilio: twilio.com, alternative voice/SMS/WhatsApp provider
- Baileys: github.com/WhiskeySockets/Baileys, WhatsApp Web protocol library
- Discussion / feedback: github.com/sns45/better-call-claude/issues