The future of intelligent agents in healthcare won’t be powered by any single tool or protocol. To operate effectively across the spectrum of clinical, operational, and financial workflows, agents will need to work together, each specializing in narrow tasks. These Multi-Agent Systems (MAS) must coordinate their efforts through shared context and tools.
Model Context Protocol (MCP) provides a way for language models and agents to access external data and invoke capabilities. But MCP on its own is not enough. It will not solve for the infrastructure problems that matter most in healthcare: task orientation, identity, structure, conflict resolution, governance, or state synchronization.
To make Multi-Agent Systems safe, tractable, useful, and production-ready in healthcare, we need centralizing and orchestrating capabilities as a foundation layer. At Canvas, that foundation is the SDK.
Context First: What is MCP?
MCP is a new client-server specification being developed to extend a language model’s capabilities by giving it access to new context (like up-to-date/real time data) and new tools (like APIs or actions) through a structured interface. Originally proposed by Anthropic and now maintained as an open community standard with contributions from OpenAI, Google, Microsoft and others, there is significant hope in the industry that MCP will be a massive unlock for applications of AI.
But it's nascent, especially in healthcare. So what does MCP need in order to be useful in healthcare?
The answer is an orchestrating nexus. Specifically, a task completion oriented, structured, secure, event-driven environment that gives agents the tools, context, semantic understanding, and oversight they need to act safely and effectively.
What are the current limitations of MCP in healthcare?
As promising as it is, MCP doesn’t handle core infrastructure problems. Its not designed to. It doesn’t manage identity (identity has been kept out of scope from the spec and even with the draft OAuth 2.1 extension, the role based access controls and audit capability is not addressed). It doesn’t store or structure data. It doesn’t reason about permissions, coordinate shared state, or govern side effects. In healthcare, those aren’t optional. These are table stakes capabilities that any production-ready technology solution must offer reliably.
Let’s assume that over time, MCP matures so that these issues with authentication or infrastructure are solved. This leaves another set of architectural questions that healthcare organizations must solve in the deployment of agents and utilizing MCP. These questions are particularly acute in healthcare where the system of record controls and offers access to patient data, and that access is highly regulated, must be highly secure, and workflows tend toward the far extreme of complexity, variability, and interconnectedness. This creates inherent infrastructure limitations that make answering these questions more difficult.
For an organization employing N agents, where should each be hosted? Is each its own application with local data store for local context? How is that duplicated state going to updated and with what frequency or, more likely, with what event-based update scheme? How will tools be shared (or not) across agents? How will governance work and where will the case sampling happen to measure performance?
- Hosting Agents: Each agent must live somewhere — managing N agents becomes costly and chaotic as actions and interactions explode combinatorially, with the certain eventuality of conflict (agents at cross purposes) and infinite loops.
- Shared Context is Hard: Agents need access to the same data at the same time, but coordinating local state across agents (especially time-sensitive, like clinical data) is complex.
- Tool Use and State Change: When one agent uses a tool (e.g. writes to the EMR), it may change the system in ways that other agents need to know about instantly — causing chain reactions. Synchronizing that is very hard.
This creates combinatorial complexity in an agent-to-agent world (i.e., a graph where every node = agent and every edge = communication pathway). It also opens up a new set of problems related to lifecycle management. What happens when the schema changes or people disagree with the schema? Agent and MCP versioning?
Summarizing, to be successful with a multi-agent system and MCP, a healthcare organization requires a foundation that provides:
- Authentication, access, and audit control
- Structured, longitudinal context (e.g., patient records)
- Hosted tools with built-in tracking, monitoring, and governance
- A task oriented secure runtime for agent execution with negotiation protocols and coordination authority
How the Canvas SDK solves the problem
We built the Canvas SDK to be a platform for intelligent automation within the system of record, the established hub for deterministic workflows and the obvious hub for agentic workflows in healthcare. This is a hub and spoke model where agents are hosted centrally within the EMR run-time and at the same time externally, leverage structured shared context centered on the patient record, use the same tools and event stream, and where safe governance is part of the service offering to the customer.
This is the right way to approach the multi-agent future, where the center of gravity is the system of record:
- Secure interfaces to expose tools and data for agents and developers
- Server-side delivery of agents within the EMR run-time
- Event streams emitting clinical, operational and financial events
- Built-in governance to support safe deployment at the point of care
- Data architecture that enables agents to safely operate with full context
- Coordination authority to resolve conflicts between agents and ensure idempotency contracts
Options for Agent deployment in a healthcare organization
Summary
MCP is an exciting development for distributed agent communication, offering a standardized way to extend language models with external context and capabilities. But for healthcare, where AI applications have input and output in the EMR domain - safety, coordination, and compliance are non-negotiable and MCP by itself is not sufficient for multi-agent deployment. At Canvas, we've focused not just on communication between agents, but on giving agents what they actually need to be effective: task completion orientation with negotiation protocols; structured real-time semantic understanding; access to safe, observable tools; and a governance model that supports oversight at scale. The SDK provides a consistent, low-complexity toolset for building multi-agent systems without incurring the combinatorial cost of stitching together context, tools, and state externally. That’s the foundation agents need, and it’s what makes them truly useful in production in healthcare.
