# AgentLine (remote · api.agentline.cloud)

Give AI agents a phone number. Voice calls, SMS, and phone number management for MCP clients.

- Trust score: 33/100 (low)
- Change this week: −23
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `api.agentline.cloud`: 33/100 (this document), [markdown](https://verifymcp.io/servers/agentlinehq-agentline/api.md), [page](https://verifymcp.io/servers/agentlinehq-agentline/api)

## Channel facts

- Endpoint: `https://api.agentline.cloud/mcp`
- Transports: `streamable-http`
- Auth: `none`
- 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-08-03.

- **Endpoint Security**: 83/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - The endpoint enforces authorisation, but returns a challenge with no valid RFC 9728 metadata, so a client cannot discover where to get a token.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 0/100
  - Transport blocked by authentication: the endpoint requires auth we don't have to verify streamable-http.
- **Schema Quality & AI Usability**: 0/100
  - Schema blocked by authentication: the endpoint requires auth we don't have to read it.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 0/100
  - Tool coverage blocked by authentication: the endpoint requires auth we don't have to read its tools.
- **Capabilities**: 0/100
  - Capabilities blocked by authentication: the endpoint requires auth we don't have to read them.

**Unverified: 5 categories.** Categories scored 0 because we could not verify them: authentication we do not have, an unreachable endpoint, or not enough scan history. We only credit what we can confirm.

## Install

### Claude

```bash
claude mcp add --transport http agentlinehq-agentline https://api.agentline.cloud/mcp
```

### Codex

```toml
[mcp_servers.agentlinehq-agentline]
url = "https://api.agentline.cloud/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "agentlinehq-agentline": {
      "type": "remote",
      "url": "https://api.agentline.cloud/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add agentlinehq-agentline --url https://api.agentline.cloud/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  agentlinehq-agentline:
    url: "https://api.agentline.cloud/mcp"
```

### Other

```json
{
  "mcpServers": {
    "agentlinehq-agentline": {
      "type": "http",
      "url": "https://api.agentline.cloud/mcp"
    }
  }
}
```

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-08-02 (score 33, −27)

- [security regression] Endpoint reachability: reachable → behind authorisation
- [security regression] Stability: 0.20 → unverified
- [security regression] Transport: pass → unverified
- [security] Authorization: The endpoint enforces authorisation, but returns a challenge with no valid RFC 9728 metadata, so a client cannot discover where to get a token.
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional] First check of Schema quality: unverified

### 2026-07-31 (score 60, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 59, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-28 (score 58, +2)

- [security] Tool “push_call_context” rewrote its description, which is the text the model reads

### 2026-07-27 (score 56, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 56)

First indexed and scored.

## MCP tools (28)

### `list_agents` (~86 tokens)

List Agents

List all AI voice agents configured on your account.

