When discussing whether to open internal APIs to agents, one question is hard to avoid: MCP already exists, so why is anyone building UTCP? The more practical version is—for this pile of REST APIs I have on hand, should I wrap them into an MCP Server, or is writing a UTCP manual enough?
Let's lay out the facts on both sides first, then talk about how to choose. The MCP details below come from the official docs (doc version 2026-07-28 at the time of writing; spec page dated 2025-06-18), and the UTCP details come from its official docs, version 1.1.
1. They're Not at the Same Level of Abstraction
This is the easiest point to confuse, and also the most important.
MCP is a protocol. It explicitly defines two layers: the data layer uses JSON-RPC 2.0 to define message structure and semantics (capability negotiation, version discovery, tools/resources/prompts/notifications), and the transport layer defines connection establishment, message framing, and authorization. There are three roles: MCP Host (the AI application itself), MCP Client, and MCP Server.
UTCP is a description. It has no roles, no sessions, no handshake. What it defines is "how to write a manual"—what the tool is called, what its parameters are, which URL the real endpoint lives at, and where auth goes.
Put more plainly:
MCP gives tools a standard socket; UTCP gives tools a standard manual.
A plug needs power and has to match the spec; a manual just needs to be understandable. That difference gives rise to all the differences below.
2. Side-by-Side Comparison
| Dimension | MCP | UTCP |
|---|---|---|
| Official positioning | Open standard for connecting AI applications with external systems | Standard for describing "how to call tools directly" |
| Roles | Three parties: Host / Client / Server | Two parties: the agent and the target tool; no intermediary role |
| Communication | JSON-RPC 2.0; STDIO locally, Streamable HTTP remotely | Reuses the target protocol directly: HTTP, WebSocket, SSE, CLI, gRPC (MCP is also supported) |
| Output artifacts | Server exposes Tools / Resources / Prompts | The tool_call_template in the manual |
| Client-side capabilities | Roots / Sampling / Elicitation | None; the client only reads the manual and makes the call |
| State | Sessions, capability negotiation, and list-changed notifications | Stateless; each call follows the manual |
| Discovery | Handshake → list tools → call | Fetch the manual (or convert from OpenAPI) |
| Where auth lives | Authorization at the transport layer; credentials on the Server/SDK side | The client holds the credentials and uses the target endpoint's existing auth |
| Deployment unit | One process or service per Server | No new deployment unit |
| Extensibility | Official extension mechanism (e.g., the Tasks extension) | Extends horizontally through its list of supported protocols |
| Version maturity | Spec keeps evolving; SDKs are split into Tier 1–3 | Spec 1.1; implementations and examples are still accumulating |
3. The Four Most Substantive Differences
Now that you've seen the table, here are four differences that will actually affect your choice.
1. Transport layer: wrap it in a layer, or use the native protocol directly
MCP's remote form is Streamable HTTP, where one Server serves multiple Clients; its local form uses STDIO, usually one Server to a single Client. Either way, calls must go through the Server layer.
UTCP has no intermediary at all; an Agent call is just a regular HTTP request hitting your existing endpoint.
The latency difference is on the order of a few milliseconds in the same data center, which isn't much; but an Agent often calls tools a dozen or more times in a row for a single task, and it adds up. More important is the failure surface: if the MCP Server goes down, the Agent is disconnected, even if your business endpoint is alive and well.
2. Capability model: three primitives vs. one action
This one is easy to overlook, but it determines the ceiling of expressiveness.
An MCP Server provides three things, each with different control:
- Tools — the model decides when to call them
- Resources — app-controlled, feeding context to the model (files, database records, etc.)
- Prompts — user-controlled, preset prompt templates
On the client side, there are also Roots (working directory boundaries), Sampling (letting the Server make reverse requests to the model for completions), and Elicitation (asking the user for more information).
UTCP does only one thing: describe how to call a tool. It has no concept of resources, no concept of prompt templates, and no ability to make reverse requests to the model.
So if your need is simply "let the Agent call my endpoint," UTCP is enough; if you also need to provide context to the model, give users preset workflow templates, or do human-in-the-loop follow-up questions, MCP has broader expressiveness.
3. Auth: are credentials in the middleman's hands or the caller's hands
This is the difference I consider most practical.
MCP places authorization at the transport layer, with credentials held by the Server/SDK. The Agent itself doesn't need to know your API key. The benefit is straightforward: the caller is constrained—the Server decides what it can see and do.
UTCP gives credentials to the client. The Agent must hold your key/token to call your endpoint directly. The benefit is a complete audit trail—the backend still sees the real caller, and permissions, rate limiting, and logs all reuse the existing system without being reimplemented in a middle layer.
The cost is equally direct: you lose a safety net.
4. State and real-time behavior
MCP is session-based and supports mechanisms such as capability negotiation and "tool list changed notifications"—when the toolset changes, it can proactively push updates to the client.
UTCP is pull-based: the Agent reads a manual once, then calls according to the description inside. There is no push, and no channel for "the server proactively tells you it has changed."
If you're building a long-running Agent whose toolset changes dynamically, this becomes a hard constraint.
IV. Attack surface: what each is afraid of
MCP-specific risks are concentrated in that shell:
- The Server is a new entry point; if it is breached, the backend is compromised along with it
- Tool descriptions from third-party Servers can be poisoned (the descriptions are provided by the Server, and the model trusts them)
- Supply chain: installing a Server of unknown origin is equivalent to handing over internal network privileges
UTCP-specific risks are listed in its own official security documentation:
- The manual endpoint becomes a discovery target; you must add authentication to it and only return tools the caller has permission to see
- Variable substitution introduces injection risks
- The client holds credentials, so the credential exposure surface grows
- The client must handle multiple authentication methods itself
In one sentence: MCP consolidates risk into one component, while UTCP spreads risk to every caller.
The former is easier to manage but a single point of failure can be fatal; the latter is not fatal but hard to govern uniformly.
V. How should Java teams choose?
| Your situation | Recommendation |
|---|---|
| The API is already standard REST, has OpenAPI docs, and you just want agents to be able to call it | UTCP — smallest amount of change |
| You need to provide context resources and prompt templates to the model | MCP — UTCP has no such concepts |
| You need dynamically changing tool sets, long sessions, real-time notifications | MCP |
| Internal tools, small team, no one dedicated to maintaining a middle layer | UTCP |
| You must precisely control which capabilities an agent can see | MCP — the server is a natural control point |
| You need OAuth authorization for third-party integrations | MCP — transport-layer auth comes ready-made |
One more real-world difference from a pure Java perspective: MCP has an official Java SDK (Tier 2 in the official SDK list; Tier 1 is Python, TypeScript, C#, Go, Rust, Ruby), so there's ready-made scaffolding for writing the server side; on the Java side, UTCP is currently basically "write a Controller that returns JSON yourself" — simple, but it also means no framework-level help.
6. It's Not Either/Or
One detail worth knowing: MCP is itself on the list of protocols UTCP supports. In other words, you can use a UTCP manual to describe an MCP server and let agents find it through UTCP's discovery mechanism.
So in practice, deployments tend to be hybrids:
- Newly written, cleanly designed APIs → direct UTCP
- Legacy APIs with a lot of baggage, or ones that need aggregation and orchestration → wrap them in an MCP server
- Both side by side, split along capability boundaries
There's no need to force a migration just for the sake of "unification." The cost and risk of migrating often outweigh the maintenance cost of running both.
7. My Take
MCP's strength is its ecosystem and expressiveness: the three primitives can do more than "call a tool," official SDKs are available across the board, mainstream agent frameworks and IDEs support it, and someone has already written up an answer for the pitfalls you run into.
UTCP's strength is one less layer of infrastructure: no new deployment unit, no rewriting auth, OpenAPI converts automatically. For small teams and internal tools, that's a very real temptation.
But you should be clear about what you're trading for it:
Skipping the middleware comes at the cost of moving the trust boundary forward. If an agent holds your credentials and calls the API directly, then your API design has to hold up against an unconstrained caller.
If your APIs still carry baggage like "it's an internal call anyway, just add an ID and you can query it," the middle layer is actually protection.
Top comments (0)