claude-call 📞

Talk to your Claude Code by voice — a real phone call with your terminal agent.

Not a generic voice assistant. claude-call is voice I/O bolted onto your actual Claude Code session — same skills, MCP servers, memory, and context. You launch it from a project, it resumes the conversation you were just having there, and you keep going by voice. It can read files, run tools, edit code, post to your integrations — everything your Claude Code can do — because the brain is your Claude Code.

  🎙️ mic ─▶ VAD (Silero) ─▶ whisper.cpp (local STT)
                                              │
                                              ▼
                         claude (daemon, --resume your session)   ◀── the brain IS your Claude Code
                                              │
  🔊 speaker ◀─ edge-tts ◀──────────────── streamed reply (sentence by sentence)

• Local ears (or API): whisper.cpp by default — offline, ~0.6s/utterance (resident server). Or switch to a cloud STT (Groq, OpenAI, ElevenLabs, Google Chirp 2) for top accuracy — see Speech-to-text.
• Your brain: the claude CLI you're already logged into — no separate API key to manage, all your skills/MCP/context. (It does cost — headless usage is billed; see Cost & billing.)
• Free voice: Microsoft edge-tts, many languages — or plug a premium API (ElevenLabs, Cartesia, OpenAI, Rime, Deepgram) if you want.
• One warm process: the brain runs as a persistent daemon for the whole call — context stays cached, replies stream as it talks.

Why it's different

Every other voice agent gives you a fresh, context-less assistant. This one continues your session. Ask it "where were we?" and it knows — because it's literally the same conversation, reached through a microphone instead of a keyboard.

Cost & billing