Returns every AI phone agent you've created, including their
system prompts, voice settings, and associated phone numbers.
Useful for checking which agents are ready to make or receive calls.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```

### `create_agent` (~1128 tokens)

Create Agent

Create a new AI voice agent for telephony.

Sets up a new AI phone agent with a custom system prompt, voice,
and greeting. Once created, buy a phone number and attach it to
this agent so it can make and receive calls autonomously.

Fields:
  \- name: Display name for the agent
  \- system_prompt: Instructions that define the agent's personality and behavior on calls
  \- initial_greeting: What the AI agent says when the call connects
  \- voice_id: TTS voice preset (e.g. "female-1") or Cartesia UUID
  \- transfer_number: Phone number to transfer calls to (e.g. a human operator)
  \- voicemail_message: Message the agent leaves if the call goes to voicemail

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Example Response:**
\```json
{
  "id": "Id",
  "account_id": "Account Id",
  "name": "Name",
  "created_at": "2023-01-01T00:00:00Z"
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "id": {
      "type": "string",
      "title": "Id",
      "description": "Unique agent identifier (e.g. 'agt_abc123')"
    },
    "account_id": {
      "type": "string",
      "title": "Account Id",
      "description": "Account that owns this agent"
    },
    "name": {
      "type": "string",
      "title": "Name",
      "description": "Display name of the AI voice agent"
    },
    "system_prompt": {
      "title": "System Prompt",
      "description": "Default system prompt for all calls (can be overridden per-call)"
    },
    "initial_greeting": {
      "title": "Initial Greeting",
      "description": "Default greeting for all calls (can be overridden per-call)"
    },
    "voice_id": {
      "title": "Voice Id",
      "description": "TTS voice preset or Cartesia UUID"
    },
    "transfer_number": {
      "title": "Transfer Number",
      "description": "Phone number for call transfers"
    },
    "voicemail_message": {
      "title": "Voicemail Message",
      "description": "Message left on voicemail"
    },…

Input parameters:

- `initial_greeting` (string): Default opening line spoken on ALL calls (inbound and outbound), e.g. 'Hello, how can I help you today?'. Can be overridden per-call via POST /v1/calls.
- `name` (string, required): Display name for the AI voice agent
- `owner_phone` (string): Owner's phone number in E.164 format (e.g. '+12125551234'). Calls from this number enter task mode — the agent treats speech as executable instructions.
- `system_prompt` (string): Default instructions for the agent's personality and behavior on ALL calls (inbound and outbound). Can be overridden per-call via POST /v1/calls.
- `transfer_number` (string): Phone number in E.164 format to transfer calls to (e.g. a human operator fallback)
- `voice_id` (string): TTS voice preset name (e.g. 'female-1', 'male-1') or Cartesia voice UUID; defaults to system voice if not set
- `voicemail_message` (string): Message the AI agent leaves if the call goes to voicemail

### `get_agent` (~346 tokens)

Get Agent

Get details of a specific AI voice agent.

Returns the agent's full configuration including system prompt,
voice settings, greeting, and transfer number.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `agent_id` (string, required)

### `update_agent` (~500 tokens)

Update Agent

Update an AI voice agent's configuration.

Modify any combination of the agent's settings: system prompt,
voice, greeting, transfer number, or voicemail message.
Changes take effect on the next call the agent handles.
Only include the fields you want to change — unset fields are preserved.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `agent_id` (string, required)
- `initial_greeting` (string): Updated default greeting for ALL future calls (inbound and outbound)
- `name` (string): New display name for the AI voice agent
- `owner_phone` (string): Updated owner phone number in E.164 format for task mode
- `system_prompt` (string): Updated default instructions for ALL future calls (does not affect calls already in progress)
- `transfer_number` (string): Updated transfer phone number in E.164 format
- `voice_id` (string): New TTS voice preset name or Cartesia voice UUID
- `voicemail_message` (string): Updated voicemail message

### `delete_agent` (~358 tokens)

Delete Agent

Delete an AI voice agent.

Permanently removes the agent and detaches any phone numbers
assigned to it. Detached numbers remain active on your account
and can be reassigned to another agent.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `agent_id` (string, required)

### `list_phone_numbers` (~85 tokens)

List Numbers

List all phone numbers provisioned on your account.

Returns every phone number you've bought for your AI agents,
including which agent each number is assigned to, the number's
status (active/released), and country.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```

### `buy_phone_number` (~579 tokens)

Provision

Buy a US phone number for your AI agent.

Searches for and purchases a real US phone number from the telephony
provider, then attaches it to the specified AI agent. Once attached,
the agent can make outbound calls and receive inbound calls on this number.

Each AI agent can only have ONE active phone number. Costs $2.00 per number.

Request body:
  \- agent_id: str (required) — the AI agent to assign this number to
  \- country: str (must be "US")
  \- number_type: "local" | "tollfree"
  \- area_code: preferred 3-digit US area code (e.g. "212" for NYC, "415" for SF)

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `agent_id` (string, required): ID of the AI agent to assign this phone number to (e.g. 'agt_abc123')
- `area_code` (string): Preferred 3-digit US area code (e.g. '212' for NYC, '415' for SF, '310' for LA)
- `country` (string): Country code for the phone number (currently only 'US' is supported)
- `number_type` (string): Type of phone number: 'local' or 'tollfree'
- `pattern` (string): Legacy digit pattern match (prefer area_code instead)

