UTCP vs MCP: How They Differ and When to Use Each
·
UTCP (Universal Tool Calling Protocol) and MCP (Model Context Protocol) both tell an AI agent which tools it can call, and they differ in who makes the call: with MCP the agent sends every call to an MCP server, and with UTCP the agent reads a manual once and calls each tool's own endpoint itself. Use MCP when the agent runs in an MCP client such as Claude, ChatGPT or Cursor, or needs more than tool calls; use UTCP when your agent framework already speaks UTCP, or when you want tool definitions your own code calls with ordinary HTTP. Unified.to publishes the same tools over both protocols, so this post uses it as the worked example.
Key takeaways
- MCP sends every tool call to an MCP server as a JSON-RPC 2.0 message. The current revision, 2026-07-28, is stateless.
- UTCP publishes a JSON manual. Each tool in it carries a call template, such as an HTTP request or a CLI command, that the client runs itself.
- UTCP describes tools only. MCP also defines resources and prompts, and servers can add extensions such as Unified's MCP Events.
- As of November 2026, Unified.to's UTCP docs note that "none of the major LLM providers support it natively yet"; you use UTCP through client libraries and adapters.
- When a tool sits behind a hosted API, UTCP doesn't take that API out of the path: on Unified.to, an MCP call and a UTCP call both go through Unified.to to reach the integration.
What is UTCP?
UTCP, the Universal Tool Calling Protocol, is an open standard in which whoever publishes a tool also publishes a manual: a JSON document listing each tool's name, description, input and output schemas, and a call template that tells the client how to make the call. The client fetches the manual once, then calls each tool over that tool's own protocol, with no UTCP server between the agent and the tool.
- Origin. The project announced itself on 15 July 2025 in a post titled "Introducing UTCP - The Direct Alternative to MCP" (UTCP blog). The Python client's first release, 0.1.0, is dated 10 July 2025 (PyPI).
- Version. The documentation at utcp.io is labelled version 1.1 (last updated 30 November 2025). The Python client reached 1.2.0 on 16 September 2026 (PyPI, read 10 November 2026).
- Protocols. Call templates are handled by plugins: HTTP and Server-Sent Events (
utcp-http), CLI (utcp-cli), text files (utcp-text) and MCP (utcp-mcp), per the protocols page (last updated 30 November 2025). - Protocol limits. Version 1.1 added
allowed_communication_protocols: unless a manual sets it, the manual can register only tools that use its own protocol, so an HTTP manual can't quietly add a CLI tool (v1.0 to v1.1 migration guide). - Code. The official Python, TypeScript and Go implementations are MPL-2.0 licensed and live in the universal-tool-calling-protocol GitHub organization (read 10 November 2026).
What is MCP?
MCP, the Model Context Protocol, is an open protocol in which an MCP server lists tools and answers tool calls from an MCP client, with every message following JSON-RPC 2.0. Servers can offer tools, resources and prompts, over two standard transports: stdio for a local subprocess and Streamable HTTP for a remote server.
The current revision, 2026-07-28, removed protocol-level sessions and the initialize handshake. Every request now carries its protocol version and client capabilities in _meta, and servers must implement server/discover to advertise the versions and capabilities they support. For what changed and how Unified.to moved to it, see MCP v2 is here.
How do UTCP and MCP compare?
UTCP and MCP differ most on who makes the call, what travels on the wire, and how much of the agent's surroundings each protocol covers.
| Dimension | MCP | UTCP |
|---|---|---|
| Who makes the tool call | The MCP server, after the client sends tools/call | The client, from the tool's call template |
| How tools are discovered | tools/list on the server | One fetch of the manual |
| What travels on the wire | JSON-RPC 2.0 messages | The tool's own protocol: an HTTP request, a CLI command, an SSE stream, a file read or an MCP call |
| Transports | stdio and Streamable HTTP | One per call template, through protocol plugins |
| State | Stateless from 2026-07-28; earlier revisions use sessions | No sessions |
| What it describes | Tools, resources and prompts, plus extensions | Tools only |
| Authorization | An optional OAuth 2.1-based framework for HTTP; stdio servers take credentials from the environment | Each call template names its own auth, such as an API key or OAuth 2; the tool's owner enforces it |
| Clients that support it natively (November 2026) | MCP clients including Claude, ChatGPT, Cursor and VS Code | None of the major LLM vendors, per Unified.to's docs; client libraries and adapters instead |
| What the tool's owner runs | An MCP server | The existing API, plus an endpoint that serves the manual |
Does UTCP remove a hop?
UTCP removes a hop only when the call template points at the tool's own API. UTCP's comparison page describes MCP as "Agent → MCP Server → Tool" and UTCP as "Agent → Tool (Direct)", and the utcp.io home page lists latency as "Double hop" for MCP against "Direct calls" for UTCP. Neither page says how its performance figures were measured (read 10 November 2026).
When the tool is a SaaS integration reached through a hosted API, that API stays in the path. Unified.to's UTCP call templates point at Unified's own API (POST https://api.unified.to/tools/{id}/call), which then calls the integration; a Unified MCP call goes to https://mcp-api.unified.to/mcp, which also calls the integration. Either way, Unified.to sits between the agent and the integration, because that is where the connection's credentials, permissions and data model live. What UTCP changes is the envelope: a plain HTTP request instead of a JSON-RPC message, no session, and no MCP client library on your side.
How does authentication differ?
MCP defines an optional OAuth 2.1-based authorization framework for HTTP transports, while UTCP leaves authentication to each tool: the call template names the scheme and a variable, and the client fills in the secret when it makes the call.
- UTCP. Secrets are referenced as variables such as
${API_KEY}and kept out of the manual. UTCP's security guidance (last updated 16 September 2026) says the endpoint that serves the manual should require authentication and list only the tools the caller may see, and that reference clients require HTTPS for remote destinations and don't forward credentials to a different origin on a redirect. - MCP. The 2026-07-28 revision deprecated OAuth Dynamic Client Registration (RFC 7591) in favour of Client ID Metadata Documents, keeping registration available for authorization servers that don't support them (changelog).
- On Unified.to**.** Unified MCP accepts a workspace API key, a connection-scoped token, an enterprise-managed token, or OAuth sign-in from an MCP client (Core tools only). The UTCP manual accepts a workspace API key or a connection-scoped token, the same credentials the MCP server takes, and every call template uses
Authorization: Bearer ${UNIFIED_API_KEY}, so the manual never contains your credential (UTCP docs). UTCP clients prefix variables with the manual's name: register the manual asunifiedand the client looks upunified_UNIFIED_API_KEY.
What does each protocol return?
An MCP tool result is a list of content blocks, usually text, plus structuredContent on revisions from 2025-06-18, while a UTCP HTTP call returns whatever the tool's API returns, described by the tool's outputs schema.
On Unified.to, the two line up closely:
- Over MCP, a list tool returns
{"results": [...]}both asstructuredContentand, since 10 November 2026, as its text content, matching the tool'soutputSchema. A failed call hasisError: trueand JSON text such as{"error": true, "status": 404, "message": "..."}(MCP changelog). - Over UTCP (
format=utcp), a call returns the result itself, with a list wrapped as{"results": [...]}and nocontentorstructuredContentenvelope. A failed call returns an error status, such as 400, 401, 403, 404, 429 or the integration API's own status, with anisErrorbody, which UTCP clients raise as an error.
What does MCP cover that UTCP doesn't?
MCP describes more than tool calls: servers can offer resources and prompts, and clients and servers negotiate optional extensions in their capabilities. UTCP describes tools and how to call them, and nothing else.
On Unified.to, two features depend on that difference and work only over MCP:
- MCP Events. On a single connection's server, an agent can call
events/list,events/pollorevents/subscribeto learn when records change, instead of listing them again. MCP Events is a draft extension of the MCP specification. - Agent Skills. In Core mode, the MCP server serves Unified.to's Agent Skills alongside the workspace tools.
Unified's UTCP docs put it plainly: over UTCP there are no events, skills or OAuth discovery, only tools.
UTCP's advantage runs the other way. One manual can mix tools that use different protocols, such as an HTTP API and a CLI, provided it sets allowed_communication_protocols. And a team with a working HTTP API can publish a manual without building and operating an MCP server.
Who supports UTCP today?
UTCP is used through client libraries and adapters rather than built into model vendors' clients. As of November 2026, Unified.to's UTCP docs list:
- Client libraries: Python (
utcpwithutcp-http), TypeScript (@utcp/sdkwith@utcp/http), Go (go-utcp) and Rust (rs-utcp, pre-1.0), plus community libraries for Ruby, Elixir and Lua. - Agent frameworks: LangChain and LangGraph (
langchain-utcp-adapters, early release), Pydantic AI (pydantic-ai-utcp, early release) and Strands Agents (strands-utcp, a community contribution). - Bridges: the UTCP-MCP bridge (
@utcp/mcp-bridge), which serves UTCP manuals to an MCP client such as Claude Desktop or Claude Code, and Code Mode (@utcp/code-mode).
MCP, by comparison, connects to clients that ship with support for it, including Claude, ChatGPT, Cursor and VS Code (Unified MCP installation).
Can you use UTCP and MCP together?
UTCP and MCP connect in both directions. A UTCP client can call tools on an existing MCP server through UTCP's MCP plugin and MCP call templates, and the UTCP-MCP bridge serves UTCP manuals to MCP clients. Code Mode is a library "to enable agents to call MCP and UTCP tools via code execution".
Code execution is also where Unified.to's two outputs meet. Claude's programmatic tool calling has the model write code that calls tools and keeps intermediate results out of its context, and Unified's code execution guide shows how to forward those calls to the MCP server. Because a successful Unified list result is the same {"results": [...]} object over both protocols, code that reads results works with either; error handling differs, since a failed UTCP call arrives as an HTTP error status.
If you already manage tools through UTCP, the bridge brings them into an MCP client. If you don't, Unified's docs recommend connecting the MCP client to Unified MCP directly, which also gives it MCP Events and Agent Skills.
How do you call the same Unified tool over MCP and UTCP?
On Unified.to, the same tool, here list_crm_contacts on a CRM connection, can be called over either protocol with the same credential, the same permissions and tools options, and the same cost: each tool call counts as one API request on your plan.
Over MCP, point an MCP client at https://mcp-api.unified.to/mcp (EU: mcp-api-eu.unified.to, AU: mcp-api-au.unified.to) with a connection-scoped token. The client's SDK builds the tool call. In outline, on the 2026-07-28 revision:
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
"name": "list_crm_contacts",
"arguments": { "limit": 10 },
"_meta": {
"io.modelcontextprotocol/protocolVersion": "2026-07-28",
"io.modelcontextprotocol/clientCapabilities": {}
}
}
}
Over UTCP, register Unified's manual with a UTCP client. This is the Python example from Unified's UTCP docs:
import asyncio
import os
from utcp.utcp_client import UtcpClient
async def main():
key = os.environ['UNIFIED_API_KEY'] # a workspace API key or a connection-scoped token
client = await UtcpClient.create(config={
# The manual is named "unified", so the variable is unified_UNIFIED_API_KEY
'variables': {'unified_UNIFIED_API_KEY': key},
'manual_call_templates': [{
'name': 'unified',
'call_template_type': 'http',
'http_method': 'GET',
'url': 'https://api.unified.to/utcp?connection=<CONNECTION_ID>&permissions=crm_contact_read',
'auth': {
'auth_type': 'api_key',
'api_key': 'Bearer ${UNIFIED_API_KEY}',
'var_name': 'Authorization',
'location': 'header',
},
}],
})
# Tool names are prefixed with the manual name. Arguments go under "arguments".
result = await client.call_tool('unified.list_crm_contacts', {'arguments': {'limit': 10}})
print(result)
asyncio.run(main())
The client then sends an ordinary HTTP request built from the tool's call template. The URL parameters from the manual URL are copied into every call URL:
POST https://api.unified.to/tools/list_crm_contacts/call?connection=<CONNECTION_ID>&permissions=crm_contact_read&format=utcp
Authorization: Bearer <UNIFIED_API_KEY>
Content-Type: application/json
{ "arguments": { "limit": 10 } }
A few details matter when you switch between them:
- Arguments are nested under
argumentson UTCP. UTCP sends one input as the request body and the rest as query parameters, so the tool's parameters travel as one object. - What the manual lists depends on the credential. A connection-scoped token, or a workspace API key with
connection, lists that connection's integration tools. A workspace API key alone lists the Core tools for managing connections, integrations and webhooks. With no credential, the manual is a preview, and calls still need a credential. - Each region has its own manual:
api.unified.to/utcp(US),api-eu.unified.to/utcp(EU) andapi-au.unified.to/utcp(AU). A credential works only on its own region's host, except API keys synced with Multi-Region Sync on Scale. - Narrow the tool list on either protocol. Unified's docs note that most LLMs handle a few dozen tools at most;
permissionsandtools(with*and?wildcards) narrow the list on either protocol, andhide_sensitivestrips personal data from results.
When should you use UTCP, and when MCP?
Choose by where the agent runs and what it needs beyond tool calls.
| Situation | Use |
|---|---|
| The agent runs in an MCP client such as Claude, ChatGPT, Cursor or VS Code | MCP |
| The agent needs change events or Agent Skills from Unified.to | MCP |
| Your agent framework already speaks UTCP, for example through the Python, TypeScript or Go libraries or the LangChain, Pydantic AI or Strands adapters | UTCP |
| Your own code calls tools with plain HTTP and you don't want an MCP client library or a session | UTCP |
| You manage tools through UTCP and want them inside an MCP client | UTCP, through the UTCP-MCP bridge |
| Product code reading and writing customer data in production | The Unified API |
| For the other half of this choice, whether an agent should call tools at all or run commands in a shell, see CLI vs MCP: Architecture Trade-offs for AI Agents. For where MCP is the wrong tool, see When to Use (and Not Use) Model Context Protocol, and for how Unified MCP compares with other hosted servers, see Best MCP Servers for Connecting AI Agents to SaaS APIs. |
→ Start your 30-day free trial
Written by Mallory Greene.
About the author: Mallory Greene is Head of Marketing at Unified.to_. She writes about integration infrastructure, unified APIs, and MCP for technical teams. Based in Toronto._