Claude Code Calls Your Phone: This Plugin Changes Everything

What if your AI assistant could literally call you on the phone when it finished coding? Not a push notification. Not an email buried in spam. An actual ringtone on your actual phone—while you're making coffee, walking your dog, or finally taking that shower you've been postponing for three sprints.

Here's the brutal truth: developers waste 23 minutes on average recovering from every interruption. Yet we chain ourselves to terminals, obsessively checking if npm run build finished, if that database migration succeeded, if Claude Code got stuck on an edge case. We treat ourselves like human CI monitors. Pathetic, right?

That pain ends now. A developer named Zefram Lou built something so elegantly simple it feels obvious in retrospect—yet nobody else did it. CallMe is a minimal plugin that transforms Claude Code from a silent terminal ghost into a proactive colleague who picks up the phone. Start a complex refactoring. Walk away. Your phone rings when Claude needs you. Not a moment sooner.

This isn't science fiction. It's a Model Context Protocol (MCP) plugin you can install in under 10 minutes. And it's about to fundamentally change how you work with AI coding assistants.

What Is CallMe? The Plugin That Broke Claude Code's Silence

CallMe is a minimal MCP (Model Context Protocol) server plugin created by Zefram Lou, a developer known for building elegant blockchain infrastructure and developer tools. Released in early 2025, it solves one of the most overlooked friction points in AI-assisted development: asynchronous human-AI collaboration.

The Model Context Protocol, pioneered by Anthropic, allows Claude Code to extend its capabilities through external tools. Most plugins fetch documentation, query databases, or manipulate files. CallMe does something radically different—it bridges the digital-physical divide, giving Claude a voice that reaches you wherever you are.

The plugin exploded in developer circles precisely because it attacks a universal pain point. We've all experienced the paralysis of long-running AI tasks: do you stare at the terminal? Check every 30 seconds? Risk missing the moment Claude needs clarification? CallMe eliminates this decision fatigue entirely. It transforms Claude from a tool you monitor into a teammate you collaborate with asynchronously.

What makes CallMe genuinely revolutionary isn't the phone call itself—it's the multi-turn conversational capability. This isn't a one-way notification. When your phone rings, you answer, discuss the situation with Claude through natural speech, make decisions, and hang up. Claude continues working. The conversation state persists. It's as if you have a senior developer who respects your time enough to call instead of Slack-bombing you.

The architecture is deliberately minimal. No bloated dashboards. No complex orchestration. Just a local MCP server, an ngrok tunnel for webhooks, and your choice of phone provider. The entire codebase does one thing exceptionally well: initiating and managing voice calls between Claude Code and your phone.

Key Features: Why CallMe Outperforms Every Notification System

True Phone Integration, Not Pseudo-Notifications

CallMe doesn't send push notifications that get buried under Instagram alerts. It initiates actual PSTN phone calls to any number you configure—smartphone, smartwatch, even landlines. This matters because phone calls command attention in ways no other channel can. The psychological distinction between "another notification" and "my phone is literally ringing" is massive for time-sensitive development decisions.

Natural Multi-Turn Conversations

The continue_call tool enables genuine dialogue. Claude can present options, you respond verbally, Claude processes your speech-to-text through OpenAI's gpt-4o-transcribe model, and the conversation flows. This isn't IVR hell with "press 1 for yes." It's natural language understanding at conversation speed.

Composable Tool-Use During Calls

Here's where it gets insane: Claude can perform other MCP tool operations while talking to you. Imagine Claude calls to discuss authentication implementation, you ask "what does the OAuth spec say about refresh tokens?", and Claude invokes a web search tool—while you're still on the call—then continues the conversation with fresh information. The speak_to_user function enables this by allowing Claude to acknowledge requests before executing time-consuming operations.

Provider Flexibility with Cost Optimization

CallMe supports both Telnyx and Twilio, with Telnyx recommended at roughly 50% lower cost. Outbound calls run approximately $0.007/minute on Telnyx versus $0.014/minute on Twilio. The plugin defaults to sensible choices but exposes full configuration for power users.

Local-First Architecture with Secure Tunneling

