The Model Context Protocol (MCP) is the standard an AI assistant uses to discover and call tools a server exposes. Connect an MCP client — Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, Cline, Zed — to a server and it can list that server's tools, read their schemas, and invoke them from an ordinary prompt.
Most MCP servers shipped by communications platforms stop at documentation: they index API references so the assistant can answer "how do I send an SMS" without executing anything. Asking one to actually send the SMS still means leaving the chat and writing the call yourself. Devotel Orbit ships a read-write MCP server. Prompting "send the order-shipped WhatsApp template to this contact" or "pause the August reactivation campaign and report the delivery rate" executes against the same account the dashboard shows, on the same data, at the same published rates.
How the CPaaS MCP field shakes out
The three vendors with an official MCP offering divide cleanly on what the assistant is allowed to do (Q3 2026):
- Twilio — officially hosted server is read-only: it searches and
retrieves API docs across the product surface. A separate, alpha/Labs server that can execute calls exists but carries no support commitment.
- Telnyx — read-write server, plus a large published Agent Skills
catalog. Those skills are scaffolding for writing your own integration code against the Telnyx SDKs, not a running agent — they teach an assistant to produce code you then own and keep in sync.
- Devotel Orbit — read-write server whose built-in tools call directly
into the same conversations, campaigns, contacts, and knowledge base your dashboard uses, driven by the same native agent runtime (LangGraph) that powers Orbit's own AI agents. There is no separate integration to keep in sync: the tool surface and the operational surface are the same system.
The practical difference shows up the first time you want the assistant to do something rather than explain something — send the message, dial the test call, enrol the segment — and find out whether the server can complete the action or only describe the endpoint.
What Orbit's MCP server exposes
The tool surface mirrors the platform, because it is built on the same LangGraph runtime as Orbit's deployed agents:
- Conversations and messages. Send SMS, WhatsApp (template or freeform),
and transactional email; check delivery status on anything already sent.
- Campaigns and journeys. List and start campaigns; enrol a contact or a
list into a published flow.
- Contacts and segments. Look up, create, and update contacts; build a
segment from a natural-language description; record events on the customer-360 timeline.
- Voice and video. Place an outbound call; create a video room and issue
guest invites.
- Knowledge base and analytics. Semantically search the tenant knowledge
base; pull aggregated delivery KPIs for a time window.
- AI agents. List deployed agents and escalate an AI conversation to a
human agent.
Because the tools call into the same runtime the dashboard and Orbit's own agents run on, nothing described here is a parallel integration. The campaign you start from a chat window is the campaign you open in the dashboard a minute later, and the contact you update is the same record either way.
The human approval step
Read-write access is only safe if a person stays in the loop. Orbit layers three controls on top of the tool surface:
- Scoped credentials. An agent exchanges its token for a narrower,
shorter-lived credential limited to the tools the task needs; the delegation chain naming the agent and its human sponsor is signed into the credential, so attribution survives the exchange.
- Session guardrails. A per-session budget cap refuses chargeable calls
past a dollar ceiling, and a read-only mode restricts the session to the GET tools.
- URL-mode elicitation. When a tool needs a sensitive one-time value — a
confirmation token, an authorization code — asking for it in the chat window would expose it to the client and its logs. Instead the tool call returns a single-use link to a hosted Orbit page titled "Provide the requested information". The person opens the link, enters the value, and it goes straight to Orbit — never to the assistant's host app. The link expires after 15 minutes; a client that predates elicitation simply keeps its existing confirmation prompts.
That last mechanism is what makes a human approval step concrete: the assistant's host app never sees the plaintext, and the prompt that carries the value cannot be replayed.
Setup in three steps
- Generate an API key in Dashboard → Settings → API Keys (sandbox keys
prefixed dv_test_sk_ exercise every tool without sending anything or charging anything).
- Add the Orbit server to your client — one JSON block naming the npx
command and your key as ORBIT_API_KEY.
- Verify with a read prompt — "List my Orbit campaigns" — then try a write.
The connection guide in the docs is the canonical how-to, with copy-paste configs for Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, Cline, Zed, and Continue, plus sandbox mode, and the guardrail environment variables.
Further reading
The comparative listicle ranks Orbit's server against Twilio, Telnyx, and Vonage on read-write tool coverage and native agent-runtime depth: Best MCP Server for Communications & CPaaS 2026. The credential-scoping mechanism came out of the work described in Scoped agent credentials, pinned regression replay, and the Agent ROI guide, and the agent-runtime framing in What is LLM orchestration?.
Frequently asked questions
What makes Orbit's MCP server different from Twilio's?
Twilio's officially hosted MCP server is read-only — it searches API docs and retrieves parameter schemas but cannot execute a call, and the separate alpha/Labs server that can execute carries no support commitment. Orbit's server executes: its tools act on the same conversations, campaigns, contacts, and knowledge base the dashboard shows, driven by the same LangGraph runtime that powers Orbit's own AI agents.
What can I actually do from an AI assistant connected to Orbit?
Send SMS, WhatsApp, and email; place outbound calls; create video rooms; list and start campaigns; enrol contacts into published journeys; look up, create, and update contacts; build segments from natural language; search the knowledge base; pull delivery analytics. Read-only tools answer immediately; tools that send, spend, or delete sit behind confirmation prompts, scoped credentials, and per-session budget caps.
How does the approval step work when a tool needs a sensitive value?
The tool returns a single-use link to a hosted Orbit page instead of asking in the chat. You open the link and enter the value there — it goes straight to Orbit and never transits the assistant's host app or its logs. The link expires after 15 minutes, and clients that predate the elicitation capability keep their normal confirmation prompts.
What does it cost to use?
The server has no separate licence fee — connect with your existing Orbit API key. Tool calls that consume billable resources debit your normal pay-as-you-go balance at the same published rates as the API and dashboard, and a sandbox key (dv_test_sk_) exercises every tool without sending messages, placing calls, or charging anything.