### `list_messages` (~413 tokens)

List Messages

List SMS messages sent and received by your AI agents.

Returns message history with optional filters by AI agent or
conversation. Each entry includes direction (inbound/outbound),
phone numbers, message body, and delivery status.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `agent_id` (string): Filter messages by AI agent ID
- `conversation_id` (string): Filter messages by conversation thread ID
- `limit` (integer): Maximum number of messages to return (1-200)
- `offset` (integer): Number of messages to skip for pagination

### `make_outbound_call` (~697 tokens)

Create Call

Make an outbound phone call from your AI agent.

Initiates a real phone call from the AI agent's phone number to the
specified destination. The agent uses its configured system prompt,
voice, and greeting to conduct the conversation autonomously.

The AI agent handles the entire call — speech-to-text, LLM reasoning,
and text-to-speech — in real time. The call transcript is saved
automatically and can be retrieved via GET /v1/calls/{call_id}/transcript.

Request body:
  \- agent_id: the AI agent making the call
  \- to_number: destination phone number in E.164 format (e.g. "+12125551234")
  \- from_number_id: (optional) specific number to call from
  \- system_prompt: (optional) override the agent's default prompt for this call
  \- initial_greeting: (optional) override the agent's greeting for this call
  \- voice_id: (optional) override the voice for this call

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Deta…

Input parameters:

- `agent_id` (string, required): ID of the AI agent making the call (e.g. 'agt_abc123')
- `from_number_id` (string): Specific phone number ID to call from; defaults to the agent's assigned number
- `initial_greeting` (string): Per-call greeting override. Replaces the agent's default greeting for this call ONLY. If omitted, the agent's default initial_greeting is used.
- `system_prompt` (string): Per-call system prompt override. Replaces the agent's default prompt for this call ONLY. If omitted, the agent's default system_prompt is used.
- `to_number` (string, required): Destination phone number in E.164 format (e.g. '+12125551234')
- `voice_id` (string): Override the TTS voice for this call: preset name (e.g. 'female-1') or Cartesia UUID

### `list_calls` (~454 tokens)

List Calls

List voice calls made by your AI agents.

Returns call history with optional filters by agent or status.
Each entry includes direction (inbound/outbound), duration,
phone numbers, and current status.

Filters:
  \- agent_id: only calls for a specific AI agent
  \- status: "initiated", "in-progress", "completed", or "failed"

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `agent_id` (string): Filter calls by AI agent ID
- `limit` (integer): Maximum number of calls to return (1-200)
- `offset` (integer): Number of calls to skip for pagination
- `status` (string): Filter by call status: 'initiated', 'in-progress', 'completed', or 'failed'

### `get_call_details` (~362 tokens)

Get Call

Get full details of a specific voice call.

Returns the call's metadata including direction, phone numbers,
status, duration, AI agent configuration used, and the full
conversation transcript between the AI agent and the caller.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `call_id` (string, required)

### `get_call_transcript` (~382 tokens)

Get Transcript

Get the full conversation transcript for a call.

Returns the complete speech-to-text transcript of the phone call,
with each turn labeled by role ("human" for the caller, "assistant"
for the AI agent). Useful for reviewing what was said on the call,
extracting information, or auditing AI agent behavior.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `call_id` (string, required)

### `hangup_call` (~378 tokens)

Hangup Call

Hang up an active phone call.

Programmatically terminates an in-progress voice call. Use this
when the AI agent needs to end the conversation, or to force-stop
a call that is no longer needed. The call's final transcript and
billing are processed automatically after hangup.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `call_id` (string, required)

### `push_call_context` (~649 tokens)

Push Call Context

Push context into a LIVE relay-mode call (mid-call context injection).

This is the required way for backend agents (Hermes, OpenClaw, etc.) to
answer a live caller after a ``call.utterance`` event. Do your work, then
POST facts here — do NOT only send the answer to WhatsApp/SMS/chat.

