Skip to main content

Key Insight: MCS recognizes that successful LLM integration is not about building new protocols or frameworks, but about standardizing how we describe and execute the bridge between an LLM's text output and existing systems. The effectiveness of any integration ultimately depends on the model's capabilities and the quality of prompts, not the complexity of the tooling.

1 · MCS Motivation Overview

LLMs are token predictors. They consume and produce sequences of tokens that are rendered as text via a tokenizer. This means text is the only interface an LLM has to interact with its environment. It cannot execute anything directly.

To enable execution, you need a parser. The parser takes the LLM’s output, identifies structured instructions, and translates them into real-world actions.

Function Calling Recap

Function calling enables LLMs to interact with external systems by generating structured outputs (typically JSON) that describe function invocations.

The process involves:

  1. Providing the LLM with function schemas/descriptions
  2. The LLM generates a structured call in response to user queries
  3. A parser determines, extracts and validates the function call
  4. The parser executes the call against the target API/service
  5. Results are returned to continue the conversation

This pattern allows LLMs to act as intelligent orchestrators using text alone. The exact format of the function description doesn't matter. What matters is that the LLM understands when and how to call a tool and how to format the output for the parser.

This concept was formalized in TALM: Tool Augmented Language Models, which showed how LLMs can be extended with non-differentiable tools to solve real-world tasks.

Modern AI frameworks often provide parsers, but not standardized descriptions or callable functions. This leads to a fragmented landscape of custom tooling where developers repeatedly reinvent the same logic for each application.

The Model Context Protocol (MCP) addressed this by introducing the first open standard to connect LLMs with external systems. OpenAI followed a similar idea with "Plugins" (discontinued) and "Actions" for Custom GPTs long before that, but never published it as a general concept.

However, MCP added a full protocol stack, along with new complexity and security implications. Updates throughout 2025 and into 2026 -- OAuth 2.1 with PKCE, mandatory Resource Indicators (RFC 8707), streamable HTTP transport -- have improved its robustness, but the fundamental attack surface of a new protocol remains. By early 2026, the ecosystem has accumulated over 50 documented vulnerabilities (13 critical), including remote code execution chains, cross-client data leaks, and tool poisoning -- where malicious instructions hidden in tool descriptions are invisible to users but acted on by models VulnerableMCP. Academic analysis confirmed 7.2% of servers exhibit general security flaws and 5.5% show MCP-specific tool-poisoning vulnerabilities Arxiv 2504.03767.

Much of the effort that followed focused on building wrappers around APIs that could already be used directly by LLMs, as demonstrated in the MCS proof of concept. This wrapper anti-pattern is increasingly recognized in the community 8 9.

Critically, MCP often reimplements features the web has solved decades ago. Take authentication: instead of relying on proven standards like Basic Auth, OAuth2, or API Keys over HTTPS, MCP introduces its own way, all while using JSON-RPC under the hood. This adds layers of complexity with little gain.

Despite this, MCP succeeded, not because of elegance, but because it is the first real standard in this space. And a standard was needed.

Useful features like autostarting MCP servers were not design decisions, but emerged from practical needs when using the STDIO transport layer. Making a core benefit for some developers a side effect not a core of MCP itself. Seems nice in the context of MCP, but makes no sense to call local resources by spinning up one or multiple servers with user privileges.

MCS now distills this all down to the essentials. What is actually required to connect an LLM to external systems in a standardized and reusable way.

At the core, it's a driver problem.

A MCS driver must expose a function specification that LLMs can consume. Most modern LLMs can use these out of the box. But to ensure precision, the driver should also provide usage instructions and formatting hints so the output can be correctly parsed.

The parser is the other half of the equation. It bridges the LLM’s output to real-world execution by scanning for and dispatching structured calls.

Previously, function implementations were written from scratch for every use case. But with MCS generalization is key. If a REST call works for one service, it can be reused for all REST services.

MCS generalizes function calling for a given protocol over a specific transport layer in one driver.

MCS follows a standard-first principle: if an established specification format exists, use it. Drivers can work with any machine-readable format, for example:

  • OpenAPI (JSON/YAML) -- RESTful APIs
  • JSON Schema -- structured input/output validation, CLI tools, message formats
  • GraphQL SDL -- GraphQL-based APIs
  • WSDL -- SOAP and legacy enterprise services
  • gRPC / Protocol Buffers -- high-performance binary APIs
  • OpenRPC -- JSON-RPC APIs
  • EDIFACT/X12 schemas -- EDI-based B2B interfaces
  • Custom formats -- when no standard applies

MCS does not prescribe a format -- it prescribes the driver contract. The format can even be changed to address the capabilities of the connected LLM.

What this enables​

The driver contract creates something that didn't exist before: a clear division of labor.

Because each driver encapsulates specification, prompt logic, and execution behind a stable interface, roles can specialize independently. Technical engineers build ToolDrivers for specific protocols without needing AI knowledge. Prompt engineers optimize model-specific instructions inside drivers, making their work reusable across every application that uses that driver. AI application developers pick drivers and manage the conversation loop -- without understanding the underlying protocol or investing in prompt engineering.

Prompt engineering, in particular, changes from a per-project cost into a one-time investment with compounding returns. When someone improves the prompts inside a driver, every application using it benefits immediately. Combined with dynamic prompt loading (Section 11), prompt configurations become versionable, tradeable artifacts.

Because MCS drivers are standard libraries -- not separate services -- they integrate into existing toolchains: package registries, CI/CD pipelines, monitoring, access control. The LLM integration fits into the existing software architecture like any other module.

This is the ecosystem MCS is designed to enable. Section 12 explores it in detail.