Your AI rings your iPhone, speaks its question, and gets your spoken answer back as text.
Scored across 9 tools
Each tool maps to a distinct step in the phone conversation lifecycle (place, speak, poll, hang up, send text, receive reply), and descriptions explicitly route between near-neighbours, e.g. play_audio says 'use call for text under ~2000 characters.' The main residual overlap is poll_result vs. wait_for_reply (both long-polling) and call vs. say (both speak and return an answer), which an agent must resolve from state (open call vs. thread events) rather than from the name alone.
Names are all lower snake_case and mostly verb or verb_noun (hang_up, play_audio, poll_result, set_thread_title, wait_for_reply), so the pattern is readable. A few bare noun/verb names (call, text, setup, say) break the verb_noun rhythm slightly, but the intent of each is still obvious.
Nine tools is well within the ideal range and every tool corresponds to a real step in the call/text workflow. There is no filler: setup, placement, in-call dialogue, polling, audio playback, hangup, thread labeling and inbound waiting all earn their place.
The lifecycle is essentially covered end to end: onboarding (setup), outbound call/text, in-call speech, polling, hangup, playback of long audio, and inbound replies with cursor-based paging. Minor gaps exist — no way to list or read past threads/history, retrieve voicemail audio, or manage persistent settings (voice/language are per-call) — but agents can work around these within a session.
Ring the human's phone (iPhone or Android), read question aloud word
for word, and return what they say back as text. Waits up to ~30s.
status "completed" carries their words in `transcript` (empty if they only
listened). "ringing" (not picked up yet) or "in_call" (listening) means the
call has not settled: pass call_id to poll_result until it does. An
unanswered ring settles as "missed" within about a minute; "declined" means
they refused it. Do not retry an unanswered call in a loop: send one `text`
instead.
By default the line stays open after their answer ("open": true): they hear
a soft hold sound while you think, and a voice assistant tells them you are
working on it. Reply with `say`, finish with `hang_up`; after about two
minutes of silence the line drops by itself. Anything they said while
waiting comes back with their next answer as "said_while_waiting". The
"language" and "language_name" fields report what the recognizer heard, as
information only. `voice` picks who speaks (female first: bella, sarah,
jessica, ...; male: roger, eric, brian, ...) and sticks for later calls.
Reuse the returned session_token in later calls and texts so the phone
keeps one thread. The `from` in the result is your own number: never call
or text it. Missing `to` returns setup_required with download links.Inputs: question (required), to, voice, language, +3 more. Returns: from, next, open, turn, +14 more
End a call you placed. In an open conversation goodbye is spoken
first; leave it empty to just hang up. A call that already ended reports
its final status.
Inputs: call_id (required), session_token (required), goodbye. Returns: open, status, call_id, session_token
Bigger and longer audio goes here. Calls the human and plays a
recording to them as a phone call: a podcast, a long narration you
rendered, a voice memo, music. source is a link (YouTube, SoundCloud, a
podcast page, or a direct .mp3/.m4a/.wav/.ogg/.flac/... link) or the
audio_id of a file uploaded with
curl --data-binary @file.m4a "https://callmemcp.com/audio?to=<number>&filename=file.m4a"
(up to 300 MB / 3 hours, kept for a day). The voice says your intro, the
title and the length, then asks if they want to listen now; on a yes the
file plays as plain sound (no voice model) until it ends or they hang up.
Returns once they answer the offer: status "playing" (they said yes),
"completed" with listened:false (no, or nothing), or missed/declined.
poll_result later reports listened_s and finished. Use call for text
under ~2000 characters. language ("tr", "de") is the language of your
intro; the offer and the call's own lines follow it.
Inputs: source (required), to, intro, title, +4 more. Returns: from, next, open, turn, +14 more
Check on a call that came back "ringing", "in_call" or "playing". Waits
up to ~25s for it to settle, then returns the same shape as call: the
final status and transcript once they answer, decline, or the ring times
out ("missed", within about a minute). Still not settled: call it again.
For play_audio calls it reports listened_s and finished. Rings nothing.
Inputs: call_id (required), session_token (required). Returns: from, next, open, turn, +14 more
In a call whose result came back "open": true, speak text to the human
and return what they answer, in the same shape as call. Only after their
previous answer is in. Waits up to ~30s; on "in_call", follow up with
poll_result. "open": false means the call has ended. Pass language only
to switch the language of the call's own lines; empty keeps it. voice
switches who speaks from this line on (female first: bella, sarah, ...;
male: roger, eric, ...); empty keeps it. Anything
they said while you were thinking comes back as "said_while_waiting".
End the call with hang_up once you are done.
Inputs: text (required), call_id (required), session_token (required), voice, +1 more. Returns: from, next, open, turn, +14 more
Name this session's conversation thread on the human's phone (e.g. the project or task you are working on). Shown as the thread title in the app.
Inputs: title (required), session_token (required). Returns: ok, label
Return first-setup instructions and clickable App Store and Google Play download links, for when you do not have the human's Call Me number yet. Show both links to the human as clickable links, then ask them to open My Number in the app and give you its 10 digits. Nothing is sent and nothing rings.
Inputs: no named parameters. Returns: status, message, storage, app_store_url, +3 more
Send a one-way text to the human's phone (a push notification, no
ring). Use it for updates that need no answer, or as the fallback when a
call comes back "missed" or "declined". delivered:false means it was saved
to their history but no notification showed; notice says why. Their
replies arrive through wait_for_reply. Missing to returns setup_required
with the download links. Pass a previous session_token to stay in the
same thread.
Inputs: body (required), to, from_label, session_token. Returns: ok, from, note, notice, +4 more
Wait for the human to send something back to this session — texts and voicemail transcripts arrive here. Long-polls up to wait_s (max 30s); returns {events, cursor}. Pass the returned cursor next time to only see new events. An empty events list just means nothing yet — poll again if you are still waiting.
Inputs: session_token (required), cursor, wait_s. Returns: cursor, events
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Your AI rings your iPhone, speaks its question, and gets your spoken answer back as text.
Your AI rings your phone or messages you on Twring when it needs you, and reads your reply.
AI phone calls from your verified number, with answers, transcripts and recordings.
Calls your phone when an AI task finishes or is blocked — hear it, say what's next.
Add one secure layer between your agents and this server.
