The journey from Microsoft’s Semantic Kernel (SK) to Model Context Protocol (MCP) servers marks a significant evolution in how AI agents interface with external tools, services, and each other. This transformation illustrates a broader shift: from embedding intelligence into applications to building ecosystems where AI functions as an interoperable, real-time participant.
The Foundation: Semantic Kernel and AI Function Calling
Microsoft’s Semantic Kernel emerged as a pioneering framework enabling developers to integrate large language models (LLMs) with conventional application logic. With function calling, developers could expose native code (C#, Python, etc.) and prompt-based logic to LLMs, enabling them to take action based on user prompts or environmental context.
Semantic Kernel gave rise to hybrid agents—intelligent systems capable of reasoning with both data and action. A user could ask, “Book me a meeting with Lisa tomorrow at 3 PM,” and the LLM, using function calling, could interact with calendar APIs to complete the task. It was AI as orchestrator—not just respondent.
The Evolution: From Isolated Agents to Interconnected Systems
While Semantic Kernel empowered AI agents within a single application, the real world demanded interoperability. Different agents needed to interact—across organizations, services, and platforms. The limitation of isolated function calling soon became clear. A more extensible, secure, and discoverable way to publish and consume functions was needed.
Enter Model Context Protocol (MCP).
MCP: A Protocol for Open, Secure AI Interoperability
The Model Context Protocol, led by innovators including GitHub and backed by the OpenAI developer ecosystem, proposes a standardized way for LLMs to discover and invoke capabilities hosted anywhere—be it on a local server, enterprise API, or public service.
Think of MCP servers as the modern equivalent of “function registries.” They allow:
- Agents to query and discover available capabilities via a standard format.
- Functions to describe themselves semantically, including auth, input/output schemas, and constraints.
- A secure handshake and invocation pipeline, so one agent’s toolset can be safely used by another.
It’s the infrastructure needed to move from a single LLM agent to a network of agents working together across domains.
Why MCP Matters: An Open API for AI
Just as REST and GraphQL helped web services flourish, MCP may be the bridge that lets AI truly plug into the digital ecosystem:
- Modular AI Development: Build once, publish anywhere. Tools built for one model can be reused by others.
- Zero Trust Ready: Security is embedded from the start, with scopes, tokens, and permission management.
- Cross-Model Collaboration: Models from different vendors can collaborate using a common protocol, enabling heterogeneous multi-agent systems.
Real-World Momentum
We’ve already seen examples like:
- Claude building structures in Minecraft via MCP servers.
- Plugins and Copilot extensions aligning with MCP specs to offer discoverable functionality.
- Pulses of new MCP servers listed in public directories, showing adoption is growing fast.
From Function Calls to AI Protocols: What’s Next?
The transition from Semantic Kernel’s tightly-coupled function calls to the loosely-coupled, protocol-driven world of MCP reflects the broader evolution in software design—from monoliths to microservices, and now from mono-agents to mesh-agents.
This shift unlocks powerful possibilities:
- Open marketplaces of AI services
- Composable, dynamic workflows across models
- Agentic systems that evolve by learning new functions over time
Conclusion
Semantic Kernel gave us the building blocks. MCP is giving us the roads, bridges, and traffic rules. Together, they set the stage for the next generation of intelligent systems—open, secure, and interoperable by design.
The future isn’t just AI-powered apps. It’s AI-powered networks—and MCP is the protocol that could make them real.