# Odile answering lines (remote · odilelabs.com)

A phone line for your app or business that answers calls, takes messages and bookings.

- Trust score: 80/100 (high trust)
- Registry status: active
- Liveness: live
- Owner verified: yes
- Last scored: 2026-11-04

## Components

- remote · `odilelabs.com`: 80/100 (this document), [markdown](https://verifymcp.io/servers/com-odilelabs-answering-lines/mcp-lines.md), [page](https://verifymcp.io/servers/com-odilelabs-answering-lines/mcp-lines)

## Channel facts

- Endpoint: `https://odilelabs.com/mcp/lines`
- Transports: `streamable-http`
- Auth: `required`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-04.

- **Endpoint Security**: 97/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation is enforced on tool calls, advertised via RFC 9728 protected-resource metadata. Discovery is public, which costs nothing: no tool can be invoked without a token.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC is configured correctly; the domain's records validate against the full chain to the root.
  - The authorisation server offers only Dynamic Client Registration (RFC 7591), which MCP 2026-07-28 deprecated in favour of Client ID Metadata Documents.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 62/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 3175 tokens (~352/item across 9 items; 9 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 13/100
  - Stability observed for 4 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 9 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 10 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Odile answering lines MCP server?

Odile answering lines is a hosted endpoint at https://odilelabs.com/mcp/lines, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http com-odilelabs-answering-lines 'https://odilelabs.com/mcp/lines'
```

### Cursor

```json
{
  "mcpServers": {
    "com-odilelabs-answering-lines": {
      "url": "https://odilelabs.com/mcp/lines"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-odilelabs-answering-lines": {
      "type": "http",
      "url": "https://odilelabs.com/mcp/lines"
    }
  }
}
```

### Codex

```toml
[mcp_servers.com-odilelabs-answering-lines]
url = "https://odilelabs.com/mcp/lines"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-odilelabs-answering-lines": {
      "type": "remote",
      "url": "https://odilelabs.com/mcp/lines",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-odilelabs-answering-lines --url 'https://odilelabs.com/mcp/lines' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  com-odilelabs-answering-lines:
    url: "https://odilelabs.com/mcp/lines"
```

### Netclaw

```json
{
  "McpServers": {
    "com-odilelabs-answering-lines": {
      "Transport": "http",
      "Url": "https://odilelabs.com/mcp/lines"
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-odilelabs-answering-lines -t streamable-http -u 'https://odilelabs.com/mcp/lines'
```

### Other

```json
{
  "mcpServers": {
    "com-odilelabs-answering-lines": {
      "type": "http",
      "url": "https://odilelabs.com/mcp/lines"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-04 (score 80, +1)

No change was recorded against any check on this day. Stability & Change Management went from 10 to 13. That category is still filling its 30-day observation window: 3 days of observed history at the previous scan, 4 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-02 (score 79, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-01 (score 78, +3)

- [security improvement] DNSSEC: fail → pass
- [security improvement] HSTS header: fail → pass
- [functional improvement] Stability: unverified → 0.03

### 2026-10-31 (score 75)

First indexed and scored.

## MCP tools (9)

### `get_answering_line_offer` (~238 tokens)

After Hours answering line, prepaid minutes or resolved conversations: the offer

Read the offer for starting a new After Hours answering line: a phone assistant that picks up the calls an owner forwards from their own business number, takes messages and bookings and tells the owner. Use it before set_up_answering_line, to tell the owner exactly what they would buy. It covers the prepaid minute packs, the per-resolved-conversation packs, the billing rules and what happens when a balance reaches zero. It covers After Hours lines only: Direct credit costs are in get_m2m_network and an existing line's balance is in get_answering_line. Offered in: US. The values come from the same tables checkout charges from, so they cannot drift from what is billed. Takes no arguments, needs no sign-in, reads no account and changes nothing. Returns { product, packs[{id, minutes, cents}], per_minute_cents, min_billable_seconds, billing_rule, at_zero, outcome_packs[{id, outcomes, cents}], per_outcome_cents, outcome_billing_rule, outcomes_at_zero, countries[], owner_must[], terms_url, set_up_with, top_up_with }.

### `try_answering_line` (~326 tokens)

Try an answering line free: a test number and code

Create a test call so you can hear an After Hours answering line before anything is set up: it returns a shared test phone number and a 4-digit code (valid 24 hours, up to 5 calls). Calling the number and keying the code reaches a phone assistant answering as the business you describe, and hear_url plays the same assistant in a browser. Nothing is booked, sent or charged on a test line, and it is not a real line: for one on the business's own number use set_up_answering_line. business_name and trade are required; trade sets what the assistant knows to ask, and area, hours, services and timezone shape what it says. Needs a signed-in account (any permissions); limited to 3 test lines a day per account, and rate limited. Returns { sandbox, test_number, test_number_e164, test_code, hear_url, expires_at, calls_allowed, how }.

Input parameters:

- `area` (string): Town or area, e.g. "Wellington, FL".
- `business_name` (string, required): The name the receptionist answers as, e.g. "Alvarez Plumbing".
- `hours` (string): Opening hours in words, e.g. "Mon-Fri 8 AM to 5 PM, closed weekends".
- `services` (array): Services, e.g. ["drain cleaning", "water heaters"].
- `timezone` (string): IANA timezone, default America/New_York.
- `trade` (string, required): The kind of business; it sets what the receptionist knows to ask.

### `set_up_answering_line` (~691 tokens)

Set up an After Hours answering line (prepaid minutes or resolved conversations)

Start setting up an After Hours answering line for the signed-in owner's business: a phone assistant that answers calls forwarded from the business's own number and takes messages and bookings for the owner. Nothing is built or bought until the owner pays: this returns a Stripe checkout link for the first pack, and once it is paid the line is set up automatically and its number and forwarding codes are emailed to the account's address. Only call it after showing the owner https://odilelabs.com/terms and getting a yes (owner_confirmed_terms true). The packs and billing rules are in get_answering_line_offer; a line that already exists is read with get_answering_line and topped up with buy_pack (product 'line_minutes' or 'line_outcomes', matching its billing_mode), not set up twice. United States only: business_phone and owner_mobile take any common US format with the area code and are stored as E.164, and Canadian area codes are refused. hours keys are day names (Monday, monday or mon); a day left out is closed, and omitting hours means Monday to Friday, 9 to 5. Messages reach the owner by email and the owner console; texts stay off until the owner switches them on there. Needs a signed-in connection with the lines:manage permission; limited to 3 set-ups a day per account, and rate limited. Returns { setup_id, status: 'awaiting payment', business_name, business_phone, pack, billing_mode, minutes or outcomes, price_cents, checkout_url, then }.

Input parameters:

- `business_name` (string, required): The business name callers should hear, e.g. "Alvarez Plumbing".
- `business_phone` (string, required): The business number callers dial today (US, with area code, any common format such as (561) 555-0123). The owner forwards it to the new line.
- `city` (string): The town the business is in, e.g. "Wellington, FL". The receptionist says it when a caller asks where you are.
- `country` (string): Only US for now.
- `description` (string): What the business does, in one line; this is what it tells callers.
- `extra` (string): Anything else the receptionist should know.
- `hours` (object): Opening hours by day name, e.g. {"Monday": {"open": "8:00 AM", "close": "5:00 PM"}, "Sunday": "closed"}. A day left out is closed. Omit entirely for Monday to Friday, 9 to 5.
- `languages` (array): Languages besides English the receptionist switches to when a caller does.
- `owner_confirmed_terms` (boolean, required): true ONLY after you showed the owner https://odilelabs.com/terms and they said yes. Anything else is refused.
- `owner_mobile` (string, required): The owner's own mobile (US, with area code): their calls to the line are never charged.
- `pack` (string, required): The first pack: min40: 40 minutes; min200: 200 minutes; out50: 50 resolved conversations; out200: 200 resolved conversations. Amounts and billing rules: get_answering_line_offer.
- `services` (array): Up to 12 services, e.g. ["drain cleaning", "water heaters"].

### `get_sip_address` (~167 tokens)

Your line's SIP address

Create (first call) or read the SIP address and private trunk credentials for one of the signed-in owner's answering lines, so the owner's phone system can send calls to the line over SIP, with no phone number, instead of forwarding a number. For the line's number and forwarding codes use get_answering_line. Pass the line_id from get_answering_line; a line that is still being set up returns an error. Returns { alias, sip_uri, sip_uri_tls, username, password }; keep the username and password private. The address is created once and repeat calls return the same one. SIP calls use the line's normal balance with no separate SIP charge. Needs lines:manage; rate limited per account.

Input parameters:

- `line_id` (string, required): From get_answering_line.

### `get_answering_line` (~223 tokens)

The owner's answering lines: status, number, balance, recent calls

List the signed-in owner's own After Hours answering lines and any set-ups still awaiting payment (under pending). Use it first: it returns the line_id that get_line_calls, get_line_messages, get_sip_address and buy_pack need. For each line it returns status (live, queued, setting up or closed), number, billing_mode, balance (seconds, outcomes or legacy calls; minutes_remaining to one decimal for minute lines, outcomes_remaining for outcome lines), forwarding (per carrier, the code that starts forwarding and, where the carrier has one, the stop code that turns it off) and the latest 10 recent_calls, with callers shown by their last four digits only. The full call list is get_line_calls and the messages callers left are get_line_messages. There is no tool to pause, edit or close a line: stop forwarding with the stop code, and use the owner console (https://odilelabs.com/owner) for settings, billing, call audio and transcripts. Needs lines:manage; changes nothing; rate limited per account.

### `get_line_calls` (~234 tokens)

One line's recent calls

List the incoming calls answered by one of the signed-in owner's own lines, newest first, with the full caller number (E.164 or null) that get_answering_line shows only as its last four digits. Each item has id, at (ISO), caller, duration_seconds, summary when there is one, and urgent when known. Pass the line_id from get_answering_line; limit sets the page size, and to read further back pass the previous result's next_before as before (next_before is null when there is nothing older). It covers recent calls only, so older ones may not be returned. No audio links or transcripts: open the call in the owner console (https://odilelabs.com/owner). The messages callers left are in get_line_messages, and calls you placed with call_business are read with get_call_result. Needs lines:manage; changes nothing; rate limited per account.

Input parameters:

- `before` (string): ISO timestamp cursor: only calls before this.
- `limit` (integer): Default 25, max 100.
- `line_id` (string, required): From get_answering_line.

### `get_line_messages` (~195 tokens)

One line's recent messages

List the messages the answering line took from callers for one of the signed-in owner's own lines, newest first. Each item has id, at (ISO), name, phone, message and urgent, so it holds callers' names and phone numbers. Pass the line_id from get_answering_line; limit sets the page size, and to read further back pass the previous result's next_before as before (next_before is null when there is nothing older). It reaches back through at most the 500 most recent messages. The calls themselves, with duration and summary, are in get_line_calls. Replies from businesses you contacted through Direct are in get_replies. Needs lines:manage; changes nothing; rate limited per account.

Input parameters:

- `before` (string): ISO timestamp cursor: only messages before this.
- `limit` (integer): Default 25, max 100.
- `line_id` (string, required): From get_answering_line.

### `get_receptionist_benchmark` (~405 tokens)

Published receptionist benchmark: real test calls, scored in public

Read Odile Labs' published benchmark of AI phone answering products: real test calls placed to public lines, scored against stated measures. Use it when someone asks how AI phone answering handles real calls, or to compare named products. Vendor-run by Odile Labs (which sells After Hours and Dusklin), so not independent. It does not test the caller's own line (read_more.free_line_check does). Call it with no arguments first, then narrow with line_id and scenario_id; both come from that first response, and an unknown id returns an error listing the valid ones. include_evidence adds the quoted transcript behind each point (much longer output). Returns { source, date, calls, minutes, run_by, limitations, fairness_note, scenarios[{id,name,brief}], lines[{id, vendor, business, kind, answers_as, list_price, ranked, points, possible, by_scenario{<scenario_id>:{points, possible, answered, first_words_s, ai_disclosed_unprompted, reply_language, price_quoted, measures}}}], read_more }. Needs no sign-in; reads a published file and changes nothing.

Input parameters:

- `include_evidence` (boolean): Default false: each scenario's measures come back as strings like 'yes: <measure>'. true: measures come back as [{measure, score (0 or 1), evidence (quoted transcript)}] (much longer output).
- `line_id` (string): Only this tested line, e.g. 'afterhours-plumbing', 'afterhours-vet', 'rosie', 'myaifrontdesk' or 'dialzara'. Omit for every line.
- `scenario_id` (string): Only this scenario: 'emergency' (leak after hours), 'booking' (book a slot), 'price' (price probe), 'disclosure' (are you real?) or 'spanish' (caller in Spanish). Omit for all.

### `buy_pack` (~479 tokens)

Checkout link for Formats credits, meeting minutes, phone minutes, resolved conversations, Plate API photos or legacy calls

Returns a one-time Stripe checkout link for a prepaid pack, to top up something that already exists; to start a new answering line use set_up_answering_line. The customer opens the link and pays on Stripe's own page, and this connection never sees the card. Only call it when the customer asked to buy, and tell them the price first. product picks what is bought: 'line_minutes' (phone minutes for an After Hours line; line_id required; min40: 40 minutes for $10; min200: 200 minutes for $50), 'line_outcomes' (resolved conversations for an outcome line; line_id required; out50: 50 resolved conversations for $24.50; out200: 200 resolved conversations for $98), 'direct' (Direct credits: direct100c, direct1000, direct10000), 'formats' (Odile Formats credits: small, medium, large), 'photos' (Plate API photo credits: starter: 1000 photos for $10; growth: 5000 photos for $45; scale: 20000 photos for $160), 'minutes' (meeting minutes, only where Meeting Notes is on) or 'calls' (legacy per-call lines only; line_id required). For line products the pack must match the line's billing_mode. What was paid is added within a minute of payment, whatever device paid it. Nothing renews. Needs a signed-in connection with the billing:checkout permission; rate limited per account. Returns { checkout_url, product, pack, price_cents, units, unit, then }.

Input parameters:

- `line_id` (string): For product 'calls', 'line_minutes' or 'line_outcomes': the line_id from get_answering_line.
- `pack` (string, required): The pack id: formats small | medium | large; minutes m200 | m600 | m2000; calls calls10 | calls50; phone minutes min40 | min200; outcomes out50 | out200; photos starter | growth | scale; direct direc…
- `product` (string, required): 'formats' credits, meeting 'minutes', phone 'line_minutes', resolved 'line_outcomes', Plate API 'photos', legacy answered 'calls' or 'direct' Direct credits.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/com-odilelabs-answering-lines/mcp-lines#diagnostics

## Score history

- 2026-11-04: 80
- 2026-11-03: 79
- 2026-11-02: 79
- 2026-11-01: 78
- 2026-10-31: 75

## Common questions

### What is the Odile answering lines MCP server?

Odile answering lines is an MCP server listed in the public MCP registry as com.odilelabs/answering-lines. A phone line for your app or business that answers calls, takes messages and bookings. This page covers its hosted endpoint (https://odilelabs.com/mcp/lines). Its publisher has verified ownership with us.

### Is the Odile answering lines MCP server safe to use?

Odile answering lines scores 80 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Odile answering lines MCP server expose?

Odile answering lines exposes 9 tools: get_answering_line_offer, try_answering_line, set_up_answering_line, get_sip_address, get_answering_line, and 4 more. Their descriptions and schemas cost roughly 2,958 tokens of context every time the server is loaded.

### Does the Odile answering lines MCP server require authentication?

Yes. Odile answering lines asked us for credentials when we connected, so you will need to authorise it in your MCP client before it can do anything.

### Is the Odile answering lines MCP server still maintained?

Odile answering lines is still listed as active in the MCP registry. We last reached this channel on 4 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://odilelabs.com/mcp/lines
- Repository: https://github.com/tolga-boop/odile-mcp
- Website: https://odilelabs.com/developers
- Changelog RSS feed: https://verifymcp.io/servers/com-odilelabs-answering-lines/mcp-lines.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-odilelabs-answering-lines/mcp-lines.json
- HTML version of this page: https://verifymcp.io/servers/com-odilelabs-answering-lines/mcp-lines