An “Open” Agent Framework: Building AI That Avoids the EHR Trap
I recently shared a 7-layer stack to illustrate how AI agents work, particularly within the healthcare context. The follow-up discussions have been insightful, and one recurring question keeps surfacing:
How do we develop AI solutions that avoid the mistakes of the EHR era? How do we ensure AI systems are plug-and-play, interoperable, modular, and not locked into a single vendor’s ecosystem?
The answer begins with one word: open.
Why “Open” Matters
When I say open, I do not simply mean open-source. Open-source is about licensing and access to code. What we need is something broader: systems that are open by design.
An open agent framework should allow you to:
Switch to a better model without rebuilding the entire stack
Apply the same algorithm to different data sources, such as FHIR, OpenEHR, or even unstructured documents
Add or swap tools without tearing apart existing workflows
Connect multiple agents to combine specialized capabilities
Healthcare has already experienced what happens when systems are tightly coupled and proprietary. Integration becomes expensive, innovation slows, and collaboration suffers. If we repeat that pattern in the AI era, we risk rebuilding the same silos with more advanced technology.
Fortunately, we are beginning to see emerging standards that make a more modular, interoperable ecosystem possible.
Model Context Protocol: The Glue
Model Context Protocol, or MCP, is quickly becoming connective tissue for the agent ecosystem. MCP defines how models interact with data sources, tools, APIs, and sometimes other agents in a consistent and structured way.
Rather than building custom integrations for each new model or data connection, MCP standardizes how context is passed and how tools are invoked. This abstraction allows developers to focus on capability rather than plumbing.
Within the 7-layer agent stack, MCP influences almost every layer except the interface layer. It shapes how models retrieve data, call tools, and execute structured actions. It creates separation between reasoning and integration, which is foundational to openness.
But the interface layer is where things become especially interesting.
MCP-UI: Openness at the Front-End
When most people hear “agent interface,” they imagine a chatbot. The question then becomes: how do you standardize a conversation?
A new specification called MCP-UI introduces openness at the UI layer. It defines how structured interface components such as buttons, forms, tables, and visual summaries can be embedded directly into conversational workflows.
Instead of treating UI as a separate hard-coded layer, MCP-UI allows developers to define both logic and interface elements through the same standard used to manage model context and tools. This creates portable, reusable conversational experiences that are not tightly bound to a single front-end framework.
Openness at the front-end ensures that the user experience can evolve without breaking the underlying agent logic.
A2A: When Agents Talk to Each Other
The second emerging standard is A2A, short for Agent-to-Agent Protocol.
If MCP defines how agents talk to data and tools, A2A defines how they talk to each other. This is a critical distinction.
In real-world healthcare scenarios, a single agent is rarely sufficient. Imagine:
A clinical reasoning agent collaborating with an administrative agent
A patient-facing agent consulting a billing agent in the background
A care coordination agent requesting data from a documentation agent
A2A enables this collaboration in a structured and predictable way. It supports orchestration across specialized agents, allowing them to share context, delegate tasks, and return structured results.
This is how we move from isolated chatbots to ecosystems of intelligent, specialized agents working in concert.
Openness as the Differentiator
As we move deeper into the agent era, openness will be the true differentiator.
Closed systems may optimize for short-term control, but they struggle to scale collaboration. They limit model choice, restrict integration, and create friction for innovation.
Open systems, by contrast, invite collaboration. They allow models, tools, agents, and data sources to evolve independently while remaining interoperable.
If we want to avoid repeating the EHR mistakes, openness must be built into the architecture from day one.
At Prompt Opinion, we are developing agent solutions grounded in these open standards and principles. If you are exploring how to build modular, interoperable AI systems in healthcare, we would be glad to connect and discuss how to operationalize openness in practice.