By Chris Heggem – Refreshed October 2026
TL;DR
- Model Context Protocol (MCP) is an open standard for connecting AI applications to external tools, data, and workflows through one consistent interface instead of custom integrations.
- How it works: an AI application uses an MCP client to discover and call the tools, resources, and prompts that MCP servers expose.
- Adoption: as of December 2025, one year after launch, MCP had more than 97 million monthly SDK downloads and 10,000 active servers, with client support in ChatGPT, Claude, Cursor, Gemini, Microsoft Copilot, and Visual Studio Code (MCP Blog, 2025).
- What changed: MCP moved to vendor-neutral governance under the Linux Foundation in December 2025, and the July 2026 specification made the protocol stateless so it scales on ordinary enterprise infrastructure.
- Why it matters for SRE: standardized, permission-scoped access to telemetry, logs, and tickets lets AI SRE systems investigate across tools without a custom connector for each one.
As AI systems become more capable, they also become more dependent on external tools, data sources, and workflows. A model alone cannot investigate incidents, query infrastructure, access databases, or interact with enterprise systems or other agents without a structured way to connect to them.
That’s where Model Context Protocol (MCP) comes in.
Model Context Protocol is an open standard designed to help AI systems reliably interact with tools, services, and information sources. Instead of building custom integrations for every application or dataset, MCP creates a consistent framework for connecting AI to the systems it needs to reason, investigate, and act.
At Ciroos, we see MCP as an important building block for the future of AI systems and agent-driven workflows. Understanding how it works, and why it matters, is key to building scalable AI platforms.
What is Model Context Protocol?
Model Context Protocol (MCP) is an open protocol that standardizes how AI models and applications interact with external systems. Anthropic introduced MCP in November 2024, and in December 2025 donated it to the Agentic AI Foundation, a directed fund under the Linux Foundation, where it is now developed as a vendor-neutral open standard (MCP Blog).
In simple terms, MCP allows an AI system to:
- Access structured data sources
- Use external tools
- Retrieve relevant context
- Execute actions through defined interfaces
In this sense, the model context protocol AI ecosystem enables intelligent systems to operate with real-time context rather than relying only on static training data.
Why Model Context Protocol Matters
Modern AI applications require more than just model inference. To operate effectively in real-world environments, they must be able to query observability platforms, retrieve documentation and knowledge bases, access databases, execute operational workflows, and investigate issues across multiple systems. In most organizations, these capabilities live across many different tools, each with its own interface and integration requirements.
Without a standardized approach, every AI application must build its own connectors to these systems, leading to integration sprawl, fragile dependencies, and growing maintenance overhead. The model context protocol concept addresses this challenge by introducing a universal method for exposing tools and resources to AI systems, creating a consistent interface layer that simplifies how AI platforms connect, evolve, and operate across complex environments.
What’s Changed About Model Context Protocol in 2026
MCP has moved from a developer convenience to enterprise infrastructure. Four changes stand out.
- Vendor-neutral governance. MCP is now a founding project of the Agentic AI Foundation, co-founded by Anthropic, Block, and OpenAI with support from Google, Microsoft, AWS, Cloudflare, and Bloomberg. The protocol’s maintainers keep control of its technical direction (MCP Blog).
- A stateless core built to scale. The 2026-07-28 specification, the largest revision since launch, removed the connection handshake and protocol-level sessions so every request stands on its own. It also added a formal extensions framework, authorization that aligns more closely with OAuth and OpenID Connect, and a formal deprecation policy (MCP Blog).
- Built-in traceability. The same release documents how OpenTelemetry trace context travels with MCP requests, so tool calls can be traced end to end in the observability stacks SRE teams already use (MCP changelog).
- Security became its own discipline. The OWASP MCP Top 10 catalogs the most critical risks in MCP deployments, including token mismanagement, privilege escalation through scope creep, tool poisoning, and unmanaged “shadow” MCP servers (OWASP).
The common thread: connecting AI to tools is no longer the hard part. Governing that access safely and at scale is.
How Model Context Protocol Works
At a high level, MCP defines how AI applications interact with external capabilities through a structured architecture.
A typical MCP interaction involves three key elements:
- Host application – The environment running the AI system, such as an AI platform, developer tool, or operational assistant.
- MCP client – A component within the host that communicates with MCP servers.
- MCP server – A service that exposes tools, data, or capabilities through the protocol.
Through this structure, an AI system can discover available capabilities and invoke them when needed.
For example, an SRE AI assistant investigating an operational issue might:
- Discover available observability tools
- Query metrics or logs through an MCP server
- Analyze the data
- Recommend or trigger remediation actions
This architecture enables structured collaboration between AI reasoning and external systems.
Core Components of MCP: Tools, Resources, and Prompts
Several foundational primitives define how MCP works. These model context protocol concepts help standardize how information and actions are exposed to AI systems.
Tools – Tools represent executable capabilities an AI system can invoke.
Examples include:
- Querying monitoring systems
- Running database queries
- Retrieving logs
- Triggering workflows
Model context protocol tools ensure these capabilities are exposed in a consistent format so AI systems can discover and use them safely.
Resources – Resources provide contextual information rather than executable actions.
Examples include:
- Documentation
- System metadata
- Configuration data
- Knowledge bases
These resources help AI systems ground their reasoning in relevant operational context.
Prompts – Prompts define reusable instructions or workflows that guide how AI systems interact with tools and resources.
They can help standardize investigative procedures, automate repetitive analysis, or ensure consistent workflows across environments.
MCP Clients vs. MCP Servers
Understanding the difference between MCP clients and MCP servers is essential to understanding how Model Context Protocol (MCP) works in practice. MCP clients typically live inside AI applications or platforms and act as the interface between the AI system and external capabilities. When an AI system needs additional context or wants to perform an action, the MCP client is responsible for discovering available tools, requesting resources, and invoking those capabilities through the protocol.
Model context protocol servers, on the other hand, expose tools, data sources, and capabilities that AI systems can access. They provide structured interfaces to underlying systems such as observability platforms, databases, knowledge bases, or internal services, and they manage important functions like authentication, execution, and data retrieval. In most environments, organizations deploy multiple MCP servers across their infrastructure, each exposing capabilities from different systems, allowing AI applications to dynamically access the context and tools they need.
What Problems Does Model Context Protocol Solve?
The growth of AI systems has exposed several operational challenges.
Without a standardized integration layer, AI applications struggle with:
- Fragmented integrations – Each system requires custom connectors.
- Limited context access – Models often lack real-time operational information.
- Tool discovery challenges – AI systems cannot easily determine what capabilities exist.
- Operational complexity – Maintaining integrations across multiple models and services becomes difficult.
Model context protocol sampling adds flexibility in the other direction: it lets an MCP server request a model completion through the client, so servers can use AI reasoning without their own model API keys while the client keeps control over model access and permissions.
By standardizing how AI systems access context and tools, MCP reduces integration complexity while enabling more capable AI workflows.
Model Context Protocol Use Cases
MCP is increasingly being adopted across several AI-driven workflows.
- Developer tools and IDE assistants – AI assistants can query documentation, repositories, and debugging tools to support development tasks.
- Enterprise knowledge assistants – Organizations can expose internal knowledge bases, documentation, and databases through MCP servers.
- Operational automation – AI systems can access observability platforms, run diagnostics, and trigger workflows.
- AI-powered investigations – Operational teams can use AI assistants that investigate incidents using real-time telemetry and logs.
These use cases illustrate how MCP enables AI systems to operate with real-world context and capabilities.
Model Context Protocol and AI SRE
For AI-powered Site Reliability Engineering (AI SRE), access to operational context is critical. Investigating incidents, identifying root causes, and enabling AI for SRE often requires querying multiple systems such as observability platforms, log stores, configuration databases, and internal documentation.
Model Context Protocol helps enable this capability by providing a standardized way for AI systems to interact with these tools and data sources. Through MCP servers, an AI SRE system can retrieve telemetry, analyze logs, access system metadata, and correlate signals across systems to accelerate root cause analysis without requiring custom integrations for every platform.
At Ciroos, this capability is especially important for enabling AI-assisted investigations across complex environments. Modern incidents often span applications, infrastructure, and multiple observability tools, making it difficult for engineers to correlate signals quickly. By enabling standardized access to telemetry, logs, and operational metadata, MCP helps AI SRE systems gather the context needed to investigate issues systematically and support engineers in resolving incidents faster.
Ciroos itself integrates with enterprise observability, ticketing, and ChatOps tools through open standards including MCP and A2A, with read-only access by default, strictly scoped permissions, and automated data redaction.
MCP and Interoperability for AI Agents
One of the most powerful aspects of MCP is its ability to enable interoperability across AI agents and systems. As organizations adopt agent-driven architectures, multiple AI agents often need access to the same tools, data sources, and operational workflows. This is where model context protocol (MCP) agents become important, allowing AI systems to discover shared capabilities and interact with external tools through a consistent interface.
Without standardization, each agent may require its own integrations, leading to duplicated connectors, fragmented capabilities, and inconsistent behavior across systems. MCP introduces a shared protocol layer that allows agents to discover capabilities, access shared tools, and retrieve contextual information in a consistent way.
For platforms like Ciroos, MCP plays a key role in enabling a broader ecosystem of AI agents to work together. Different agents may specialize in areas such as infrastructure, networking, or application behavior, and MCP provides a common interface for these agents to access tools and share context. This allows organizations to extend their AI capabilities over time while maintaining a consistent integration model across systems.
MCP is one of two complementary open protocols here: MCP connects agents to tools and data, while the Agent2Agent (A2A) protocol, also hosted by the Linux Foundation, connects agents to each other.
MCP vs. APIs vs. Function Calling
MCP does not replace APIs. Instead, it standardizes how AI systems interact with them.
APIs define how software systems communicate.
MCP defines how AI systems discover and use those capabilities.
Function calling inside language models also allows models to invoke tools, but MCP expands the concept by providing:
- Tool discovery
- Context access
- Standardized interfaces
- Multi-system interoperability
This makes MCP particularly valuable for large-scale AI platforms and enterprise environments.
How to Get Started with Model Context Protocol
Organizations exploring MCP typically begin by:
- Identifying tools and systems AI should access
- Creating MCP servers that expose those capabilities
- Integrating MCP clients into AI applications
- Establishing governance and security policies, such as least-privilege scopes, read-only defaults, and an inventory of approved MCP servers (the OWASP MCP Top 10 is a useful checklist)
Because MCP is an open protocol, developers can build servers that expose capabilities from virtually any system.
As the ecosystem grows, major AI assistants, developer tools, and enterprise platforms now support MCP natively, making it easier to build AI applications that operate across complex environments.
Book a demo to see how Ciroos uses open standards like MCP to investigate across your existing stack.
Model Context Protocol (MCP) FAQs
What is Model Context Protocol?
Model Context Protocol (MCP) is an open standard that allows AI systems to interact with external tools, data sources, and services. It provides a structured way for AI models to retrieve context and execute actions beyond their training data.
Is Model Context Protocol open source?
Yes. MCP is designed as an open protocol, with reference implementations, SDKs, and documentation available publicly. This allows developers and organizations to build their own MCP servers and integrations.
How does MCP help AI systems access real-world data?
MCP enables AI systems to query tools and retrieve contextual information from external sources such as databases, observability platforms, and documentation systems, giving the AI access to live operational data.
What are MCP tools?
MCP tools are executable capabilities exposed through MCP servers. These tools allow AI systems to perform actions such as querying logs, retrieving metrics, or triggering automated workflows.
What is the difference between MCP clients and servers?
MCP clients live inside AI applications and request capabilities, while MCP servers expose tools and resources that those AI systems can access.
Why is MCP important for AI agents?
AI agents need structured access to tools and information to perform tasks reliably. MCP provides a standardized way for agents to discover capabilities, retrieve context, and execute actions across complex environments.
Who created Model Context Protocol, and who governs it now?
Anthropic introduced MCP as an open standard in November 2024. In December 2025, Anthropic donated it to the Agentic AI Foundation, a directed fund under the Linux Foundation co-founded by Anthropic, Block, and OpenAI. MCP’s maintainers still set its technical direction, while the foundation provides vendor-neutral governance.
What’s the difference between MCP and A2A?
MCP connects an AI agent to tools, data, and other resources. A2A (Agent2Agent) connects AI agents to each other so they can discover one another and coordinate on tasks. The two are complementary, and both are open protocols hosted by the Linux Foundation.
Is Model Context Protocol secure?
MCP includes an authorization framework, but how securely it runs depends on how each deployment is configured. The OWASP MCP Top 10 lists the main risks, including token mismanagement, privilege escalation through scope creep, tool poisoning, and unmanaged MCP servers. Common safeguards are least-privilege scopes, read-only defaults, vetted servers, and treating tool output as untrusted input.
What is sampling in Model Context Protocol?
Sampling lets an MCP server ask the client’s AI model to generate a response, instead of the server calling a model itself. The server needs no model API keys of its own, and the client keeps control over which model is used and what the model sees. The specification recommends a human be able to review or deny sampling requests.
How does Ciroos use Model Context Protocol?
Ciroos integrates with enterprise observability, ticketing, and ChatOps tools through open standards including MCP and A2A. That lets the Ciroos AI SRE Teammate reason across an organization’s existing stack without rip-and-replace, with read-only access by default, strictly scoped permissions, and automated data redaction.Ciroos integrates with enterprise observability, ticketing, and ChatOps tools through open standards including MCP and A2A. That lets the Ciroos AI SRE Teammate reason across an organization’s existing stack without rip-and-replace, with read-only access by default, strictly scoped permissions, and automated data redaction.