# your coding agent can call you when it gets stuck

agentvoice is an MCP server that gives your coding agent a phone line - it calls you when it is blocked or done, and places real, disclosed calls to businesses.

## install

```
npx @spekoai/mcp-calls@latest init
```

signs you in, writes detected client configs, and installs the Claude skill when applicable. free call credits on signup. no card.

Manual (Claude Code):

```
claude mcp add speko-calls --scope user --env SPEKO_API_KEY=sk_... --env SPEKO_CLIENT_PROFILE=claude-code -- npx -y @spekoai/mcp-calls@latest
```

For a local setup that is not already owner-verified, set the API key in the current shell first. POSIX:

```
export SPEKO_API_KEY=sk_...
```

PowerShell:

```
$env:SPEKO_API_KEY='sk_...'
```

Then run the portable verification command below. This places one real, disclosed voice-OTP call. Owner verification supports NANP (+1) numbers today:

```
npx -y @spekoai/mcp-calls@latest me verify
```

In remote mode, run owner verification on the backing-server host with `SPEKO_MCP_SERVER_URL` unset.

Claude Code project-scoped `.mcp.json` (commit it - the key expands from each dev's shell env, never lands in the repo):

```json
{
  "mcpServers": {
    "speko-calls": {
      "command": "npx",
      "args": ["-y", "@spekoai/mcp-calls@latest"],
      "env": {
        "SPEKO_API_KEY": "${SPEKO_API_KEY}",
        "SPEKO_CLIENT_PROFILE": "claude-code"
      }
    }
  }
}
```

## how it works

1. `call_me` rings your locally verified number. no destination input.
2. `you answer` give direction; hear it read back.
3. `result` a spoken CONFIRMED after the read-back becomes final_instruction. anything else stays advisory.

Give the active coding run this rule: `while the coding run is still active: if you get blocked or finish, use call_me. if it returns before the reply, poll get_call until terminal before yielding.`

This is not a wake-from-idle timer. MCP cannot restart a coding client after its active turn has ended.

calling a business? lookup_business + make_call uses a verified dial token, or call_number calls a number you already have.

## tools

- `call_me(message, mode?, context?, after_hours_confirmation?, max_duration_seconds?, wait?)` - calls this install's locally verified owner number - no destination input. notify delivers a message; converse returns an untrusted voice transcript from an unverified speaker: a spoken CONFIRMED after the literal read-back creates final_instruction; unconfirmed replies stay advisory. voice only - no SMS or iMessage.
- `lookup_business(name, location?, phone_number?, utc_offset_minutes?)` - finds the business, carrier-verifies the line, and mints the signed dial token that make_call requires - the agent never dials a hallucinated number.
- `make_call(dial_token, objective, caller_name, context?, behavior?, greet_first?, after_hours_confirmation?, max_duration_seconds?, wait?)` - places the disclosed, objective-scoped call a dial token authorizes. returns the OUTCOME line and the full transcript.
- `call_number(phone_number, objective, caller_name, recipient_name?, context?, behavior?, greet_first?, utc_offset_minutes?, after_hours_confirmation?, max_duration_seconds?, wait?)` - disclosed call to a number you already have or found. disclosure, rate caps, the do-not-call list, and the hours gate still bind. personal mobiles: consenting parties only.
- `get_call(call_id)` - re-checks a call by id: status, outcome, transcript. read-only, never dials.
- `check_call_readiness()` - preflight: auth, credit balance, caller-ID, owner-number setup. read-only, never dials.

## safety

every call says it's an AI. no exceptions.

- **owner destination is not an input** - call_me accepts no destination - it dials the owner number verified by one real, disclosed voice-OTP call (NANP +1 numbers today). the person who answers is still not identity-verified, so replies stay untrusted data. every ordinary rail applies; local verification relaxes nothing.
- **AI disclosure, composed server-side** - every call opens with "Hi, I'm <name>'s AI assistant..." - built into the opener server-side, not a prompt suggestion. it answers truthfully if asked "are you a robot".
- **signed dial tokens** - HMAC-SHA256, account-bound, 15-minute TTL. lookup_business mints them; make_call requires them. raw numbers are rejected on the verified path.
- **business-line verification** - on the lookup path, dial tokens only mint for carrier-verified business lines.
- **per-number rate caps** - 3 calls per hour, 8 per day to the same number. the rejection tells you when the window reopens.
- **do-not-call list with auto opt-out** - "stop calling" / "take me off your list" in a callee turn is detected and the number is suppressed automatically. manage it with speko dnc.
- **after-hours gate** - calls outside 08:00-21:00 destination-local require typed confirmation - the server records it but cannot attribute it to a speaker, so clients pass the human's own words, never invent them. collection-flavored calls are day-hours-only, no override.
- **no-sell, no-spam, no-impersonation** - selling, promotion, surveys, fundraising, campaigning, harassment, and pretending to be someone else are screened on objective, behavior, AND context - blocked intent can't be smuggled sideways.
- **hard number blocks** - emergency and premium-rate numbers can never be dialed. no opt-in exists.
- **honest failure states** - a call the platform never put on the wire returns not_connected - never a fake success. transcripts and outcomes are returned when captured; no result is ever invented.

## pricing

Free call credits to start; usage pricing lives in the dashboard: https://platform.speko.dev

## faq

### Can my coding agent call me?

Yes. call_me rings this install's locally verified owner number and accepts no destination (verification supports NANP +1 numbers today). Replies come back as an untrusted voice transcript from an unverified speaker: a spoken CONFIRMED response after the literal read-back creates final_instruction; unconfirmed replies stay advisory. The server also places disclosed outbound business calls.

### Can it text me, or call me after I stop replying?

No. Owner control is outbound voice only - no SMS or iMessage, no inbound hotline. And MCP cannot start a new model turn after the client session is idle, so call_me is not a background timer: the call happens while the run is active, and any nonterminal result must be polled with get_call before the run yields. Results stay retrievable later by call_id.

### Is this legal? Do people know they are talking to an AI?

Every call opens with a non-removable AI disclosure - "Hi, I'm <your name>'s AI assistant..." - composed server-side, and it answers truthfully if asked whether it is a robot. Calls are objective-scoped and transactional; selling, spam, surveys, and impersonation are screened server-side. Personal mobiles: consenting parties only. Designed for the FCC's AI-disclosure expectations; not legal advice.

### What does it cost?

Start with free call credits, no card. Usage pricing lives in the dashboard at platform.speko.dev. The published business-call demo is a real 54-second call that cost $0.11.

### Which coding agents work with it?

Any stdio MCP client can run it. The init command configures each supported client it detects: Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, Cline, Gemini CLI, and Codex. Zed gets a paste-ready manual snippet.

### What happens if nobody answers, or the call fails?

You get the truth: not_placed (account not configured), not_connected (never reached the wire), timeout (still running - poll get_call, never re-dial), or completed with connected/answered booleans. No fake successes.

### Can it call any number?

No. Emergency and premium-rate numbers are never dialable. Per-number rate caps (3/hour, 8/day), a do-not-call list with automatic opt-out detection, and an 08:00-21:00 destination-local hours gate bind server-side, where they cannot be patched around.

## demo (real session)

Call `71f83d0e` - 54s, $0.11. Outcome: order placed and confirmed. Full transcript: https://agentvoice.to/demo.md

---

they let agents spend money and dial humans blind; we report what happened, what it cost, and refuse the calls that shouldn't happen.

- npm: https://www.npmjs.com/package/@spekoai/mcp-calls (MIT licensed)
- source: https://github.com/SpekoAI/mcp-dev-calls
- api keys: https://platform.speko.dev
- built with Speko: https://speko.ai