[KongchangAI]
· 3 min read· 1,784 words

MCP vs Skill vs Local Tools: A Layered Architecture That Clarifies Their Boundaries

MCP vs Skill vs Local Tools: A Layered Architecture That Clarifies Their Boundaries

MCP turns multi-model-to-multi-tool adaptation from multiplication into addition, but three costs must be accounted for.

The article clarifies that MCP, Skill, and local functions are not a choose-one relationship but a combination across different architectural layers: Skill describes business processes, MCP connects to general-purpose tools reused across parties, and local functions handle lightweight in-app logic. MCP unifies message formats via JSON-RPC 2.0, with STDIO and Streamable HTTP being merely different transport links. Servers expose tools, resources, and prompts, where Input/Output Schema ensures consistency of inputs and returns, and permission rules converge on the server. Its core value is compressing N models × M tools work into N+M. But MCP is not free: extra latency, operational overhead, and harder troubleshooting. It is only worth adopting when tools need cross-model, cross-team reuse or independent permission boundaries; for a single app with a few tools, local functions are simpler.

Many teams integrating LLM tools face a question that looks like "tool selection" but is really about "layering": should we use MCP, Skill, or local functions? A video from Bilibili cuts through this ambiguity with a real production scenario—three models from different vendors, 17 private Skills, and 23 local script tools, all of which need to uniformly invoke three core capabilities across every model. If you adapt each one individually, the work multiplies. MCP turns it into addition.

What Problem Does MCP Actually Solve

MCP stands for Model Context Protocol. The problem it solves is simple: when an LLM application wants to call an external tool, how should that middle layer connect, send requests, and receive responses? Previously each vendor wrote its own protocol; now everyone writes to the same format.

MCP has two core roles: the client (usually your Agent application) and the server (the program that actually executes capabilities). The two communicate via JSON-RPC 2.0, exchanging structured requests and responses.

There are two transport modes: local processes use standard input/output, called STDIO mode; remote services use HTTP, called Streamable HTTP mode. So local and remote aren't two separate systems in MCP—just a different transport link with exactly the same message format.

STDIO and Streamable HTTP transport modes

A server exposes three types of capabilities: tools, resources, and prompts. Tools are executable actions, resources are readable context data, and prompts are reusable instruction templates. The tool layer is the most critical: the client sends a list command, and the server returns a tool manifest, where each tool has a name, a functional description, and a JSON Schema for its input parameters (Input Schema). The model looks at this manifest and the parameter descriptions to autonomously decide which tool to call and what parameters to pass. When actually calling, it sends a call command with the tool name and parameters; the result can be text, images, or structured JSON, corresponding to the output schema and structured content specification.

JSON-RPC 2.0 is a lightweight remote procedure call protocol that encapsulates requests and responses in JSON format. It divides calls into requests (with id, method, params) and notifications (without id, no response required), while responses contain either a result or an error field. MCP chose it as the communication foundation because it is simple enough, has broad cross-language support, and naturally supports bidirectional communication—the server can also proactively send notifications to the client (for example, when the tool manifest changes). Compared to REST, JSON-RPC is not bound to HTTP semantics, so the STDIO and Streamable HTTP transports can reuse exactly the same message body, which is precisely the prerequisite for MCP to achieve "changing the link without changing the format."

Input Schema is essentially a JSON Schema used to describe the types, required fields, value ranges, and nested structures of tool inputs. Its value lies in turning "what the parameters should look like" into a machine-readable contract: the model side generates compliant call parameters based on it, and the server side validates against the same schema, so the two sides don't talk past each other. Output Schema constrains the structure of returned results, and together with the structured content specification, it ensures the client receives predictable JSON fields rather than free text that needs further parsing. Without this layer of schema, models tend to fabricate parameter names or omit required fields, and errors only surface when the server executes; with schema, many problems can be intercepted before the call is even made.

The Real Role of Skill and Local Tools

A Skill is essentially a capability manual: a directory containing a skill.md that clearly states what the capability does, when to use it, and how to use it, optionally with a few scripts and reference materials, loaded on demand by the host program. The video specifically corrects a common misconception—the Skill format itself is open, readable by all hosts, so there's no such thing as private binding. Its real problem is that it only addresses "how this thing should be done"; it's a work instruction, not a definition of how tools should be uniformly invoked.

Local tools (commonly called local functions) are written directly in business code, with capabilities living inside the application, and they can't be taken to another application.

Boundaries of local tool capabilities

So the three are not a choose-one relationship. In practice, Skill usually describes business processes, MCP connects to general-purpose tools, and local functions handle lightweight logic that is only used within this application and not worth deploying separately. Each of the three layers handles one thing, which is far more reasonable than forcing a binary choice.

From Multiplication to Addition: Where Consistency and Permissions Belong

