Rime Calls: connector documentation

Rime Calls is a Muse connector from Rime Labs, Inc. This page follows what Meta's connector guidelines ask for (§5.4): setup, inputs and outputs, read/write and sensitive designations, permissions, side effects, status handling, errors and rate limits. Support and security: ares@rime.ai.

What it does

Lets a Muse user have an AI voice agent phone a business for them, for example to book a table, ask about opening hours or check an order. The agent runs on Rime Prism, Rime's speech-to-speech model. It says it is an AI assistant calling for the user and that the call is transcribed, works toward the goal the user approved, agrees to nothing beyond what the user allowed, and hangs up when done. The user then gets a summary and a transcript.

This is a Rime-funded demo. There are no user accounts and no charges to users. Rime pays for all calls, within the daily limits below.

Setup

Field	Value
Connection	Existing MCP server, streamable HTTP
Endpoint	`https://muse-connector-m3jasmbv4a-uk.a.run.app/mcp`
Authentication	API key, sent as `Authorization: Bearer <key>`: the connector's shared key, or a user's own Rime API key (see below).
Scopes	None. Every tool is available to the key.
Test credentials	A test key on the same endpoint. Calls placed with it never dial out: Rime's test line answers them, so review never reaches a real business (see Testing).

Using your own Rime API key

Anyone can add Rime Calls to their own Muse as a custom connector with their own Rime API key as the Bearer key. Then:

The key is checked with Rime on first use and refused if it isn't valid, or if it doesn't have access to Prism. That check happens before dialing.
The call's voice agent runs on that key, so Prism usage is billed to that Rime account. The phone line and the post-call report are on Rime.
Only that key can read its calls.
Each key gets its own daily budget: 20 calls and 60 connected minutes. All users' keys together also share a daily budget of 300 calls and 1,000 connected minutes. All the other rules apply too: business lines only, calling hours, do-not-call, and 2 calls per number per day across everyone (20 for a toll-free number).
The key is never stored. The server holds it in memory only while the call runs, and lets go of it when the call ends, answered or not. Calls are tied to a hash of it.

Tools

Tool	Classification	Approval in Muse
`start_call`	Sensitive write: places a real phone call on the user's behalf	Every use
`hang_up`	Write: ends a call the user started	First use, then per use unless always allowed
`get_call`	Read	First use, then per use unless always allowed

The MCP tool annotations agree with this: start_call and hang_up set destructiveHint, and get_call sets readOnlyHint.

Who can read a call. Every user of the connector shares one key, so the key alone can't tell whose call is whose. Instead: - A call is reachable only by its call_id. start_call returns it, it's 128 random bits, and there's no tool that lists calls. - The test key reaches only test calls, and the production key only real ones. - A call that isn't reachable gets the same "no call" error as an id that doesn't exist.

`start_call` (sensitive write)

Places an outbound call and returns at once. The call goes on without Muse.

Input	Required	Meaning
`to`	yes	The business's number, in any common US/Canadian format
`goal`	yes	What the call should achieve
`on_behalf_of`	yes	The user's name, as the agent says it on the call
`may_agree_to`	no	What the agent may accept without checking back. When empty, it agrees to nothing beyond the goal.
`context`	no	Facts the agent may share on the call
`recipient_name`	no	Who is expected to answer
`voice`	no	`wawona` (default), `astra`, `aurora`, `brando`
`max_minutes`	no	Length limit, at most 30. Default 5. Use 30 for a business likely to put the call on hold.

What the approval covers. Muse's approval card shows every input above, and the call follows exactly those details. On the call, the agent will not agree to anything outside may_agree_to. It never gives payment details. If the business asks for something else, the agent says it will check with the user, which ends in an outcome for the user to act on rather than a commitment.

Side effects. - A phone call to to from Rime's number. - The call is transcribed. - If the callee asks not to be called again, the number goes on the do-not-call list.

Output. call_id, to, status (queued), goal and on_behalf_of.

`get_call` (read)

The status, report and transcript of one call. wait_seconds (up to 120) holds the answer until the call ends and its report is written, so a single call can return the finished result.

Once the call is over, report is what to show the user. A text model writes it from the transcript and what the user asked for, a few seconds after hang-up:

Field	Meaning
`result`	`done`, `partly_done`, `not_done`, `no_answer`, `voicemail_left` or `failed`. `done` only if the other side clearly confirmed it.
`summary`	Two to four sentences on how the call went, keeping the nuance: conditions, offers, deadlines, who they spoke to
`facts`	Concrete details learned (times, prices, names, numbers, confirmation codes), each as a `label` and `value`
`commitments`	Anything the agent agreed to or promised on the user's behalf, with `within_limits` saying whether it fell within `may_agree_to`
`next_steps`	What the user needs to do, most urgent first
`open_questions`	Questions the other side asked that the agent couldn't answer

While the report is being written, report is "being written". If it couldn't be written, report is null and report_error says why. outcome is the agent's own one-line summary, kept for reference. When it disagrees with the report, the report is right.