The MCP server runs entirely on your machine. No code sent to third-party services except the phone provider you choose. Webhook reception uses ngrok tunnels, meaning your local server gets secure HTTPS endpoints without firewall configuration. The optional CALLME_TELNYX_PUBLIC_KEY variable enables cryptographic webhook signature verification for security-conscious organizations.

Free Local TTS with Kokoro

Text-to-speech costs can accumulate during extended debugging sessions. CallMe integrates Kokoro, a free local TTS engine via Docker, reducing total cost to roughly $0.01-0.02/minute versus $0.03-0.04 with OpenAI's TTS. The plugin auto-detects Docker availability and spins up Kokoro containers automatically.

Use Cases: Where CallMe Transforms Your Workflow

1. Long-Running Refactoring Sessions

You're modernizing a 50,000-line legacy codebase. Claude estimates 45 minutes to complete the migration. Previously, you'd camp the terminal or set a timer and hope. With CallMe: start the task, grab lunch, take a walk. Your phone rings when Claude hits an ambiguous type signature or needs architectural guidance. You discuss, decide, hang up. Claude resumes. Your afternoon isn't held hostage.

2. CI/CD Pipeline Debugging

Complex deployment failures require iterative investigation. Claude runs tests, analyzes logs, proposes fixes. Instead of terminal camping during 20-minute test suites, you receive a call only when human judgment is genuinely required. The speak_to_user function lets Claude announce "Running integration tests now, this will take 12 minutes" so you know exactly when to expect the next interaction.

3. Distributed Team Collaboration

Working across time zones with colleagues who need code review? Configure CallMe with team member numbers. Claude calls the appropriate person when their domain expertise is needed—database schema questions route to your DBA, frontend component decisions to your React specialist. The plugin becomes an intelligent routing layer for technical decisions.

4. Accessibility-First Development

Developers with visual impairments or repetitive strain injuries benefit enormously from voice-first interaction. CallMe enables complete development workflows without terminal focus—start tasks via voice, receive spoken updates, provide verbal guidance. The speech-to-text integration with OpenAI's latest models achieves remarkable accuracy even with technical vocabulary.

5. On-Call Incident Response

When production alerts fire at 3 AM, Claude investigates while you stay in bed. It calls only when human escalation is necessary, presenting synthesized log analysis and proposed remediation. You make the go/no-go decision verbally, then return to sleep if the automated fix succeeds.

Step-by-Step Installation & Setup Guide

Prerequisites

Before installation, gather:

• Active Telnyx or Twilio account
• OpenAI API key (for speech-to-text)
• ngrok account (free tier sufficient)
• Claude Code installed and updated

Step 1: Configure Your Phone Provider

Recommended: Telnyx (cheaper, simpler onboarding)

# Create account at https://portal.telnyx.com, verify identity
# Buy a number (~$1/month): https://portal.telnyx.com/#/numbers/buy-numbers
# Create Voice API application: https://portal.telnyx.com/#/call-control/applications
#   - Set webhook URL to https://your-ngrok-url/twiml (you'll get this after ngrok setup)
#   - API version: v2
# Verify your receiving number: https://portal.telnyx.com/#/numbers/verified-numbers
# Get Public Key from Account Settings > Keys & Credentials (optional, enables security)

Alternative: Twilio (more expensive, $20 minimum credit)

# Create account at https://www.twilio.com/console
# Use free number or buy new one (~$1.15/month)
# Locate Account SID and Auth Token on Console Dashboard

Step 2: Configure Environment Variables

Create or edit ~/.claude/settings.json:

{
  "env": {
    "CALLME_PHONE_PROVIDER": "telnyx",
    "CALLME_PHONE_ACCOUNT_SID": "your-connection-id-or-account-sid",
    "CALLME_PHONE_AUTH_TOKEN": "your-api-key-or-auth-token",
    "CALLME_PHONE_NUMBER": "+15551234567",
    "CALLME_USER_PHONE_NUMBER": "+15559876543",
    "CALLME_OPENAI_API_KEY": "sk-...",
    "CALLME_NGROK_AUTHTOKEN": "your-ngrok-token",
    "CALLME_TELNYX_PUBLIC_KEY": "your-public-key",
    "CALLME_TTS_PROVIDER": "kokoro",
    "CALLME_TTS_VOICE": "af_bella"
  }
}