AUTHENTICATION (one of):
  1\. **Push token** (preferred — no API key): the ``push_token`` from the
     ``call.utterance`` payload, via ``X-Push-Token`` header, ``?token=``
     query param, or ``push_token`` body field.
  2\. **Bearer API key**: ``Authorization: Bearer al_live_...`` for the
     account that owns the call.

Body — any of these keys works (``context`` is canonical):
    {"context": "the facts/answer the voice agent should speak"}

Other accepted keys: ``summary``, ``answer``, ``response``, ``message``,
\``reply``, ``text``, ``result``.

Returns:
    delivered=true, status="live"     — voice agent will speak it now
    delivered=true, status="buffered" — caller moved on; held for their
      next question (late pushes are NOT rejected)
    HTTP 410                           — **call has ended.** STOP working
      on this request and abandon any in-flight lookup. No further context
      will be spoken.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },…

Input parameters:

- `call_id` (string, required)
- `token` (string): Push token (alt to X-Push-Token header / body).

### `poll_events` (~464 tokens)

List Events

Poll for telephony events from your AI agents.

Returns pending events such as call completions, transcripts, and
failures. Events are consumed on retrieval (one-time read) — once
polled, they are automatically deleted from the mailbox.

Your AI agent should call this endpoint periodically to receive
notifications about completed calls and their transcripts.

Filters:
  \- agent_id: only events for a specific AI agent
  \- event_type: e.g. "call.completed", "call.failed"

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `agent_id` (string): Filter events by AI agent ID
- `event_type` (string): Filter by event type (e.g. 'call.completed', 'call.failed')
- `limit` (integer): Maximum number of events to return (1-200)

### `peek_events` (~387 tokens)

Peek Events

Peek at pending telephony events without consuming them.

Returns a preview of queued events (call completions, transcripts)
without removing them from the mailbox. Useful for checking if
there are events to process before committing to retrieve them.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `agent_id` (string): Filter events by AI agent ID
- `limit` (integer): Maximum number of events to preview (1-200)

### `get_account_balance` (~100 tokens)

Get Balance

Get your AI telephony account balance and rate card.

Returns the current balance, currency, billing rates for calls
and phone numbers, and how many call minutes or phone numbers
the balance can cover. Use this to check affordability before
making calls or buying numbers for your AI agents.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```

### `get_expenditure_breakdown` (~396 tokens)

Get Expenditure

Get a detailed expenditure breakdown for AI telephony usage.

Shows total spend split by category (voice calls, phone number
provisioning, top-ups, refunds) with counts and averages.
Useful for tracking how much your AI agents are spending on
phone calls and phone numbers.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `period` (string): Time period: 'current_month', 'last_month', 'all_time', or 'YYYY-MM'

### `list_available_voices` (~128 tokens)

Get Available Voices

List all available voice presets for AI phone agents.

Returns named TTS (text-to-speech) voice presets that can be used
when configuring AI agents or making phone calls. Each voice defines
how your AI agent sounds on the phone.

You can use a preset name (e.g. "female-1", "male-1") or pass any
valid Cartesia voice UUID directly as a voice_id.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```

### `get_account_voice` (~89 tokens)

Get Account Voice

Get the current account-level default voice for AI phone agents.

Returns which voice is used for all AI agents under this account
unless overridden at the agent level or per-call. Controls how
your AI agents sound during phone conversations.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```

### `reset_account_voice` (~84 tokens)

Reset Account Voice

Reset account voice to the system default.

Removes the account-level voice override so all AI agents fall back
to the system default voice during phone calls (unless they have
their own voice_id configured).

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```

### `set_account_voice` (~523 tokens)

Update Account Voice

Set the account-level default voice for AI phone agents.

This becomes the default voice for ALL AI agents under this account,
controlling how they sound on phone calls. Individual agents or
specific calls can still override this setting.

Voice resolution priority:
  1\. Per-call voice_id (POST /v1/calls)
  2\. Agent voice_id (PATCH /v1/agents/{id})
  3\. Account default (this endpoint)  ← you are here
  4\. System default (Supportive Male)