For a recorded call (a test-line call, or a call to one of Rime's own team phones), recording is a link to its audio: a stereo WAV, the other side on the left and the agent on the right. It downloads only with the key that placed the call, sent as Authorization: Bearer <key>.

`hang_up` (write)

Ends a call that is ringing or in progress. Calling it on a call that has already ended does nothing and returns the call.

Call statuses

queued → ringing → in-progress → one of completed, busy, no-answer, failed, canceled. The last five are final. answered_by is human, or machine_end_* when the call reached voicemail, in which case the agent leaves a short message. outcome is the agent's summary, or why the call ended. error is set only when the call failed on Rime's side.

Which calls are allowed

start_call refuses, with a message saying why:

Numbers outside the US and Canada, premium-rate numbers, and fictional 555-01xx numbers.
Personal cell phones. Twilio Lookup's line type must be landline, fixed VoIP, non-fixed VoIP or toll-free. This is a demo for calling businesses.
Calls outside 9:00 to 20:00 in the callee's local time. The message gives the next opening. This rule doesn't apply to the test key, so review can happen at any hour.
Numbers on the do-not-call list.
Numbers already called twice in the last 24 hours. A toll-free number, which reaches a company's call centre, can take 20.
Calls once the demo's daily budget is spent: 50 calls or 150 connected minutes over the last 24 hours.
Calls with a user's own Rime key once that key's budget is spent (20 calls or 60 connected minutes), or once all users' keys together have spent theirs (300 calls or 1,000 connected minutes). The message says to try again tomorrow.
Calls beyond 2 at once. The message says to try again in about 10 minutes.

Errors

Tool errors come back as MCP tool errors (isError: true) whose text says what to fix or why the call isn't allowed. A refused call is never placed, and it isn't counted against any limit.

Rate limits

2 concurrent calls.
Test-key calls have their own daily budget, separate from real calls.
50 calls and 150 connected minutes per rolling 24 hours for the shared demo key.
20 calls and 60 connected minutes per rolling 24 hours for each user's own Rime key, and 300 calls and 1,000 connected minutes for all users' keys together.
2 calls per destination number per 24 hours, or 20 for a toll-free number.
30 minutes per call at most, enforced by the phone carrier as well.
A call that hasn't ended 5 minutes after its ringing time and time limit is ended and marked failed, so it can't hold a line.

Data

Data	Why	Kept
The number called, the goal, context, `on_behalf_of` and `may_agree_to`	To place and run the call	30 days
Call transcript, outcome and report	Returned to the user through `get_call`	30 days
Do-not-call list (numbers only)	To honor opt-outs	Indefinitely
Call audio	Streamed live to the agent, never stored	Not kept
Recordings of test-line calls and calls to Rime's own team phones	So Rime can review its own test calls. The agent says at the start that the call is recorded. No other call is recorded.	30 days

Processor	What it receives	Purpose
Twilio	The number called; the call's audio in transit	Placing the call, checking the line type
Rime Prism	The call's audio and the call instructions	Running the conversation
OpenAI API	The transcript and the call's details	Writing the report after the call
Google Cloud	Call records, and recordings of test-line calls	Hosting and storage, in `us-east4`

Records are deleted automatically 30 days after they're written.
Processors run under zero data retention (ZDR).
Data isn't sold, used for advertising or profiling, or used to train models.
It's encrypted in transit (HTTPS and WSS throughout) and at rest.
Privacy policy: rime.ai/privacy. Terms: rime.ai/terms.

Testing

Use the test key. It works exactly like production, with one difference: whatever number to names, the call doesn't dial out. Rime's test line answers it, and an AI receptionist (a second Prism voice) plays whatever business recipient_name names. When recipient_name is empty, it plays Luigi's Trattoria, an Italian restaurant. Nothing is charged.

Made-up numbers are fine, for example (415) 555-2671. Every rule except calling hours still applies, so each refusal can be tested as well.

Test-line calls are recorded, and the agent says so when the call starts. Once the call ends, get_call returns a recording link to its audio.

Try	How	What happens
A booking	`goal` "Book a table for 2 at 7pm Friday", `may_agree_to` "7:00 or 7:30"	The host books it. `get_call` returns the report, `result` `done`.
The agent's limits	`goal` "Book a table for 2 at 8pm Friday", `may_agree_to` "8:00 only"	The host offers only 7:00 or 7:30. The agent declines; the report says `not_done` and passes the options on.
Do-not-call	Put "do not call" in `goal`	The host asks to be taken off the list. The agent apologizes and hangs up, and the next `start_call` to that number is refused.
Voicemail	Put "voicemail" in `goal`	A greeting and a beep. The agent leaves a short message and hangs up. `answered_by` is `machine_end_beep`.
Hanging up	`hang_up` while a call is in progress	The call ends at once.
Waiting for the result	`get_call` with `wait_seconds` 60	Returns once the call ends and its report is written.
Refusals	`to` a personal cell phone, a +44 number, or a 900 number	`start_call` refuses with the reason, and nothing is placed.