Back to the opening scenario. With three vendors' models and three core capabilities, if you follow the Skill or local tool approach, it's three models times three capabilities—nine sets of adaptation work in total, each needing to align parameters, return formats, and permission rules, and each new capability adds another round of multiplication. Switch to MCP, and it's three tool servers plus one general client implementation; the work goes from multiplication to addition.

In practice, each of the three core capabilities gets its own independent server. Each server manages its own affairs: who has permission to call, how large a data scope can be called, how parameters are validated, how long logs are retained, and which fields in returned results need to be masked. All rules are written on the server, and all models share the same set of rules.

All rules converge on the server

Where does consistency come from? Two levels. For version upgrades, MCP connections have a lifecycle: when establishing a connection, both sides first handshake and negotiate the protocol version and capability scope they support; if the server declares that its tool manifest supports dynamic changes, it can proactively push notifications during updates, and the client simply re-fetches the tool manifest upon receipt. Capability iterations only change the server; the client gets the latest version on the next refresh, without manually updating 17 Skills one by one. If no compatible protocol version can be negotiated, the connection is terminated outright rather than silently running incorrect logic.

Consistency of inputs and returns is ensured by unified input schema constraints: the model side generates parameters according to the same schema, and the server validates against the same schema; returned results rely on output schema plus the structured content specification, so the client receives JSON with a fixed structure rather than free text. Permissions are also uniformly enforced on the server side: HTTP links use tokens or keys for credentials, and permission scope decisions all converge on the server, so there's no need to write a separate set on each model side.

Credential management for HTTP links

The MCP connection lifecycle begins with an initialization handshake: the client sends the protocol versions and capabilities it supports, the server returns the selected version and its own capability declarations, and only after both confirm compatibility does normal send/receive begin. If versions cannot be negotiated, the connection terminates immediately to avoid continuing communication with mismatched semantics. Once in the normal phase, both sides agree on which features they support via capability declarations—for example, whether the server supports dynamic tool manifest changes or resource subscriptions. When the server declares support for manifest changes, it can proactively push notifications after tools are added, modified, or deleted, and the client re-fetches the manifest upon receipt to complete a hot update without restart or manual intervention. This mechanism is the technical foundation for "change only the server, and the client follows automatically."

MCP Is Not a Free Lunch: Three Costs to Account For

First, there is an extra hop in the link. Remote services add an extra network round trip, so be cautious with tools that are particularly latency-sensitive; if you can put them locally via STDIO, do so.

Second, operational costs increase. Servers are deployed independently, so someone has to manage versions, certificates, authentication, and rate limiting. Previously writing a local function was enough; now there's an additional independent service that needs long-term maintenance.

Third, troubleshooting becomes harder. The call chain gets longer, and errors can occur at any link—the model, the client, or the server—so full-chain logging is needed to investigate.

Whether to adopt MCP has a straightforward criterion: if it's a single application with a single model and only two or three tools, local functions are the easiest. Only when tools need to be reused across multiple models and multiple teams, or when the tools themselves have independent permission and data boundaries, is MCP worth adopting. Forcing a server setup for three small internal tools just for the word "unification" is pure overengineering.

Consistency Must Be Verifiable, Not Just Assured Verbally

There are three steps to verify consistency: run the same batch of test cases against all connected clients and check that inputs and return structures are exactly identical; perform schema validation tests on each server by deliberately passing wrong parameter types or omitting required fields to see whether clear error messages are returned; and perform negative permission tests, where calls from accounts without permission must be intercepted and rejected. Roll out upgrades gradually first, monitoring the corresponding model's call error rate and timeout rate on a single server, and only expand to full rollout once metrics are stable.

The core value of MCP is compressing the adaptation work of connecting N models to M tools from N×M down to N+M. Whether to adopt it depends on whether the tools in your hands truly need cross-party reuse.

One-line Summary

MCP turns the adaptation effort of connecting multiple models to multiple tools from multiplication into addition, but three costs must be accounted for.

Paragraph Summary

The article clarifies that MCP, Skill, and local functions are not a choose-one relationship but a combination belonging to different architectural layers: Skill describes business processes, MCP connects to general-purpose tools reused across parties, and local functions handle lightweight in-application logic. MCP unifies message formats via JSON-RPC 2.0; STDIO and Streamable HTTP are merely different transport links. Servers expose three types of capabilities—tools, resources, and prompts—among which the Input/Output Schema of the tool layer ensures consistency of inputs and returns, and permission rules all converge on the server. Its core value is compressing the work of connecting N models to M tools from N×M to N+M. But MCP is not a free lunch: the extra hop adds latency, independent servers increase operational burden, and longer chains raise troubleshooting difficulty. It is only worth adopting when tools need cross-model, cross-team reuse or have independent permission boundaries; for a single application with a few tools, local functions are simpler.

#MCP#Skill#local tools#layered architecture#Model Context Protocol#JSON-RPC 2.0
Share:

Related articles