Accepts:
  \- A preset name: "female-1", "female-2", "female-3", "male-1", "male-2", "male-3"
  \- A Cartesia voice UUID: "f786b574-daa5-4673-aa0c-cbe3e8534c02"

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `voice_id` (string, required): TTS voice preset name (e.g. 'female-1', 'male-1') or Cartesia voice UUID

### `submit_feedback` (~1108 tokens)

Submit Feedback

Submit feedback, report a bug, or request a feature.

Use this endpoint to tell the AgentLine team about anything you
encounter while using the platform:

  \- **bug** — something is broken or not working as expected
  \- **feature_request** — you wish a capability existed
  \- **difficulty** — something was hard or confusing to use
  \- **feedback** — general comments, suggestions, or praise

Your feedback is reviewed by the team. Include as much detail as
possible — for bugs, describe what you expected vs. what happened
and any steps to reproduce it. You can check back on submitted
feedback via GET /v1/feedback to see its status.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Example Response:**
\```json
{
  "id": "Id",
  "account_id": "Account Id",
  "category": "Category",
  "message": "Message",
  "severity": "Severity",
  "status": "Status",
  "created_at": "2023-01-01T00:00:00Z"
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "id": {
      "type": "string",
      "title": "Id",
      "description": "Unique feedback identifier (e.g. 'fb_abc123')"
    },
    "account_id": {
      "type": "string",
      "title": "Account Id",
      "description": "Account that submitted this feedback"
    },
    "category": {
      "type": "string",
      "title": "Category",
      "description": "Feedback type: 'bug', 'feature_request', 'difficulty', or 'feedback'"
    },
    "message": {
      "type": "string",
      "title": "Message",
      "description": "Full feedback message"
    },
    "subject": {
      "title": "Subject",
      "description": "Short summary title"
    },
    "severity": {
      "type": "string",
      "title": "Severity",
      "description": "Impact level: 'low', 'normal', 'high', or 'critical'"
    },
    "agent_id": {
      "title": "Agent Id",
      "description": "Related AI agent ID, if any"
    },
    "contact_email": {
      "title": "Contact Email",
      "description"…

Input parameters:

- `agent_id` (string): ID of the AI agent this feedback relates to, if applicable
- `category` (string, required): Type of feedback: 'bug' (something broken / not working), 'feature_request' (want a new capability), 'difficulty' (hard or confusing to use), or 'feedback' (general comment or praise)
- `contact_email` (string): Email address for follow-up about this feedback (optional)
- `message` (string, required): Detailed description of the feedback, issue, or request. For bugs, include what you expected vs. what actually happened.
- `severity` (string): Impact level, mainly relevant for bugs: 'low', 'normal', 'high', or 'critical'
- `subject` (string): Short summary title for the feedback (optional)

### `list_feedback` (~450 tokens)

List Feedback

List feedback you have submitted.

Returns your feedback history with optional filters by category
(bug, feature_request, difficulty, feedback) and status (open,
acknowledged, in_progress, resolved, closed). Useful for tracking
progress on bugs or feature requests you reported.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `category` (string): Filter by feedback type: 'bug', 'feature_request', 'difficulty', or 'feedback'
- `limit` (integer): Maximum number of feedback entries to return (1-200)
- `offset` (integer): Number of entries to skip for pagination
- `status` (string): Filter by status: 'open', 'acknowledged', 'in_progress', 'resolved', 'closed'

### `get_webhook` (~377 tokens)

Get Webhooks

List the account's per-agent webhook configuration(s).

Secrets are **masked**. Pass `agent_id` to inspect a single agent's webhook.
The full secret is only ever shown once, on the POST that creates/replaces it.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `agent_id` (string): Inspect one agent's webhook (omit to list all)

### `set_webhook` (~900 tokens)

Set Webhook

Create or replace an agent's webhook.

The configured URL receives ALL of that agent's event types — call lifecycle
(`call.received`, `call.completed`, `call.failed`), SMS (`sms.received`),
and future events — as signed JSON POSTs. Each agent may have at most one
webhook; POSTing again replaces it.

\- `agent_id`: the agent whose events this webhook receives (required).
\- `secret`:   HMAC signing secret. Omit to auto-generate.

The response returns the full `secret` **once** — store it to verify the
signature header on deliveries.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Example Response:**
\```json
{
  "agent_id": "Agent Id",
  "url": "Url",
  "secret": "Secret",
  "signature_header": "Signature Header"
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "agent_id": {
      "type": "string",
      "title": "Agent Id",
      "description": "Agent this webhook is scoped to"
    },
    "url": {
      "type": "string",
      "title": "Url",
      "description": "Configured webhook URL"
    },
    "secret": {
      "type": "string",
      "title": "Secret",
      "description": "Full signing secret. Save it now \u2014 it is masked on subsequent reads."
    },
    "signature_header": {
      "type": "string",
      "title": "Signature Header",
      "description": "Header name used for HMAC-SHA256 signature delivery."
    },
    "created_at": {
      "title": "Created At",
      "description": "When the webhook was last (re)configured"
    }
  },
  "type": "object",
  "required": [
    "agent_id",
    "url",
    "secret",
    "signature_header"
  ],
  "title": "WebhookCreated",
  "description": "Returned on POST \u2014 exposes the full secret this one time."
}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```js…

