After a team integrates MCP, a common problem tends to show up: to expose a dozen or so internal REST endpoints to an Agent, you write an MCP service layer, wrap each of those endpoints as a tool one by one, and then you also have to add auth, deployment, and canary rollout for that wrapper layer. The wrapper itself produces no business value, but it becomes a new single point of failure. That is exactly what UTCP wants to solve—can we avoid making the Agent go through me, and instead have it call my endpoints directly?
1. First, Let's Get the Two Things Straight
MCP (Model Context Protocol) takes the middleman approach: the Agent connects to an MCP Server, and the Server exposes the tool list, receives calls, and forwards them to the real backend endpoints. The transport layer is JSON-RPC over stdio or HTTP.
UTCP (Universal Tool Calling Protocol) takes the instruction-manual approach: it does not forward calls; it only describes "how to call this tool"—the URL, method, how to fill in parameters, and where to put auth. The Agent reads this manual (officially called a manual) and calls that endpoint itself.
The official UTCP documentation states this philosophy quite directly: if a human can call your API, an AI Agent should be able to call it too, using the same security measures, without extra infrastructure.
This sentence is the key to understanding the entire UTCP design. All the "advantages" you see later are essentially corollaries of this sentence; all the "costs" can also be derived from it.
2. The Same Thing, Two Architectures
For the same "check weather" capability, the two sides look like this.
MCP's form: you need a service process that exposes a tool called get_weather externally, and when it receives a call internally, it requests the real endpoint.
{
"name": "get_weather",
"description": "Get current weather",
"inputSchema": {
"type": "object",
"properties": { "location": { "type": "string" } },
"required": ["location"]
}
}
Note that this is only a declaration. The part that actually does the work is in your Server code; if the endpoint changes, you have to change the code and redeploy.
UTCP's form: the manual directly specifies how to make the call.
{
"manual_version": "1.0.0",
"utcp_version": "1.0.1",
"tools": [
{
"name": "get_weather",
"description": "Get current weather",
"tool_call_template": {
"call_template_type": "http",
"url": "https://api.weather.com/current",
"http_method": "GET",
"query_params": { "location": "{location}" }
}
}
]
}
The difference is whether there is an intermediary layer:
MCP: Agent → MCP Server → 你的接口
UTCP: Agent → 你的接口
3. The Four Things Java Backends Care About Most
Let's not talk about abstract "philosophy"; let's talk about concrete impact.
1. Deployment Surface
MCP adds another layer of things to operate: processes, ports, health checks, canary rollout, and autoscaling. If this wrapper layer goes down, the Agent is cut off, even if your business endpoints themselves are perfectly fine.
UTCP has no such layer. Your Spring Boot application runs as usual, except that it adds a /utcp GET endpoint that returns the manual. One fewer deployment unit means one fewer class of failure.
For teams that already have a complete K8s setup and a unified gateway, the operational cost of an MCP Server is not high; but for small teams or internal tools, this layer is indeed a pure burden.
2. Authentication
This is, in my view, UTCP's most practical benefit.
A common MCP approach is to implement authentication again inside the MCP Server—verify once when the Agent connects to the Server, and then carry internal credentials when the Server calls the backend. The result is:
- The backend's original permission system is "downgraded" at the Server into a coarse-grained configuration.
- The backend can only see the Server's identity, not the end user, for who actually called what.
- The audit trail is broken at one point.
In UTCP, the Agent carries your original credentials and goes through your original authentication. Permissions, auditing, rate limiting, and logging all stay where they were.
The official documentation lists this as one of the advantages of direct communication: native security controls remain intact, and existing monitoring and logging continue to work.
3. Latency
MCP adds one more network hop: Agent → Server → backend → Server → Agent. Within the same data center, this hop is about a few milliseconds; across availability zones, it may reach more than ten milliseconds.
A single call is not a big deal. But in Agent scenarios, one task often triggers a dozen or more tool calls, and the cumulative effect is noticeable. UTCP is just the response time of the endpoint itself.
4. Amount of Rework
MCP: you need to write a handler for each capability, write tool descriptions, and handle parameter mapping, error conversion, timeouts, and retries.
UTCP: if you already have OpenAPI documentation, the official project provides a converter that can automatically turn an existing OpenAPI spec into a UTCP manual, with zero changes to business code.
For backend teams that "already have a bunch of REST endpoints and want to expose them to Agents," this is the most direct reduction in effort.
4. Don't Pretend UTCP's Costs Aren't There
After praising the advantages, let's talk about the problems. UTCP is not free.
First, moving authentication to the client side means moving the risk there too.
In MCP mode, credentials are on the Server side, and the Agent cannot access them. In UTCP mode, the Agent must hold your credentials. The official documentation specifically warns in its security section: the manual endpoint itself becomes a discovery target, variable substitution introduces injection risks, and the client must handle multiple authentication methods itself.
Put simply: when you remove the "middleman," you also remove the safety net that middleman provided.
2. Capability boundaries rely on convention, not protocol enforcement.
In MCP, the Server determines which tools are exposed, and the Agent can only see what the Server provides. In UTCP, once the Agent gets the manual, what it can call depends on the permissions of your API itself—if your API design includes an endpoint that "looks up any order by ID," then the Agent can look up any order.
This means your API design has to hold up when an Agent calls it directly. REST APIs used to be written for the frontend, and the frontend imposed page-level constraints; now the caller is an unconstrained model.
3. The ecosystem is still early.
MCP already has an official SDK and broad support from mainstream IDEs and Agent frameworks; more people have hit its pitfalls, so there are more answers. UTCP's spec is still iterating in the 1.x range (the docs I saw were 1.1), and implementations and case studies are still accumulating.
Choosing a protocol isn't just choosing technology—it's also choosing an ecosystem.
4. Not every scenario is suited to direct connections.
If your backend API is designed in a very "frontend-oriented" way (one request returns a pile of data a page needs), or if you need multi-step orchestration and result aggregation, then the middle layer can actually be valuable—it can wrap three rough APIs into one tool with clear semantics. In that case, MCP's "extra layer" is an advantage.
5. How Java teams can get started
The core of UTCP is the manual, and getting it working on the Java side takes roughly three steps.
Step 1: Expose the manual endpoint. Just add a Controller to your existing Spring Boot app that returns the JSON manual.
package com.example.utcp;
import java.util.List;
import java.util.Map;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UtcpManualController {
@GetMapping("/utcp")
public Map<String, Object> manual() {
Map<String, Object> weatherTool = Map.of(
"name", "get_order",
"description", "按订单号查询订单详情",
"inputs", Map.of(
"type", "object",
"properties", Map.of(
"orderNo", Map.of("type", "string", "description", "订单号")),
"required", List.of("orderNo")),
"tool_call_template", Map.of(
"call_template_type", "http",
"url", "https://api.example.com/orders/{orderNo}",
"http_method", "GET"));
return Map.of(
"manual_version", "1.0.0",
"utcp_version", "1.0.1",
"tools", List.of(weatherTool),
"auth", Map.of(
"auth_type", "api_key",
"api_key", "${ORDER_API_KEY}",
"var_name", "X-API-Key",
"location", "header"));
}
}
Step 2: Put this endpoint behind the same authentication as your business APIs. Don't skip this step—the first item in the official security section is "implement authentication for the manual discovery endpoint," and you must only return the tools the caller has permission to see.
Step 3: Use a converter to turn your existing OpenAPI into a manual. If your API docs are already complete, this step can save a lot of manual work. The converted result needs a human review, focusing on two things: whether description is clear enough (the model relies on it to choose tools), and whether it exposes any endpoints that shouldn't be available to the Agent.
6. Recommendations for choosing
I'll give a judgment criterion that isn't exactly "neutral."
| Your situation | Recommendation |
|---|---|
| Your API is already standard REST, has OpenAPI docs, and you just want agents to be able to call it | Try UTCP first — smallest amount of change required |
| You need multi-step orchestration, result aggregation, or want to hide backend API details | Use MCP — this is exactly where the middle layer earns its keep |
| Internal tools, small team, no dedicated person to maintain a middle layer | Try UTCP first |
| You need tight control: precise control over which capabilities agents can see | Use MCP — the Server is a natural chokepoint |
| You already have a mature MCP ecosystem and ready-made Servers | Don't touch it — migration costs more than it gains |
In one sentence: What UTCP eliminates is infrastructure; the price is moving the trust boundary to the client. If your APIs are cleanly designed and have fine-grained auth, UTCP pays off. If your APIs still carry a pile of historical baggage along the lines of "the frontend will constrain it anyway," then the middle layer is actually protection.
7. An easily overlooked point
UTCP and MCP are not mutually exclusive. UTCP's list of supported protocols already includes MCP — meaning you can use a UTCP manifest to describe an MCP Server and let agents find MCP tools through UTCP's discovery mechanism.
This means the real-world choice is often: use UTCP to connect directly to new, clean APIs, and wrap legacy baggage-heavy ones with MCP — let the two coexist. There's no need to force a migration just for uniformity.
Top comments (0)