Critical formatting note: Phone numbers must use E.164 format (+1 for US, country code required). The CALLME_PHONE_NUMBER is what Claude calls from; CALLME_USER_PHONE_NUMBER is where you receive calls.

Step 3: Install the Plugin

# Add from MCP marketplace
/plugin marketplace add ZeframLou/call-me

# Install into Claude Code
/plugin install callme@callme

Restart Claude Code completely after installation. The MCP server initializes on startup and establishes the ngrok tunnel automatically.

Step 4: Verify Installation

# Run Claude with debug logging to see MCP server initialization
claude --debug

# In Claude Code, test with explicit instruction:
# "Call me to discuss the next steps when you're done with this task."

REAL Code Examples: How CallMe Works Under the Hood

The CallMe plugin exposes four core tools through the MCP protocol. Here are the actual implementations from the repository, with detailed explanations of how each function enables voice-driven development workflows.

Example 1: Initiating Your First Call

When Claude completes a task or needs immediate human input, it invokes the initiate_call tool. This is the entry point that transforms text-based AI interaction into a phone conversation.

// Initiate a new phone call to the user
const { callId, response } = await initiate_call({
  message: "Hey! I finished the auth system. What should I work on next?"
});

What happens behind the scenes: The MCP server receives this tool call via stdio, formats the message for TTS conversion, instructs Telnyx/Twilio to dial CALLME_USER_PHONE_NUMBER, and streams synthesized audio when you answer. The callId returned is critical—it's the session identifier for all subsequent interactions in this conversation. The response contains your transcribed speech after you speak. Claude doesn't just blast a message and hang up; it waits for your verbal response, creating genuine two-way communication.

Example 2: Continuing Multi-Turn Conversations

Real technical discussions require follow-up questions. The continue_call tool maintains conversation state using the original callId.

// Continue an existing call with follow-up questions or new information
const response = await continue_call({
  call_id: callId,  // Reuse the session ID from initiate_call
  message: "Got it. Should I add rate limiting too?"
});

Why this matters: Without call_id, each tool call would spawn a separate phone call—imagine getting 15 calls in 10 minutes for a single debugging session. The session persistence enables natural dialogue flow. Claude can reference previous decisions, build context, and you can interrupt with "actually, go back to the first option." The response again contains your transcribed reply, which Claude feeds into its reasoning loop for the next action.

Example 3: Non-Blocking Status Updates with speak_to_user

Here's where CallMe's architecture shines for realistic development workflows. Some operations take minutes but you want acknowledgment that Claude understood your request.

// Speak to user WITHOUT waiting for response—acknowledge before long operations
await speak_to_user({
  call_id: callId,
  message: "Let me search for that information. Give me a moment..."
});

// Continue with your long-running task—call stays open but Claude isn't blocked
const results = await performSearch();  // Could take 2-3 minutes

// Re-engage user with results when ready
const response = await continue_call({
  call_id: callId,
  message: `I found ${results.length} results matching your criteria...`
});

The genius pattern: speak_to_user sends TTS audio and immediately returns. The phone connection stays alive (you hear hold music or silence depending on provider), but Claude's execution thread continues. This enables parallel human-AI operation—you know your request was understood, Claude works independently, then reconnects when value exists. Compare this to being trapped on a call with dead air while someone types.

Example 4: Graceful Call Termination

Clean endings matter for professional interactions and cost control.

// End the call with a closing message
await end_call({
  call_id: callId,
  message: "Perfect, I'll get started. Talk soon!"
});

Cost implication: Phone providers bill by the second. Explicit end_call prevents runaway charges from forgotten connections. The closing message provides psychological closure—you're not wondering if Claude is still working or if the connection dropped. For critical operations, you might skip end_call and let Claude call back with completion, creating a "check-in" pattern for very long tasks.

Advanced Usage & Best Practices

Optimize Costs with Kokoro TTS

For heavy users, OpenAI TTS at ~$0.02/minute dominates costs. Enable Kokoro for free local synthesis:

# In ~/.claude/settings.json or shell environment
export CALLME_TTS_PROVIDER=kokoro
export CALLME_TTS_VOICE=af_bella  # Or af_sky, am_adam

# Docker auto-detection: if port 8880 is free, plugin pulls and starts Kokoro
# Custom instance: point to existing server
export CALLME_KOKORO_URL=http://localhost:8880/v1

Custom ngrok Domains for Stability

Free ngrok URLs change every session, requiring phone provider dashboard updates. Paid ngrok domains eliminate this:

export CALLME_NGROK_DOMAIN=your-domain.ngrok.io

Tune Silence Detection for Your Environment

Noisy environments need longer silence thresholds; quiet offices can use shorter for faster response:

# Default 800ms—increase for coffee shops, decrease for home offices
export CALLME_STT_SILENCE_DURATION_MS=1200
# Extend timeout for thoughtful responders
export CALLME_TRANSCRIPT_TIMEOUT_MS=300000  # 5 minutes

Webhook Security in Production

Telnyx supports cryptographic signature verification. Always set CALLME_TELNYX_PUBLIC_KEY in production to prevent webhook spoofing attacks that could trigger fraudulent calls.

Development Mode

cd server
bun install
bun run dev  # Hot-reload MCP server for plugin development

Comparison with Alternatives

Why CallMe wins: Terminal notifications fail when you step away. Slack bots get lost in noise. PagerDuty is overkill and lacks AI context. Only CallMe delivers contextual, conversational, anywhere-accessible human-AI collaboration at minimal cost.

FAQ: Common Developer Concerns

Does CallMe work with any phone number worldwide?

Telnyx and Twilio support most countries, but you'll need to verify receiving numbers per provider policies. US/Canada/EU coverage is excellent; some regions may require additional documentation.

Can I use CallMe without OpenAI?

Partially. CALLME_OPENAI_API_KEY is currently required for speech-to-text. The text-to-speech component can use free Kokoro instead, but STT has no local alternative yet. Future versions may integrate open-source STT models.

What happens if I miss Claude's call?

The call goes to voicemail per your phone's settings. Claude receives no transcription and will retry based on your next interaction or explicit instruction. Consider setting "Call me back in 5 minutes if I don't answer" in your prompt.

Is my conversation data stored anywhere?

CallMe's MCP server runs locally. Audio passes through your chosen phone provider (Telnyx/Twilio) and OpenAI's STT API per their respective privacy policies. No persistent storage in the plugin itself.

Can multiple developers share one CallMe setup?

Each developer needs their own CALLME_USER_PHONE_NUMBER and ideally separate phone provider credentials. The plugin doesn't support multi-user routing natively, though you could build a wrapper for team use.

How do I debug when calls fail?

Run claude --debug to see MCP server stderr logs. Common issues: incorrect ngrok token (tunnel fails), unverified phone numbers (provider rejects), webhook URL mismatch (call connects but no audio).

Will this drain my OpenAI credits?

STT costs ~$0.006/minute. A typical 3-minute debugging call costs under $0.02 in API fees. Heavy users can monitor usage at platform.openai.com/usage.

Conclusion: The Future of Human-AI Collaboration Is Voice

CallMe represents something bigger than a clever notification hack. It demonstrates how MCP plugins can dissolve the interface boundaries between AI systems and human physical reality. When Claude Code can literally reach into your pocket and start a conversation, the "artificial" in artificial intelligence starts feeling genuinely auxiliary.

The setup takes 10 minutes. The cost is negligible. The productivity gain—reclaiming your attention, eliminating terminal camping, enabling genuine asynchronous collaboration—is transformative.

Zefram Lou built exactly what developers needed and nothing more. No feature bloat. No enterprise sales cycle. Just install, configure, and never miss a critical AI decision again.

Ready to let Claude call you? Grab the plugin from github.com/ZeframLou/call-me, follow the setup above, and experience the weird satisfaction of your phone ringing with a robot asking whether you prefer interface segregation or union types. The future is stranger—and more productive—than we imagined.

What's your CallMe use case? Long-running compiles? Distributed team coordination? 3 AM incident response? Share how you'd deploy voice-enabled Claude Code in your workflow.