Read this before you rely on it. The brain is claude -p (Claude Code's headless mode), and headless usage is billed differently from interactive use:

• Interactive Claude Code (you typing in the terminal/IDE) is covered by your flat Pro/Max plan.
• Headless claude -p — what claude-call uses — is not flat. As of June 15, 2026, Anthropic moved claude -p, the Agent SDK, GitHub Actions and third-party apps to a separate monthly agent credit, charged at standard API rates:

Plan	Monthly agent credit
Pro	$20
Max 5×	$100
Max 20×	$200

When that credit runs out, automated calls stop unless you enable overflow (pay-as-you-go) billing.

So a voice call costs real money (API token rates) out of that credit. You don't set up a separate API key — it uses your Claude Code login — but it is not "free on top of your subscription."

Keep it cheap: - CALL_MODEL=haiku — the cheapest brain. - CALL_CONTINUE=0 — start a fresh session instead of resuming a big one (far fewer input tokens per turn). You lose "continue your session," but it's much cheaper. - Fewer, longer calls amortize the prompt cache (warm turns cost less than many cold starts). - Want predictable pay-as-you-go instead? Put ANTHROPIC_API_KEY=... in .env and claude -p bills that directly (no agent-credit cap/stop).

💸 Want it on your flat plan? Use hook mode. voice_hook.py runs the voice loop as a Stop hook on your live, interactive Claude Code session — no headless claude -p. Those turns are interactive usage covered by your flat Pro/Max plan, not the separate agent credit. You drive the voice loop from inside a normal claude session instead of launching call.sh. See Hook mode.

Sources: Anthropic ends flat-rate agent access, June 15 2026 · Use Claude Code with Pro/Max.

Quick install (one command)

curl -fsSL https://raw.githubusercontent.com/caiovicentino/claude-call/main/install.sh | bash

This installs everything — uv, ffmpeg, whisper.cpp, portaudio, the repo, a speech model — and a global claude-call command. It finishes by running claude-call doctor, so you immediately see all green plus a quick latency benchmark. Then, from any project: claude-call.

You still need Claude Code installed and logged in (it's the brain — no API key). macOS also needs Homebrew. Prefer to do it by hand? Follow the step-by-step below.

Windows (native, no WSL)

Works natively on Windows — same brain, your real Windows Claude Code sessions (no WSL, so it resumes the sessions under %USERPROFILE%\.claude, not a Linux copy). It uses scoop for the native deps instead of brew/apt.

# 1. one-time deps (scoop is user-level, no admin)
scoop install uv ffmpeg whisper-cpp        # whisper-cpp ships whisper-server.exe + whisper-cli.exe

# 2. get claude-call + install
git clone https://github.com/caiovicentino/claude-call
cd claude-call
.\install.ps1        # uv sync, downloads a whisper model, registers a `claude-call` command, runs doctor

Then, from any project you've used with Claude Code:

cd C:\my-project
claude-call          # config:  claude-call config   ·   check:  claude-call doctor

Notes for Windows: - Entry points are PowerShell: call.ps1 / install.ps1 (the .sh scripts are macOS/Linux). install.ps1 drops a claude-call.cmd shim into your scoop shims dir (already on PATH). - Use the native Claude Code installer (gives claude.exe). claude-call launches the claude CLI directly (not through a shell), and on Windows that only finds claude.exe — an npm install exposes claude.cmd, which won't be picked up. Either install the native build or make sure a claude.exe is on PATH. - Python 3.12 is fetched automatically by uv (3.13+ removed audioop). PyAudio installs from a prebuilt wheel — no portaudio build needed. - STT speed: the scoop whisper.cpp is a CPU build. If small feels slow on your machine, switch to a lighter model: .\scripts\download-model.ps1 base then set CALL_WHISPER_MODEL=%USERPROFILE%\.cache\whisper\ggml-base.bin in .env. - Ctrl+C ends the call (the macOS hardware AEC / CALL_AEC is macOS-only and simply ignored here). - Security: the default CALL_PERMISSION=--dangerously-skip-permissions lets the agent run bash/edits without asking — extra worth noting on your main Windows box. To be prompted instead, set CALL_PERMISSION=--permission-mode default in .env (the call stalls on a prompt, since voice can't answer it). See Security.

Step-by-step (from zero)

1. Install the prerequisites

You need four things on your machine:

Tool	For	Install
Claude Code	the brain	docs — then run claude once and log in
uv	Python deps	curl -LsSf https://astral.sh/uv/install.sh \| sh
whisper.cpp	local speech‑to‑text	macOS: brew install whisper-cpp · Linux: build (below)
ffmpeg + portaudio	audio I/O	macOS: brew install ffmpeg portaudio · Linux: sudo apt install ffmpeg portaudio19-dev

macOS, one line:

brew install uv ffmpeg whisper-cpp portaudio

⚠️ Claude Code must be logged in. Run claude once and sign in — that's the brain, no separate API key to set up. Heads up: headless use is billed (see Cost & billing).

Linux whisper.cpp (if there's no package): build it and put its binaries on your PATH:

git clone https://github.com/ggerganov/whisper.cpp && cd whisper.cpp
cmake -B build && cmake --build build -j --config Release
export PATH="$PWD/build/bin:$PATH"   # so whisper-server / whisper-cli are found

2. Get claude-call

git clone https://github.com/caiovicentino/claude-call
cd claude-call
./install.sh        # checks prereqs, installs python deps, downloads a whisper model

3. (optional) Make it a global command

ln -s "$PWD/call.sh" /usr/local/bin/claude-call

4. Call

Go into a project you've used with Claude Code, and run it:

cd ~/my-project
claude-call          # or:  /path/to/claude-call/call.sh

It greets you, resumes that project's most recent Claude Code session, and listens. By default you address it by name — say "Claude, …" and pause ~1s when you finish (that's the turn detector deciding you're done). Want a pure open mic (no wake word)? Set CALL_WAKE=off. Ctrl+C ends the call.

The first run downloads a small Silero model and warms the whisper server. The first spoken turn loads your session context (slower; cached after that).

Commands

Command	What it does
claude-call	Start a voice call — resumes the Claude Code session in the current folder.
claude-call config	Interactive menu: voice (with live preview), style, language, model, echo, TTS provider.
claude-call doctor	Check prerequisites + model + config, and benchmark STT/TTS latency.

Configure

Run the interactive menu — pick your voice (with live preview), speaking style, language, brain model, echo mode and activation:

claude-call config

It writes your choices to .env. Prefer doing it by hand? Every setting is a plain env var:

All settings (.env or env vars)

Var	Default	What
CALL_LANG	en	Language (en, pt, es, fr, de, it, ja…). Picks a default voice + speech style.
CALL_VOICE	per-lang	Any edge-tts voice, or a voice id for a premium provider.
CALL_VOICE_RATE	+0%	Speaking speed (edge only).
CALL_TTS	edge	Voice provider — edge (free) or premium (see Premium voices).
CALL_MODEL	your default	opus / sonnet / haiku. Bigger = smarter & slower.
CALL_CONTINUE	1	Resume your most recent Claude Code session in CALL_CWD.
CALL_CWD	where you ran it	Which project's session to resume.
CALL_WAKE	(your name, e.g. claude)	Activation word — say it to address the agent (assistant mode). Defaults to CALL_NAME lowercased. off (or empty) = open mic (call mode).
CALL_ECHO_GATE	1	Mute mic while it speaks (use on speakers). 0 = barge-in (use headphones).
CALL_AEC	0	macOS hardware echo cancellation → barge-in without headphones (see below).
CALL_PERMISSION	--dangerously-skip-permissions	See Security.
CALL_STT	local	Speech-to-text engine: local (whisper.cpp) or an API provider — groq, openai, elevenlabs, google (see Speech-to-text).
CALL_STT_API_KEY	(empty)	Key for the API STT provider (or use the provider's own env var, e.g. GROQ_API_KEY).
CALL_STT_MODEL	per-provider	Override the STT model id (e.g. whisper-large-v3-turbo).
CALL_TTS_MODEL	per-provider	Override the TTS model id (premium providers).
CALL_NAME	Claude	What the agent calls itself / the activation word (the default CALL_WAKE). Change it in claude-call config → Name.
CALL_SYSTEM	per-lang	Override the spoken-style system rules (custom persona/instructions).
CALL_UI	1	Live terminal panel (transcript, state, levels). 0 = off.
CALL_SOUNDS	1	Sound cues (listening / thinking / wake). 0 = silent.
CALL_HOTKEY	f9	Push-to-talk key.
CALL_HOTKEY_SECS	3	Hold window for the hotkey.
CALL_CODE_MODEL	opus	Brain model for the agent (alias opus = Opus 4.8).
CALL_CODE_EFFORT	xhigh	Reasoning effort for the brain (low/medium/high/xhigh).
CALL_EFFORT	(empty)	Per-turn effort override (voice favors medium for speed).
CALL_IDLE_TIMEOUT	1800	Seconds idle before the call auto-ends.
CALL_TURN_TIMEOUT	120	Watchdog: max seconds stalled mid-turn.
CALL_TOOL_TIMEOUT	600	Watchdog ceiling while a tool (Bash/Task) is running — long builds aren't stalls.
CALL_FIRST_RESP_TIMEOUT	75	Watchdog: max seconds to first response.
CALL_ECHO_TAIL	0.8	Seconds the mic stays muted after it finishes speaking.
CALL_VAD_CONFIDENCE	0.5	Turn detector sensitivity (lower = hears more).
CALL_VAD_START_SECS	0.2	Noise filter — ignore blips shorter than this.
CALL_VAD_STOP_SECS	1.0	Silence to decide you're done (anti-cutoff).
CALL_VAD_MIN_VOLUME	0.2	Minimum volume counted as speech.
CALL_GOOGLE_PROJECT / CALL_GOOGLE_LOCATION	(empty)	For CALL_STT=google (Chirp 2) — GCP project/region; auth via gcloud ADC, no key.

Full list (STT model & port, greeting, active window, premium keys) is in .env.example.

Premium voices (optional, bring your own key)

Free edge-tts is the default and sounds great. If you want the newest, most realistic voices and don't mind paying the provider, plug in an API key:

CALL_TTS	Provider	Get a key / voices
edge	edge-tts (free, default)	—
elevenlabs	ElevenLabs — most realistic	elevenlabs.io
cartesia	Cartesia Sonic — ultra low latency	cartesia.ai
openai	OpenAI TTS	voices: alloy, nova, shimmer…
rime	Rime — natural conversational	[rime.ai](h