Input parameters:

- `agent_id` (string, required): ID of the agent whose events this webhook receives. Each agent may have at most one webhook.
- `secret` (string): Optional HMAC signing secret. Auto-generated if omitted. Used to verify the signature header on delivered payloads.
- `signature_header` (string): Header name for the HMAC-SHA256 signature of the raw body. Defaults to 'X-Webhook-Signature' (natively verified by Hermes, OpenClaw, and other agent platforms). Set to 'X-Hub-Signature-256' for GitHu…
- `url` (string, required): HTTPS URL that will receive this agent's events as signed JSON POSTs. Setting this replaces any existing webhook for the agent.

### `delete_webhook` (~357 tokens)

Delete Webhook

Remove an agent's webhook. No events for that agent will be delivered via
HTTP afterwards; they remain available via GET /v1/events (the mailbox).

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `agent_id` (string, required): Agent whose webhook to delete

### `test_webhook` (~381 tokens)

Test Webhook

Fire a signed `webhook.test` event to the agent's webhook.

Uses the exact same event bus (publish_event) that real telephony events use,
so a successful delivery confirms the entire pipeline is wired correctly.
Returns 404 if no webhook is configured for the agent.

\### Responses:

\**200**: Successful Response (Success Response)
Content-Type: application/json

\**Output Schema:**
\```json
{}
\```
\**422**: Validation Error
Content-Type: application/json

\**Example Response:**
\```json
{
  "detail": [
    {
      "loc": [],
      "msg": "Message",
      "type": "Error Type",
      "ctx": {}
    }
  ]
}
\```

\**Output Schema:**
\```json
{
  "properties": {
    "detail": {
      "items": {
        "properties": {
          "loc": {
            "items": {},
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          },
          "input": {
            "title": "Input"
          },
          "ctx": {
            "type": "object",
            "title": "Context"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      },
      "type": "array",
      "title": "Detail"
    }
  },
  "type": "object",
  "title": "HTTPValidationError"
}
\```

Input parameters:

- `agent_id` (string, required): Agent whose webhook to test

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/agentlinehq-agentline/api#diagnostics

## Score history

- 2026-08-03: 33
- 2026-08-02: 33
- 2026-08-01: 60
- 2026-07-31: 60
- 2026-07-30: 59
- 2026-07-29: 58
- 2026-07-28: 58
- 2026-07-27: 56
- 2026-07-26: 56

## Links

- Remote endpoint: https://api.agentline.cloud/mcp
- Repository: https://github.com/AgentLineHQ/agentline-mcp
- Website: https://agentline.cloud/
- Changelog RSS feed: https://verifymcp.io/servers/agentlinehq-agentline/api/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/agentlinehq-agentline/api/changelog.json
- HTML version of this page: https://verifymcp.io/servers/agentlinehq-agentline/api