Framework context
This research report supports operational interpretation across the GAISSF Ecosystem. Use GAISSF for governance and assurance context, UAIF for incident classification, and AI-IRF for incident-response architecture. These links describe relationships; they do not assert certification, regulatory approval, or legal compliance.
Executive abstract
AI interoperability protocols are beginning to occupy the same
architectural role that APIs, service meshes, and identity providers
came to occupy in enterprise software over the preceding decade —
determining not just how systems communicate, but how they establish
trust, exercise delegated authority, and coordinate operational behavior
across distributed environments. The July 2026 revision of the Model
Context Protocol (MCP), the largest specification change since its
introduction, is the concrete case study this publication uses to
examine that transition. The revision replaces MCP’s session-based core
with a stateless architecture and introduces structured extensions,
hardened authorization, and a formal deprecation policy. This
publication argues that these visible technical changes are symptoms of
a more consequential shift: MCP is evolving from an interoperability
protocol into enterprise operational infrastructure. That transition
migrates the enterprise trust boundary beyond the transport layer into
identity, authorization, extension governance, operational state, and
evidence — introducing operational assurance obligations that exceed
protocol conformance and that generalize beyond MCP itself. The
publication develops four analytical concepts — Trust Boundary
Migration, Explicit State Governance, Extension Assurance, and Protocol
Assurance — and positions them within the GAISSF™ Ecosystem without
proposing them as new normative frameworks.
Primary Contributions
This publication contributes:
- The concept of Trust Boundary Migration, describing
the architectural consequence of the 2026-07-28 revision in terms
generalizable beyond MCP to other AI interoperability protocols.
- The concept of Explicit State Governance.
- The concept of Extension Assurance.
- The concept of Protocol Assurance.
- The Enterprise AI Protocol Assurance Stack (EAPAS),
a protocol-agnostic analytical reference model.
- A protocol-independent operational assurance interpretation of AI
interoperability infrastructure, mapped to GAISSF™, UAIF™, and AI-IRF™
without extending or replacing their normative content, and bounded by
an explicit Alternative Interpretation and Limitations discussion
(Chapter 13).
How to read this publication
This publication is a continuous, evidence-bounded analysis. Part I
(Chapters 1–9) establishes why the 2026-07-28 revision represents an
architectural transition rather than a routine protocol update, and
develops the four analytical concepts — Trust Boundary Migration,
Explicit State Governance, Extension Assurance, and Protocol Assurance —
that structure the remainder of the publication, concluding with the
Enterprise AI Protocol Assurance Stack and its relationship to the
GAISSF™ Ecosystem. Part II (Chapters 10–14) operationalizes those
concepts through incident readiness, operational response, enterprise
recommendations, explicit scope boundaries (including an Alternative
Interpretation and stated Limitations), and a forward-looking conclusion
with a research agenda. Appendix A cross-references each analytical
chapter against the underlying specification changes it interprets. MCP
is used throughout as the evidentiary case study for a pattern the
publication argues generalizes beyond this one protocol.
Part I — Understanding the Architectural Shift
Chapter 1 — From Interoperability to Operational Infrastructure
Theme: Modern AI interoperability protocols increasingly
function as enterprise operational infrastructure rather than simple
communication mechanisms.
Enterprise AI is entering a phase in which interoperability protocols
increasingly determine how AI systems establish trust, exercise
authority, and coordinate operational behavior across distributed
environments — occupying, for agentic AI, something like the
architectural role that APIs, service meshes, and identity providers
came to occupy for enterprise software over the preceding decade. The
July 2026 revision of the Model Context Protocol (MCP) is a concrete,
currently observable example of that transition, and it is the evidence
base this publication uses to examine what the transition means
operationally. It is not, however, the destination of the argument: the
analytical concepts developed in this publication are built to outlast
this specific revision, and to apply equally to whichever AI
interoperability protocols come to matter most over the next several
years.
When MCP was first introduced, its primary objective was
straightforward: provide a common protocol that allowed AI applications
to interact with external tools, prompts, resources and services without
requiring bespoke integrations for every implementation.
Viewed through that lens, MCP resembled many other interoperability
standards. The protocol primarily addressed communication between
software components. Security considerations naturally focused on
transport protection, endpoint authentication and implementation
correctness, while governance remained largely an organizational concern
outside the protocol itself.
The 2026-07-28 revision represents a noticeable shift in that
architectural trajectory.
Although the published specification introduces numerous technical
improvements—including stateless operation, enhanced authorization
mechanisms, extension governance, application support and formalized
protocol evolution—the cumulative effect is more significant than any
individual feature. Collectively, these changes reposition MCP from a
communication protocol toward an operational platform expected to
support enterprise-scale AI deployments.
This distinction is important because communication protocols and
operational infrastructure are governed differently.
A communication protocol primarily answers questions such as:
How are requests exchanged?
How are responses formatted?
How do independent implementations interoperate?
Operational infrastructure must answer additional questions:
Which identities are authorized?
How is authority delegated?
How are extensions governed?
How is operational state maintained?
How are distributed activities observed?
How is evidence retained?
How are protocol changes managed across production
environments?
These questions extend beyond interoperability into governance,
operational resilience and assurance.
The 2026-07-28 revision does not attempt to solve every one of these
enterprise concerns. Rather, it acknowledges that modern AI deployments
require the protocol to participate more directly in identity,
authorization, extensibility and operational lifecycle management than
earlier versions anticipated.
Consequently, organizations evaluating MCP should avoid treating the
revision as a routine protocol update. Instead, they should recognize it
as an architectural transition in which protocol decisions increasingly
influence enterprise security posture, governance processes and
operational assurance requirements.
This observation forms the central premise of this paper.
The analysis that follows therefore evaluates each major
specification change not simply by asking what changed,
but by examining how those changes alter enterprise trust boundaries,
governance responsibilities and assurance expectations.
ODA3 Insight
ODA3 Insight
Mature protocols rarely become simpler—they relocate complexity.
The 2026-07-28 MCP revision reduces complexity within the transport
layer while increasing the importance of identity, authorization,
extension governance and operational assurance elsewhere in the
deployment architecture.
The Specification Delta
This will not be a prose chapter.
It will begin with a research table.
This table becomes the backbone of the rest of the
article. Every subsequent chapter will take one row and expand
it into an operational analysis, mapping it to GAISSF™, UAIF™, and
AI-IRF™ where appropriate.
Key Takeaway
Key Takeaway: The July 2026 MCP revision should be
evaluated as an architectural transition with operational assurance
implications rather than as a routine protocol enhancement.
Chapter 2 — The Specification Delta: More Than a Protocol
Revision
Theme: Specification changes become strategically important
when they alter governance assumptions rather than merely protocol
behavior.
The 2026-07-28 revision introduces numerous technical changes across
the Model Context Protocol. Considered individually, many appear
incremental. Collectively, however, they represent a significant
architectural evolution in how enterprise AI systems establish
communication, maintain context, govern identity, and coordinate
operational behavior.
This chapter examines the revision as a specification
delta rather than a feature list. The objective is not to
catalogue protocol changes, but to understand how each change alters
enterprise deployment assumptions, trust boundaries, and assurance
obligations.
The distinction is important.
Protocol specifications describe how compliant
implementations communicate. Enterprise architects must
additionally determine how those implementations will be
governed, monitored, secured, and evidenced once deployed.
Accordingly, each major revision is evaluated through five
complementary perspectives:
This analytical approach forms the foundation for the remainder of
the paper.
Specification Delta Matrix
ODA3 Observation
A notable pattern emerges across every major revision.
None of the changes simply add functionality.
Instead, each relocates operational responsibility.
For example:
Removing protocol-managed sessions does not
eliminate state.
Strengthening authorization does not eliminate
identity management.
Introducing extensions does not reduce
governance effort.
Formalizing protocol evolution does not remove
lifecycle management.
Instead, responsibility shifts upward—from the protocol itself to the
organizations implementing it.
This pattern is common in mature distributed architectures. Simpler
protocol behavior often requires more disciplined governance elsewhere
in the system.
That observation leads to the first original analytical conclusion of
this paper:
Mature interoperability protocols tend to reduce transport
complexity while increasing implementation governance
responsibilities.
Whether this trade-off is beneficial depends not only on protocol
design but on the organization’s ability to govern identity,
authorization, operational state, extension lifecycle, and evidence
throughout production. This distinction explains why the 2026-07-28
revision should not be viewed solely as a protocol modernization. It is
also a governance transition.
Key Takeaway
Key Takeaway: The significance of the specification
lies in the redistribution of governance responsibilities, not simply
the addition of new protocol features.
Chapter 3 — Trust Boundary Migration
Theme: The most important architectural change is the
movement of enterprise trust responsibilities.
The most visible changes introduced in the 2026-07-28 MCP revision
include stateless communication, enhanced authorization, structured
extensions and improved application support. These features naturally
attract technical attention because they directly affect protocol
implementations.
From an operational assurance perspective, however, these individual
changes are symptoms rather than the primary architectural event.
The more significant change is that the enterprise trust
boundary has migrated.
Trust boundaries define where an organization transitions from
assumed trust to explicitly managed trust. They identify where identity
must be established, authority verified, operational state governed and
evidence preserved.
Earlier MCP deployments often treated the protocol primarily as an
interoperability layer. The implicit trust boundary typically existed
between the AI application and the external tool.
Traditional View
AI Application
│
▼
MCP Protocol
│
▼
External Tool
In this model, protocol correctness was largely synonymous with
operational correctness. If the protocol functioned as specified and
transport security was maintained, much of the remaining governance was
delegated to surrounding systems.
The 2026-07-28 revision changes this assumption.
The protocol now participates directly in identity propagation,
authorization decisions, extension negotiation, application lifecycle
and long-running operational workflows. These responsibilities require
organizations to establish trust before a request reaches a tool and to
preserve that trust throughout distributed execution.
The resulting trust boundary is substantially broader.
Figure 1. Professional publication figure to be
inserted during production.
The protocol no longer represents a simple communication channel.
It becomes part of the enterprise trust architecture.
Why the Boundary Has Moved
Each major specification change contributes to this migration.
Stateless Transport
Removing protocol-managed sessions does not eliminate operational
state.
Instead, state becomes an explicit responsibility of applications
through identifiers, handles and application-managed context.
This shifts governance from hidden transport mechanisms toward
explicit application design.
Operational questions therefore change from:
“Does the protocol maintain state?”
to
“Who owns state, how is it protected, and how can it be reconstructed
during investigation?”
Identity
Earlier implementations frequently treated authentication as an
external concern.
The revised authorization model more tightly integrates modern OAuth
2.0 and OpenID Connect practices, making identity an architectural
dependency rather than an implementation convenience.
Identity is no longer simply required for access.
It becomes fundamental to protocol operation.
Authorization
Authorization decisions now influence every downstream
interaction.
Rather than evaluating whether a connection is permitted,
organizations must increasingly determine:
which identities may invoke which tools;
under what delegated authority;
for how long;
with what operational constraints;
using which evidence.
Authorization therefore becomes a continuous operational
responsibility rather than a connection event.
Extensions
Extensions introduce independent capability evolution outside the
protocol core.
This increases flexibility.
It also creates new trust questions.
Organizations must evaluate:
extension provenance;
compatibility;
lifecycle;
update governance;
revocation;
operational monitoring.
Trust therefore extends beyond protocol conformance into extension
governance.
Long-running Tasks
Persistent workflows create trust relationships that continue after
individual requests have completed.
Organizations must determine:
who owns execution;
how interruption is handled;
how authority changes during execution;
how evidence is preserved;
how recovery occurs.
Trust now spans time as well as architecture.
ODA3 Insight
**The 2026-07-28 MCP revision does not merely relocate protocol
functionality.
It relocates enterprise trust.**
That distinction is subtle but operationally significant.
Earlier protocol generations primarily required organizations to
trust the communication layer.
The revised architecture requires organizations to govern trust
continuously across identities, applications, extensions, execution
environments and operational evidence.
Operational Consequences
This migration produces several practical implications.
Security Teams
Must validate identity propagation rather than only encrypted
transport.
Enterprise Architects
Must define trust boundaries that include extensions, execution
environments and application-managed workflows.
Governance Teams
Must treat protocol changes as architectural changes subject to
change management and operational risk review.
Incident Response
Must preserve evidence across multiple architectural layers rather
than relying on protocol logs alone.
What This Does NOT Mean
Trust Boundary Migration should not be interpreted as suggesting that
MCP itself enforces enterprise governance.
The protocol provides mechanisms.
Organizations remain responsible for implementing:
identity governance;
authorization policy;
extension approval;
operational monitoring;
evidence retention;
business authorization;
risk management.
The protocol enables these capabilities.
It does not replace them.
ODA3 Definition
Trust Boundary Migration
Trust Boundary Migration is the architectural
transition in which responsibilities previously assumed to exist within
a protocol, platform or infrastructure component become explicitly
distributed across identities, authorization systems, applications,
operational workflows and governance processes.
Trust Boundary Migration does not inherently increase or decrease
security.
Instead, it changes where organizations must establish,
monitor and demonstrate trust.
Why This Matters for the Rest of the Paper
This chapter establishes the analytical lens for everything that
follows.
The remaining chapters are no longer about individual protocol
features.
They become case studies in Trust Boundary Migration.
Each subsequent chapter answers:
How has trust moved?
Who now owns it?
What evidence demonstrates it?
How should organizations govern it?
What new assurance obligations emerge?
Explicit State Governance
Rather than discussing statelessness as an implementation
optimization, we’ll analyze how moving state from the transport layer
into application-managed context affects auditability, incident
response, forensic reconstruction, distributed tracing, evidence
retention, and operational assurance. That keeps the discussion aligned
with ODA3’s focus on governance and operational reality rather than
protocol mechanics alone.
Key Takeaway
Key Takeaway: Enterprise trust has expanded beyond
transport into identity, authorization, extensions, state, and evidence,
requiring broader governance.
Chapter 4 — Stateless Does Not Mean Simpler
One of the most widely discussed changes in the 2026-07-28 MCP
revision is the removal of protocol-managed sessions in favor of a
stateless communication model. At first glance, this appears to be a
familiar architectural evolution. Stateless protocols generally simplify
horizontal scaling, improve fault tolerance, reduce infrastructure
coupling and align well with modern cloud-native deployment models. The
official release notes explicitly describe the motivation in terms of
scalability, simplicity and implementation flexibility.
Viewed solely from an implementation perspective, these benefits are
substantial.
Viewed through the lens of operational assurance, however,
statelessness introduces a different question:
Where did the state go?
The answer is that it did not disappear.
It became explicit.
Rather than maintaining conversational or operational context within
the transport layer, the revised protocol expects applications and tools
to manage state directly through identifiers, resource references and
application-specific context. The release notes illustrate this with
examples such as basket_id and browser_id,
where the application—not the protocol—becomes responsible for
preserving and presenting the information necessary to continue an
interaction.
This architectural change is more significant than replacing one
implementation strategy with another. It changes where organizations
must establish governance, preserve evidence and demonstrate operational
control.
From Implicit to Explicit State
Earlier implementations often treated protocol sessions as the
mechanism that linked related operations together.
Conceptually:
Figure 2. Professional publication figure to be
inserted during production.
The transport layer implicitly carried continuity.
The revised architecture instead encourages explicit continuity.
Figure 3. Professional publication figure to be
inserted during production.
The transport no longer owns operational context.
Applications do.
This distinction appears subtle.
Operationally, it is not.
Explicit State Governance
The movement of state from the protocol layer into
application-managed context creates a new governance responsibility.
ODA3 refers to this responsibility as Explicit State
Governance.
Definition
Explicit State Governance is the disciplined
management, protection, validation and evidentiary preservation of
application-managed operational state after responsibility for
continuity has moved outside the transport protocol.
The objective is not merely to retain state.
It is to ensure that state remains:
Why This Matters
When protocol-managed sessions disappear, several operational
questions become the responsibility of the implementing
organization.
State Ownership
Which component owns operational continuity?
The application?
The orchestration layer?
The tool?
A workflow engine?
Ownership must now be explicit.
State Integrity
How is application-managed state protected against:
tampering;
replay;
substitution;
corruption;
unintended reuse?
Transport-level assumptions no longer provide these guarantees.
State Lifecycle
How long should state exist?
When is it archived?
When is it deleted?
Who authorizes lifecycle changes?
These become governance decisions rather than protocol behaviors.
State Recovery
If an application fails during a long-running workflow:
Can operational context be reconstructed?
Can execution resume safely?
Can investigators determine precisely what happened?
Recovery increasingly depends on application design rather than
transport semantics.
ODA3 Insight
Stateless protocols do not eliminate operational
state.
They require organizations to govern state explicitly rather than
inheriting continuity from the transport layer.
That distinction changes the assurance problem.
The question is no longer:
Does the protocol maintain state?
It becomes:
Can the organization demonstrate that application-managed state
remains trustworthy throughout its lifecycle?
Operational Implications
The migration toward explicit state affects multiple disciplines.
Enterprise Architecture
Architects must determine where operational context resides and how
trust is maintained across distributed components.
Identity Teams
State identifiers must be associated with authenticated identities
and authorization decisions rather than existing independently.
Security Operations
Monitoring systems must correlate activities across explicit
identifiers instead of relying on session identifiers created by the
protocol.
Incident Response
Forensic reconstruction must preserve:
state identifiers;
authorization context;
tool invocations;
execution history;
state transitions.
These become essential evidence.
Governance
Operational state itself becomes a governed information asset.
Policies should define:
ownership;
classification;
retention;
destruction;
audit requirements;
change management.
What This Does NOT Mean
Explicit State Governance should not be interpreted as criticism of
stateless architecture.
Stateless communication provides significant operational benefits and
is well established in distributed systems engineering.
The assurance observation is different.
Moving responsibility away from the transport layer necessarily
increases the importance of governance elsewhere in the
architecture.
The protocol has become simpler.
The organization’s operational responsibilities have not.
They have changed location.
Relationship to Trust Boundary Migration
The previous chapter argued that enterprise trust has migrated beyond
the transport layer.
Explicit State Governance explains one concrete example of that
migration.
Previously:
Transport
↓
Continuity
↓
Trust
Now:
Application
↓
Explicit State
↓
Identity
↓
Authorization
↓
Evidence
↓
Trust
This demonstrates that Trust Boundary Migration is not an abstract
architectural concept.
It produces measurable governance responsibilities.
ODA3 Operational Assurance Questions
Organizations deploying MCP should be able to answer:
Which component owns application state?
How is state integrity protected?
How is state linked to identity?
Can state transitions be independently audited?
Can workflows be reconstructed after interruption?
How long is state retained?
Can investigators distinguish valid state from replayed or
fabricated state?
What evidence demonstrates these controls operate
effectively?
These questions extend beyond protocol compliance.
They address operational assurance.
Notably Absent
The MCP specification intentionally defines protocol behavior rather
than enterprise governance.
Consequently, it does not prescribe:
state-classification policies;
retention periods;
evidence requirements;
forensic procedures;
audit models;
replay detection mechanisms;
operational ownership;
business approval workflows.
These remain implementation responsibilities and should be
established through organizational governance rather than assumed from
protocol conformance.
Transition to Chapter 5
The removal of protocol sessions relocates operational continuity
into the application layer.
The next architectural transition is even more significant.
As the protocol strengthens its authorization model and aligns more
closely with OAuth 2.0 and OpenID Connect, identity ceases to be
a supporting capability and becomes a defining architectural
dependency.
That evolution fundamentally changes how enterprise AI systems
establish trust, delegate authority and demonstrate operational
accountability.
The next chapter therefore examines Identity Becomes
Architecture, exploring why authentication and authorization
are no longer peripheral security controls but foundational components
of MCP’s enterprise deployment model. The previous chapters
established:
MCP is evolving into operational infrastructure.
Trust boundaries have migrated.
Statelessness relocates operational responsibility.
This chapter explains why identity is now the architectural
foundation.
This is not simply an OAuth discussion.
This is about the architectural evolution of enterprise AI.
Key Takeaway
Key Takeaway: Stateless communication shifts
responsibility for continuity and evidence to the application layer; it
does not eliminate operational state.
Chapter 5 — Identity Becomes Architecture
Enterprise software has historically treated identity as a security
service.
Applications authenticated users.
Authorization systems evaluated permissions.
Protocols transported requests.
These responsibilities were conceptually distinct.
The 2026-07-28 MCP revision begins to blur those boundaries.
Strengthened alignment with OAuth 2.0 and OpenID Connect, issuer
validation, improved client registration and more explicit authorization
behavior indicate that identity is no longer merely protecting the
protocol.
Identity increasingly defines how the protocol itself
operates.
This distinction represents a significant architectural
transition.
The protocol is no longer simply carrying authenticated requests
between systems.
It increasingly assumes that identity is established, propagated,
validated and maintained throughout the operational lifecycle.
That assumption changes where enterprise trust begins.
Identity Is No Longer an Edge Control
Many enterprise architectures still visualize identity as something
that happens before work begins.
Conceptually:
Figure 4. Professional publication figure to be
inserted during production.
Authentication functions as the entry gate.
Once authenticated, subsequent operations often inherit that
trust.
Modern AI systems challenge this assumption.
Agentic workflows may:
invoke multiple tools;
execute across different services;
operate for extended periods;
trigger delegated actions;
invoke downstream MCP servers;
interact across organizational boundaries.
The identity question therefore changes.
Instead of asking:
Who authenticated?
Organizations increasingly need to ask:
Which identity initiated this action?
Which identity is executing now?
Has authority changed?
Is delegation still valid?
Can every action be attributed?
Can every authorization decision be reconstructed?
Identity becomes continuous rather than transactional.
Identity Continuity
This paper introduces a second analytical observation.
Identity continuity becomes more important than
authentication events.
Authentication establishes identity once.
Operational assurance requires identity to remain attributable
throughout execution.
Consider a long-running AI workflow.
Figure 5. Professional publication figure to be
inserted during production.
At every transition, organizations must understand:
whose authority is being exercised;
whether delegation remains valid;
whether authorization has changed;
whether evidence exists for later investigation.
Identity therefore becomes part of operational continuity rather than
simply access control.
Identity Propagation Is an Assurance Problem
The revised specification strengthens identity and authorization
mechanisms.
That improves protocol consistency.
It does not automatically demonstrate that identity remains
trustworthy throughout implementation.
For enterprise deployments, the assurance question becomes:
Can identity be followed across the complete operational
path?
That requires evidence showing:
authentication;
delegation;
authorization;
propagation;
consumption;
revocation.
Missing evidence at any point creates uncertainty about operational
accountability.
ODA3 Insight
Authentication proves who entered the system.
Operational assurance must prove whose authority was
exercised throughout the system.
Those are different questions.
Only the second answers post-incident accountability.
Authorization Becomes Operational
Traditional authorization often occurs at the beginning of a
request.
Agentic AI increasingly requires authorization throughout
execution.
Examples include:
tool invocation;
resource access;
extension activation;
application interaction;
long-running tasks;
delegated workflows.
Authorization therefore evolves from a point-in-time decision into an
operational process.
Organizations should be capable of demonstrating:
why access was granted;
which authority permitted it;
when authority changed;
how delegated authority was constrained;
when authority expired;
how authorization decisions were recorded.
This is considerably broader than verifying that an access token
existed.
Identity-Centric Trust
One architectural pattern emerges repeatedly across the specification
changes.
Earlier protocol generations primarily trusted:
connections.
The revised architecture increasingly trusts:
identities.
That transition shifts enterprise security away from transport
assumptions toward continuously validated identities operating across
distributed systems.
Consequently, protocol security increasingly depends on the
surrounding identity architecture.
The protocol can transport identity.
It cannot establish enterprise trust by itself.
Operational Consequences
Enterprise Architects
Identity architecture now influences protocol architecture.
Identity services can no longer be designed independently of MCP
deployments.
Identity & IAM Teams
Delegation, token lifecycle, client registration, issuer validation
and authorization evidence become operational rather than purely
administrative concerns.
Security Operations
Incident investigations require correlation across:
identities;
tokens;
protocol messages;
tool executions;
workflow transitions.
Transport logs alone are insufficient.
Governance
Identity governance extends beyond user lifecycle management.
It now includes:
AI agents;
applications;
protocol clients;
extensions;
delegated execution;
machine identities.
Relationship to Trust Boundary Migration
The previous chapter demonstrated that enterprise trust has migrated
beyond the transport layer.
Identity explains where much of that trust now
resides.
Trust increasingly depends upon:
Identity
↓
Authorization
↓
Delegation
↓
Operational Evidence
↓
Accountability
rather than merely encrypted protocol communication.
ODA3 Operational Assurance Questions
Organizations deploying MCP should be able to demonstrate:
How identities are established.
How identities are propagated across workflows.
How delegated authority is constrained.
How authorization changes are recorded.
How revocation affects active operations.
How machine identities are governed.
How investigators reconstruct identity chains after an
incident.
Which evidence demonstrates these controls remain
effective.
Notice that none of these questions can be answered solely by reading
the protocol specification.
They require organizational governance and operational evidence.
What This Does NOT Mean
This analysis should not be interpreted as suggesting that MCP
replaces enterprise IAM platforms or authorization infrastructure.
The specification provides standardized mechanisms for integrating
with established identity systems.
Organizations remain responsible for:
identity proofing;
credential governance;
privileged access management;
role design;
segregation of duties;
machine identity lifecycle;
business authorization policies;
continuous monitoring.
Protocol conformance is therefore necessary for
interoperability.
It is not sufficient for operational assurance.
ODA3 Definition
Identity Continuity
Identity Continuity is the capability to establish,
preserve, validate and reconstruct the identity under which authority is
exercised throughout a complete operational workflow, including
delegation, transitions between services, long-running execution and
post-incident investigation.
Identity Continuity complements authentication.
It does not replace it.
Transition to Chapter 6
Identity establishes who may exercise authority.
The next architectural question is equally important:
What capabilities are introduced into the trust boundary
after deployment?
The structured extension framework introduced in the 2026-07-28
revision significantly expands how MCP evolves over time. That
flexibility is a major strength, but it also introduces new governance
responsibilities around provenance, lifecycle, compatibility and
operational risk.
The next chapter therefore examines Extension
Assurance, arguing that extensions should be governed with the
same discipline organizations already apply to software dependencies and
supply-chain components—not because the specification requires it, but
because enterprise operational assurance increasingly depends on it.
Key Takeaway
Key Takeaway: Identity is no longer a supporting
control but a core architectural dependency for protocol-enabled AI
systems.
Chapter 6 — Extension Assurance
One of the most significant architectural developments in the
2026-07-28 revision is the formal introduction of an extension framework
that allows the Model Context Protocol to evolve without requiring every
new capability to become part of the core specification. This approach
provides a structured mechanism for introducing new functionality while
preserving interoperability and maintaining stability in the protocol
itself.
From a protocol engineering perspective, this is a well-established
strategy. Mature protocols frequently separate a stable core from
extensible capabilities to encourage innovation while reducing the need
for disruptive specification revisions.
From an enterprise assurance perspective, however, extensibility
introduces a different challenge.
Every extension represents new operational capability
entering an established trust environment.
That capability may influence identity, authorization, data access,
workflow execution or interactions with external systems.
Consequently, the question is no longer simply whether an extension
is technically compatible.
The more important question becomes:
Can the organization demonstrate that the extension deserves
to be trusted?
Extensions Become Governance Objects
Earlier MCP deployments primarily evaluated trust through protocol
conformance.
The revised architecture expands that responsibility.
Organizations must increasingly evaluate:
Trust therefore expands beyond the protocol itself.
Conceptually, enterprise governance evolves from:
Figure 6. Professional publication figure to be
inserted during production.
to:
Figure 7. Professional publication figure to be
inserted during production.
The protocol remains stable.
Operational capability continues evolving.
Governance must evolve with it.
Why Extensions Matter Operationally
Extensions are not merely software modules.
They may introduce:
new authorization flows;
additional tools;
different execution models;
richer user interaction;
alternative data sources;
expanded protocol semantics;
integration with enterprise infrastructure.
Each of these changes can alter an organization’s operational risk
profile.
Consequently, extension governance should be considered part of
enterprise architecture rather than a deployment convenience.
ODA3 Definition
Extension Assurance
Extension Assurance is the continuous evaluation and
governance of protocol extensions to establish that their origin,
integrity, operational behavior, lifecycle and security characteristics
remain consistent with the organization’s trust requirements throughout
deployment and change.
Extension Assurance focuses on operational trust rather than
functional compatibility.
An extension that functions correctly may still introduce
unacceptable governance or operational risk.
Compatibility Is Not Trust
Protocol compatibility answers one question:
Can this extension interoperate?
Operational assurance asks different questions:
Who developed it?
Who maintains it?
How is it versioned?
What operational capability does it introduce?
Which enterprise systems can it affect?
Which identities may invoke it?
How is it monitored?
How is it removed?
What evidence demonstrates continued trust?
These questions cannot be answered through protocol negotiation
alone.
They require governance.
Extension Lifecycle
From an assurance perspective, every extension should have a governed
lifecycle.
Figure 8. Professional publication figure to be
inserted during production.
The protocol defines how an extension is recognized.
The organization determines whether it should be trusted.
Extension Provenance
Enterprise deployments should establish confidence in:
This resembles software supply-chain governance.
The important distinction is that extensions influence
operational behavior, not merely executable code.
Their governance should therefore include both technical validation
and operational review.
ODA3 Insight
Protocol extensibility accelerates innovation.
Operational assurance determines whether that innovation
should be trusted in production.
The protocol enables capability.
Governance determines acceptability.
Operational Consequences
Enterprise Architects
Extension architecture should become part of system architecture
documentation rather than remaining an implementation detail.
Security Teams
Every new extension should be evaluated for:
Governance Teams
Organizations should establish:
Incident Response
Investigations should capture:
Without this evidence, investigators may be unable to determine
whether observed behavior originated from the protocol core or an
extension.
Relationship to Trust Boundary Migration
Trust Boundary Migration demonstrated that enterprise trust has moved
beyond protocol transport.
Extensions further expand that movement.
Every extension potentially enlarges the operational trust
boundary.
The question therefore changes from:
Does the protocol support this capability?
to
Should this capability become part of our trusted operational
environment?
That is a governance decision.
Not a protocol decision.
ODA3 Operational Assurance Questions
Organizations should be capable of demonstrating:
Which extensions are approved?
Who approved them?
Which operational capabilities do they introduce?
Which identities may invoke them?
How are updates governed?
How is extension provenance verified?
How is operational behavior monitored?
How can extensions be isolated or removed?
What evidence demonstrates continued trustworthiness?
These questions move beyond interoperability into operational
assurance.
What This Does NOT Mean
The MCP extension framework should not be interpreted as inherently
increasing enterprise risk.
A structured extension mechanism can improve interoperability, reduce
fragmentation and enable controlled evolution.
The assurance observation is different.
As extensibility increases, so does the need for disciplined
governance.
Organizations should therefore distinguish between:
protocol capability;
implementation quality;
operational trust.
The protocol can standardize the first.
The organization remains responsible for the latter two.
Transition to Chapter 7
The previous chapters have established a consistent architectural
pattern:
Trust has migrated.
State has become explicit.
Identity has become foundational.
Extensions require governance.
These are not isolated observations.
They are manifestations of a broader transition.
The next chapter introduces the paper’s central unifying concept:
Chapter 7 — Protocol Assurance
The preceding chapters demonstrate a consistent architectural
pattern.
The 2026-07-28 revision does not merely introduce new protocol
capabilities.
It redistributes operational responsibility.
State moves from transport into applications.
Identity becomes integral to protocol operation.
Authorization becomes continuous rather than transactional.
Extensions become independently governed operational
capabilities.
Protocol evolution becomes part of enterprise lifecycle
management.
Taken together, these observations point toward a broader
conclusion.
Modern interoperability protocols should no longer be evaluated
solely through implementation correctness.
They must also be evaluated through operational
assurance.
This paper refers to that discipline as Protocol
Assurance.
ODA3 Definition
Protocol Assurance
Protocol Assurance is the continuous demonstration
that protocol implementations, operational behaviors, identities,
authorization decisions, extensions and governance processes
collectively preserve the security, integrity, accountability and
intended operational properties of a protocol throughout its
lifecycle.
Protocol Assurance extends beyond specification conformance.
It asks whether organizations can produce evidence demonstrating that
protocol-enabled operations remain trustworthy under realistic
operational conditions.
From Compliance to Confidence
Traditional protocol evaluation often follows this progression.
Figure 9. Professional publication figure to be
inserted during production.
Enterprise assurance requires an additional layer.
Figure 10. Professional publication figure to be
inserted during production.
This additional layer is where organizations demonstrate—not merely
assume—that protocol-enabled operations continue to behave as
intended.
The Assurance Question
Traditional protocol engineering asks:
Does the implementation conform to the
specification?
Protocol Assurance asks:
Can the organization continuously demonstrate that the
implementation remains trustworthy throughout operation, change, failure
and recovery?
Those questions complement one another.
They do not compete.
Assurance Evidence
Evidence supporting Protocol Assurance should extend beyond protocol
traces.
Organizations should be capable of demonstrating:
Identity Evidence
identity establishment;
delegated authority;
token lifecycle;
revocation events.
Authorization Evidence
authorization decisions;
policy evaluations;
privilege changes;
approval workflows.
Operational Evidence
workflow execution;
state transitions;
task completion;
interruption;
recovery.
Extension Evidence
approved versions;
provenance;
lifecycle history;
operational activation.
Monitoring Evidence
telemetry;
alerts;
distributed traces;
anomaly detection.
None of these evidence categories are created automatically by
protocol conformance.
They result from enterprise operational governance.
ODA3 Insight
Protocols define how systems communicate.
Protocol Assurance demonstrates that those communications
remain trustworthy throughout operation.
The distinction appears subtle.
Operationally, it is profound.
Protocol Assurance Is Continuous
One common misconception is that assurance occurs before
deployment.
Modern AI systems invalidate that assumption.
Protocol behavior evolves through:
software updates;
extension deployment;
authorization changes;
identity changes;
infrastructure changes;
policy revisions;
operational growth.
Consequently, assurance must become continuous.
Organizations should periodically re-evaluate:
Assurance therefore becomes an operational capability rather than a
deployment milestone.
Operational Consequences
Enterprise Architects
Protocol selection should include assurance planning.
Architecture reviews should identify:
Security Teams
Protocol deployments should receive the same operational validation
applied to:
identity systems;
API gateways;
cloud platforms;
privileged services.
Governance Teams
Protocol changes should enter formal change-management processes.
Major protocol revisions should trigger:
architectural review;
operational assessment;
assurance validation;
documentation updates.
Incident Response
Incident investigations should preserve:
protocol version;
extension inventory;
authorization context;
identity chain;
distributed traces;
application state;
workflow history.
These artefacts collectively establish operational evidence.
Relationship to GAISSF™
GAISSF™ emphasizes that controls should be supported by demonstrable
evidence rather than policy statements alone.
Protocol Assurance applies that same principle to protocol
ecosystems.
Organizations should not ask only:
Do we use MCP?
They should also ask:
What evidence demonstrates that our MCP deployment continues
to operate within its intended security and governance
boundaries?
Relationship to UAIF™
UAIF™ provides the structure for recording protocol-related
incidents.
Incident records should distinguish:
protocol behavior;
implementation behavior;
extension behavior;
identity behavior;
authorization behavior;
infrastructure behavior.
Separating these dimensions improves causal analysis and corrective
actions.
Relationship to AI-IRF™
AI-IRF™ provides the operational lifecycle.
Protocol Assurance strengthens:
Preparation
↓
Detection
↓
Analysis
↓
Containment
↓
Recovery
↓
Lessons Learned
by ensuring that sufficient evidence exists to reconstruct
protocol-enabled activity throughout an incident.
What This Does NOT Mean
Protocol Assurance should not be interpreted as proposing
certification of the MCP specification itself.
Nor does it imply that protocol conformance lacks value.
Rather, it recognizes that enterprise deployments introduce
operational behaviors extending beyond specification requirements.
Protocol Assurance therefore evaluates the deployment of a protocol
within an operational environment—not the protocol specification in
isolation.
ODA3 Operational Assurance Questions
Organizations should be capable of answering:
Can protocol-enabled workflows be reconstructed?
Can every authorization decision be explained?
Can every extension be attributed?
Can operational state be validated?
Can protocol changes be governed?
Can trust boundaries be demonstrated?
Can investigators reproduce protocol activity using retained
evidence?
Can the organization prove—not merely assume—that
protocol-enabled operations remain trustworthy?
Those questions define Protocol Assurance.
Transition to Chapter 8
The previous chapters introduced four connected ideas:
Protocol Assurance unifies them conceptually.
The next chapter translates those concepts into an enterprise
operating model.
Rather than discussing individual protocol mechanisms, it introduces
the Operational Protocol Stack—a reference model
showing where governance, identity, authorization, protocol behavior,
extensions, execution, observability and operational assurance interact
throughout an MCP deployment.
Enterprise AI Protocol Assurance Stack (EAPAS)
Why?
Because:
It immediately communicates enterprise scope.
It is protocol-agnostic (future A2A, ACP, OpenAPI,
etc.).
It sounds like a reusable reference architecture rather than an
MCP diagram.
It can later become a GAISSF™ reference architecture.
Chapter 8 — Enterprise AI Protocol Assurance Stack
The preceding chapters have examined individual architectural
transitions introduced by the 2026-07-28 MCP revision.
Taken together, these changes reveal a broader reality.
Enterprise AI deployments are no longer governed by a single protocol
layer.
Instead, operational trust emerges from multiple architectural layers
that collectively determine whether protocol-enabled interactions remain
secure, accountable and governable throughout their lifecycle.
This paper refers to this layered view as the Enterprise AI
Protocol Assurance Stack (EAPAS).
The purpose of the stack is not to describe software
architecture.
Its purpose is to identify where organizations must establish
operational trust and what evidence demonstrates that trust remains
justified.
Enterprise AI Protocol Assurance Stack
Figure 11. Professional publication figure to be
inserted during production.
Why This Stack Exists
Traditional protocol diagrams answer:
How do systems communicate?
The Enterprise AI Protocol Assurance Stack answers:
Where does enterprise trust need to exist?
These are fundamentally different questions.
Communication diagrams optimize interoperability.
Assurance architectures optimize operational confidence.
Layer 1 — Enterprise Governance
Governance establishes:
acceptable use;
accountability;
ownership;
change management;
operational risk;
compliance objectives.
Without governance, technical controls lack organizational
context.
Layer 2 — Business Policy
Business policy determines:
what the AI system is permitted to do;
which business processes it may affect;
what approvals are required;
which data may be accessed.
Protocols cannot define business authorization.
Organizations must.
Layer 3 — Identity & Trust
Identity establishes:
This chapter intentionally separates identity from authorization.
They solve different problems.
Layer 4 — Authorization & Delegation
Authorization determines:
permitted actions;
delegated authority;
scope;
duration;
constraints;
approval.
The protocol transports these decisions.
It does not create them.
Layer 5 — AI Protocol
This is where MCP resides.
Its responsibilities include:
interoperability;
message exchange;
capability negotiation;
protocol semantics;
compatibility.
Importantly:
The protocol is only one layer.
Not the architecture.
Layer 6 — Extensions
Extensions modify operational capability.
They therefore require:
Extension Assurance applies here.
Layer 7 — Applications & Agent Runtime
Applications determine:
orchestration;
planning;
memory;
execution;
retries;
workflow logic.
Many operational failures attributed to protocols actually originate
here.
Layer 9 — Enterprise Data & Services
Operational trust ultimately depends upon:
data quality;
classification;
integrity;
confidentiality;
availability.
No protocol can compensate for poor enterprise data governance.
Layer 10 — Observability & Evidence
Perhaps the most overlooked layer.
Organizations should retain evidence supporting:
protocol interactions;
authorization;
identity;
extension behavior;
state transitions;
workflow execution;
operational decisions.
This layer enables both incident response and assurance.
Layer 11 — Operational Assurance
Operational Assurance integrates every preceding layer.
It asks:
Can the organization continuously demonstrate that the enterprise AI
ecosystem continues operating within its intended security, governance
and operational boundaries?
Notice:
Operational Assurance is not another layer of
software.
It is an organizational capability.
ODA3 Insight
Enterprise trust does not reside in the
protocol.
It emerges from the interactions between governance,
identity, authorization, operational behavior and evidence.
This is perhaps the single most important observation in the
paper.
Relationship to GAISSF™
The Enterprise AI Protocol Assurance Stack aligns naturally with
GAISSF™.
GAISSF™ defines what controls organizations should
establish.
The stack illustrates where those controls operate
within protocol-enabled AI ecosystems.
Rather than replacing GAISSF™, it provides a reference architecture
through which governance controls, operational evidence and assurance
activities can be understood in context.
Relationship to UAIF™
UAIF™ incident records should preserve evidence across multiple
layers of the stack, distinguishing failures in:
Treating every issue as a generic “protocol incident” obscures the
true root cause and weakens corrective action.
Relationship to AI-IRF™
AI-IRF™ operational activities should be mapped to the stack.
Preparation begins with governance and identity.
Detection relies on observability.
Analysis reconstructs state across protocol interactions.
Containment may occur at the identity, extension, runtime or
enterprise service layers.
Recovery restores trusted operation while preserving evidence.
Lessons learned improve governance across the entire stack.
This layered view reinforces that incident response for
protocol-enabled AI systems extends well beyond transport-level
troubleshooting.
What This Does NOT Mean
The Enterprise AI Protocol Assurance Stack is not an
alternative architecture for MCP, nor is it a replacement for the
protocol specification.
It is an analytical model that helps organizations identify where
operational trust must be established, maintained and evidenced when
deploying AI interoperability protocols.
It is intentionally protocol-agnostic and should remain applicable as
additional AI protocols emerge.
Transition to Chapter 9
The Enterprise AI Protocol Assurance Stack provides a reference model
for understanding protocol-enabled AI ecosystems.
The next question is practical:
How should existing governance frameworks
respond?
The following chapter maps the architectural observations developed
throughout this paper to GAISSF™, demonstrating how
protocol evolution reinforces the need for evidence-driven governance
rather than introducing an entirely new control framework.
Chapter 9 — Implications for Enterprise AI Governance
(GAISSF™ Perspective)
The architectural observations developed throughout this paper do not
suggest that organizations require a new governance framework
specifically for MCP.
Rather, they demonstrate that modern AI interoperability protocols
increasingly depend upon governance disciplines that extend beyond
protocol specifications.
The 2026-07-28 revision illustrates this clearly.
Identity becomes architectural.
Authorization becomes continuous.
Operational state becomes explicit.
Extensions require lifecycle governance.
Trust boundaries expand beyond transport.
None of these responsibilities originate solely from the
protocol.
They emerge from enterprise deployment.
Consequently, organizations should resist treating protocol adoption
as a software integration project alone.
Protocol adoption increasingly becomes an operational governance
activity.
This observation aligns closely with the principles underlying
evidence-driven AI governance.
Governance Does Not Begin at the Protocol
One recurring misconception in enterprise AI deployments is that
governance begins when technical controls are configured.
Operational experience suggests otherwise.
Governance begins considerably earlier.
Organizations establish:
acceptable use;
accountability;
ownership;
authority;
operational objectives;
evidence expectations;
change management.
Only then are technical controls configured to support those
decisions.
The protocol therefore operates within governance,
rather than replacing it.
Evidence Rather Than Assumption
Several themes recur throughout this paper:
All four concepts share a common characteristic.
They require evidence.
For example:
It is insufficient to state that:
identities are governed;
authorization exists;
extensions are approved;
workflows are monitored.
Organizations should be capable of demonstrating these claims through
operational evidence.
That distinction mirrors the broader philosophy of evidence-driven
assurance.
Relationship to GAISSF™
GAISSF™ emphasizes that governance controls should be demonstrable
rather than declarative.
The observations developed throughout this paper reinforce that
philosophy.
For example:
Identity
The question is not:
“Does identity exist?”
The operational question becomes:
“Can identity be demonstrated throughout protocol-enabled
execution?”
Authorization
The question is not:
“Is authorization supported?”
The question becomes:
“Can authorization decisions be reconstructed, explained and
independently verified?”
Operational State
Rather than asking:
“Is state maintained?”
Organizations increasingly need to demonstrate:
Extensions
Organizations should distinguish:
Protocol compatibility
from
Operational trust.
Approval records, provenance, monitoring and lifecycle governance
become operational evidence.
Protocol Evolution
Protocol upgrades should trigger:
architectural review;
governance assessment;
operational validation;
assurance review.
Successful protocol deployment therefore becomes an ongoing
governance activity rather than a one-time implementation project.
ODA3 Insight
Enterprise governance should validate operational behavior,
not simply protocol capability.
Protocol capability answers:
What can the system do?
Governance answers:
Under what authority?
Operational Assurance answers:
What evidence demonstrates that it continues to operate within those
authorized boundaries?
Those questions are complementary.
They should never be treated as interchangeable.
Operational Governance Questions
Organizations adopting MCP should periodically review:
Identity
Are machine identities governed?
Is delegated authority reviewed?
Can identity propagation be demonstrated?
Authorization
Are authorization decisions attributable?
Can delegated permissions be reconstructed?
Are authorization failures monitored?
Change
How are protocol revisions reviewed?
Are extensions reassessed after updates?
Is operational documentation maintained?
These questions are implementation-specific.
The protocol itself intentionally leaves them to the deploying
organization.
Relationship to Operational Assurance
The purpose of governance is not merely to establish policy.
Its purpose is to enable assurance.
Without governance:
Operational Assurance cannot determine:
ownership;
accountability;
authority;
operational intent.
Conversely:
Without operational evidence,
Governance cannot demonstrate that policy continues to function in
practice.
The two disciplines reinforce one another.
What This Does NOT Mean
This analysis should not be interpreted as recommending new
governance requirements unique to MCP.
Many of the observations discussed in this paper apply equally
to:
The significance of the 2026-07-28 revision is that it makes these
governance dependencies substantially more visible within AI
infrastructure.
ODA3 Observation
One broader trend becomes apparent.
As AI infrastructure matures,
protocol specifications are increasingly converging toward enterprise
architecture.
Enterprise governance must therefore evolve alongside protocol
engineering.
This convergence is likely to continue as agentic AI systems become
more distributed, autonomous and operationally significant.
Organizations that separate protocol engineering from governance may
find it increasingly difficult to demonstrate operational trust as these
ecosystems grow in complexity.
Transition to Chapter 10
The governance implications are now established.
The next question is operational:
How should incident response change?
The following chapter examines the implications for
UAIF™ and AI-IRF™, exploring how
protocol-aware evidence collection, incident classification and
operational response should evolve as AI interoperability protocols
become foundational components of enterprise AI ecosystems.
Part I — Understanding the Architectural Shift
Part II — Operationalizing Trust
That structural break will make a 3,500–4,000-word paper feel much
more readable. It also mirrors the flow ODA3 has established in its
strongest publications: first establish the evidence and analytical
model, then translate those findings into governance, operations and
assurance guidance.
Operationalizing Trust
Part II — Operationalizing Trust
Chapter 10 — Incident Readiness for AI Interoperability
Protocols
(UAIF™ Perspective)
The preceding chapters examined how the 2026-07-28 MCP revision
changes protocol architecture, enterprise trust boundaries and
operational governance.
Those observations become most consequential during security
incidents.
Enterprise AI deployments increasingly consist of distributed
workflows involving AI applications, protocol exchanges, multiple
authorization decisions, extensions, external tools and enterprise
services. Consequently, incidents occurring within these environments
are unlikely to originate from a single component or produce evidence
within a single system.
The protocol therefore becomes one participant in a broader
operational chain.
Successful incident investigation depends not on protocol logs alone,
but on reconstructing interactions across identities, authorization
decisions, application-managed state, extensions, downstream tools and
enterprise infrastructure.
This fundamentally changes incident readiness.
From Event Logging to Operational Reconstruction
Traditional application investigations often begin with a sequence of
events.
Figure 12. Professional publication figure to be
inserted during production.
Protocol-enabled AI ecosystems rarely remain this simple.
Operational reconstruction increasingly resembles:
Figure 13. Professional publication figure to be
inserted during production.
Each transition represents a potential evidentiary boundary.
Investigators who collect evidence from only one layer may
reconstruct only a partial sequence of events.
The Protocol Is Evidence
One of the most important operational changes introduced by mature AI
interoperability protocols is that protocol interactions become
investigative artefacts in their own right.
Historically, protocols primarily transported data.
Investigators focused on:
application logs;
operating systems;
databases;
network captures.
Increasingly, protocol exchanges themselves become valuable evidence
because they reveal:
This represents an expansion of enterprise forensic scope rather than
a replacement for traditional evidence sources.
ODA3 Observation
An AI protocol exchange should not be viewed merely as a
communication record.
It is increasingly an operational decision
record.
That distinction becomes particularly important when AI systems
coordinate multiple downstream actions on behalf of users or
organizations.
Protocol-Aware Incident Reconstruction
Organizations should be capable of reconstructing:
Identity Chain
Who initiated activity?
Which identities acted?
Which authority was delegated?
Did authority change during execution?
Authorization Chain
Which authorization decisions enabled each action?
Were policy decisions recorded?
Were permissions modified?
Did authorization expire?
State Chain
Which operational state identifiers existed?
How did state evolve?
Was state modified?
Was state recovered?
Can state transitions be demonstrated?
Extension Chain
Which extensions participated?
Which versions?
Were they approved?
Were updates applied?
Did extensions alter operational behavior?
ODA3 Insight
AI incidents rarely occur within a single
system.
They unfold across chains of delegated authority, distributed
execution and protocol-mediated interactions.
Incident readiness should therefore focus on reconstructing those
chains rather than collecting isolated logs.
Relationship to UAIF™
UAIF™ emphasizes structured incident recording that separates:
initiating event;
contributing factors;
operational impacts;
governance observations;
corrective actions.
Protocol-enabled AI systems reinforce this approach.
Incident records should distinguish between:
Protocol Behavior
Was the protocol functioning according to specification?
Implementation Behavior
Did the implementation behave correctly?
Identity Behavior
Were identities correctly established?
Were delegated identities valid?
Authorization Behavior
Were authorization decisions correct?
Were permissions excessive?
Were policies bypassed?
Extension Behavior
Did an extension influence the outcome?
Was extension provenance established?
Was lifecycle governance followed?
Enterprise Behavior
Did downstream business systems contribute?
Were business policies correctly enforced?
This separation improves root-cause analysis and reduces the risk of
attributing every failure to the protocol itself.
Evidence Preservation
Organizations should preserve evidence capable of reconstructing:
protocol version;
implementation version;
extension inventory;
extension versions;
workflow identifiers;
state identifiers;
authorization decisions;
identity transitions;
tool invocations;
enterprise responses;
timestamps;
distributed traces.
The objective is not maximum data collection.
It is sufficient evidence to reproduce the operational sequence.
ODA3 Operational Assurance Questions
Following a protocol-enabled incident, organizations should be able
to answer:
Which identity initiated the workflow?
Which authority was exercised?
Which protocol version was deployed?
Which extensions participated?
Which application-managed state existed?
Which downstream systems were affected?
Can the workflow be reconstructed end-to-end?
Which evidence supports every conclusion reached during the
investigation?
If these questions cannot be answered, the investigation is likely to
rely on inference rather than demonstrable evidence.
What This Does NOT Mean
Protocol-aware incident readiness does not require organizations to
retain every protocol message indefinitely.
Nor does it suggest that protocol logs alone are sufficient for
forensic investigation.
The objective is proportional evidence collection that enables
reconstruction of material operational events while respecting legal,
privacy and organizational requirements.
Evidence strategies should therefore be determined through risk
assessment, governance obligations and applicable regulatory
requirements rather than protocol capabilities alone.
ODA3 Observation
As AI interoperability protocols become foundational enterprise
infrastructure, incident response evolves from system-centric
investigation toward workflow-centric
reconstruction.
The protocol is no longer simply part of the technical
environment.
It becomes part of the evidentiary environment.
That distinction is likely to become increasingly important as
organizations deploy more autonomous, multi-agent and distributed AI
systems.
Transition to Chapter 11
Incident readiness addresses how organizations investigate
failures.
The next operational question is broader:
How should organizations prepare for those failures before
they occur?
The following chapter examines AI-IRF™ implications,
exploring how preparation, detection, analysis, containment, recovery
and lessons learned should evolve when AI systems increasingly depend on
protocol-mediated interactions, distributed execution and continuously
changing operational trust boundaries.
Chapter 11 — Operational Response in Protocol-Centric AI
Systems
(AI-IRF™ Perspective)
The previous chapter argued that mature AI interoperability protocols
change how organizations investigate incidents by expanding the
evidentiary chain beyond individual systems into distributed operational
workflows.
Preparation is equally affected.
Incident response plans developed for conventional software
applications often assume that authority, execution, state and
operational context remain largely confined to a single application or
service.
Protocol-enabled AI ecosystems challenge those assumptions.
Agentic workflows may traverse multiple applications, invoke numerous
enterprise tools, activate extensions, maintain application-managed
state and execute under delegated authority for extended periods.
Consequently, incident response should evolve from protecting
isolated systems toward preserving trusted operational workflows.
This transition has implications across every phase of the incident
response lifecycle.
Prepare
Preparation traditionally focuses on:
asset inventory;
logging;
monitoring;
playbooks;
communication plans.
Protocol-enabled AI systems require additional preparation.
Organizations should establish:
protocol inventory;
approved protocol versions;
extension inventory;
extension ownership;
identity architecture documentation;
delegated authority models;
protocol trust boundaries;
evidence retention strategy.
Preparation therefore becomes architectural rather than purely
procedural.
Detect
Detection becomes more complex because malicious or unintended
behavior may emerge from otherwise legitimate protocol interactions.
Indicators should include:
unexpected protocol capability negotiation;
unusual extension activation;
abnormal authorization patterns;
identity anomalies;
unexpected tool invocation chains;
excessive workflow duration;
unexpected state transitions.
Detection therefore shifts from identifying isolated technical events
toward recognizing abnormal operational behavior.
Analyze
Analysis now extends beyond protocol messages.
Investigators should reconstruct:
Root cause should distinguish:
protocol behavior;
implementation behavior;
operational governance;
human decision-making.
This distinction reduces incorrect attribution.
ODA3 Insight
The objective of analysis is not to identify where an
incident was observed.
It is to determine where operational trust first
failed.
The first observable symptom is not necessarily the originating
cause.
Contain
Containment in protocol-enabled AI ecosystems may occur at multiple
architectural layers.
Examples include:
Identity
Revoke delegated authority.
Suspend compromised machine identities.
Rotate credentials.
Authorization
Restrict protocol permissions.
Reduce authorization scope.
Temporarily disable delegated workflows.
Extensions
Disable specific extensions.
Rollback extension versions.
Isolate extension execution.
Applications
Suspend orchestration.
Pause long-running tasks.
Terminate active workflows.
Enterprise Services
Restrict downstream APIs.
Limit sensitive operations.
Protect critical business systems.
Containment therefore becomes targeted rather than universally
disruptive.
Organizations should seek to preserve legitimate operational activity
while isolating the affected trust boundary.
Recover
Recovery extends beyond restoring technical functionality.
Organizations should verify:
protocol version integrity;
identity trust;
authorization correctness;
extension status;
operational state consistency;
workflow continuity;
evidence completeness.
Successful recovery should restore both operational capability and
organizational confidence.
Learn
Every protocol-enabled incident should produce improvements across
multiple domains.
Architecture
Were trust boundaries correctly identified?
Governance
Were responsibilities clearly assigned?
Identity
Was delegated authority appropriate?
Authorization
Were authorization decisions sufficiently constrained?
Extensions
Were lifecycle controls effective?
Operational Evidence
Was sufficient evidence available?
Assurance
Could the organization demonstrate why it believed the deployment
remained trustworthy?
This final question is frequently overlooked.
It is often more valuable than asking why the incident occurred.
Protocol-Centric Response Model
Traditional response often resembles:
Figure 14. Professional publication figure to be
inserted during production.
Protocol-enabled ecosystems increasingly resemble:
Figure 15. Professional publication figure to be
inserted during production.
Notice that recovery is not the final step.
Operational Assurance validates that trust has actually been
restored.
ODA3 Observation
One architectural trend becomes increasingly apparent.
As AI ecosystems become more distributed, incident response gradually
shifts from system recovery toward trust
recovery.
Systems can often be restarted quickly.
Re-establishing confidence in delegated authority, operational state,
protocol interactions and evidence integrity may require considerably
longer.
Organizations should therefore distinguish between:
The second objective is ultimately more important.
Operational Readiness Checklist
Organizations deploying MCP or similar AI interoperability protocols
should be able to demonstrate:
Recovery
These questions focus on operational resilience rather than protocol
mechanics.
What This Does NOT Mean
This analysis should not be interpreted as requiring organizations to
create separate incident response processes exclusively for MCP.
Rather, existing incident response capabilities should evolve to
recognize protocol-enabled workflows, delegated authority, distributed
execution and application-managed state as integral components of
enterprise AI operations.
Organizations that already maintain mature incident response
capabilities can often extend those processes rather than replace
them.
Transition to Chapter 12
The previous chapters have examined architecture, governance,
incident investigation and operational response.
The remaining question is strategic:
What should enterprise leaders, architects and boards do
differently?
The next chapter translates the technical observations developed
throughout this paper into practical recommendations
for CISOs, Enterprise Architects, AI Governance Leads and Boards of
Directors. Rather than prescribing new standards, it identifies
governance actions that organizations should consider as AI
interoperability protocols become foundational elements of enterprise AI
infrastructure.
Chapter 12 — Enterprise Recommendations
The preceding chapters examined the architectural, governance and
operational implications of the 2026-07-28 MCP revision. Those
observations suggest that organizations should evaluate AI
interoperability protocols as enterprise infrastructure rather than
development conveniences.
The recommendations below do not constitute new protocol
requirements. Rather, they identify governance and operational practices
that organizations should consider as protocol-enabled AI ecosystems
become increasingly central to enterprise operations.
Recommendation 1
Treat AI Protocols as Enterprise Infrastructure
Organizations frequently evaluate interoperability protocols
primarily through developer productivity, implementation complexity or
ecosystem adoption.
These considerations remain important.
However, once protocols become responsible for coordinating identity,
authorization, operational workflows and enterprise tool invocation,
they assume characteristics traditionally associated with critical
infrastructure.
Accordingly, protocol adoption should receive the same architectural
governance applied to:
Protocol selection should therefore become an enterprise architecture
decision rather than solely a software engineering decision.
Recommendation 2
Govern Trust Boundaries Explicitly
The migration of trust identified throughout this paper means
organizations should no longer assume that protocol boundaries coincide
with enterprise trust boundaries.
Instead, organizations should explicitly document:
trust assumptions;
delegated authority;
identity propagation;
extension boundaries;
operational ownership.
Trust boundaries should become architectural artefacts subject to
regular review.
Recommendation 4
Establish Protocol Lifecycle Governance
Protocols evolve.
Extensions evolve.
Implementations evolve.
Organizations should establish governance covering:
Protocol evolution should become part of enterprise change management
rather than remaining an engineering activity alone.
Recommendation 5
Build Evidence Before Incidents Occur
Operational assurance depends upon evidence.
Evidence cannot usually be reconstructed after an incident has
already occurred.
Organizations should therefore determine in advance:
which operational evidence will be retained;
how identity will be reconstructed;
how authorization decisions will be preserved;
how workflow execution will be traced;
how protocol interactions will be correlated.
The objective is not exhaustive logging.
The objective is sufficient evidence to support governance,
investigation and operational assurance.
Recommendation 6
Govern Machine Identities with the Same Discipline as Human
Identities
Agentic AI increasingly exercises delegated authority through machine
identities.
These identities may invoke tools, retrieve information, coordinate
workflows and initiate downstream operations.
Organizations should therefore extend existing identity governance
practices to include:
AI applications;
AI agents;
protocol clients;
automated workflows;
extension services.
Machine identities should not become unmanaged operational
actors.
Recommendation 7
Evaluate Extensions as Operational Capability
Extensions should not be reviewed solely for technical
compatibility.
Organizations should assess:
operational impact;
privilege expansion;
business relevance;
lifecycle;
ownership;
monitoring;
retirement.
Extension approval should resemble governance applied to introducing
new enterprise capabilities rather than installing optional software
features.
Recommendation 8
Design Incident Response Around Workflows Rather Than Systems
AI interoperability protocols increasingly coordinate activities
across numerous enterprise systems.
Organizations should therefore prepare to reconstruct:
Workflow reconstruction provides more complete operational
understanding than isolated system analysis.
Recommendation 9
Review Protocol Changes as Governance Events
Major protocol revisions increasingly affect:
trust assumptions;
authorization models;
extension capabilities;
operational evidence;
enterprise architecture.
Consequently, protocol upgrades should trigger:
architectural review;
governance assessment;
operational validation;
assurance review.
Organizations should resist treating protocol revisions as routine
software updates.
Recommendation 10
Invest in Operational Assurance Capability
The most significant observation developed throughout this paper is
that protocol maturity increases governance responsibility.
Organizations should therefore invest not only in protocol adoption
but in the capability to demonstrate:
This capability ultimately determines whether protocol-enabled AI
systems remain trustworthy as they evolve.
ODA3 Insight
Organizations do not gain operational trust by deploying
modern AI protocols.
They gain operational trust by governing those protocols,
demonstrating their effectiveness and continuously validating the
assumptions on which those deployments depend.
This distinction summarizes the practical message of the paper.
What These Recommendations Are NOT
These recommendations should not be interpreted as:
implementation requirements;
protocol certification criteria;
regulatory obligations;
normative requirements for MCP deployments.
Rather, they represent operational considerations derived from the
architectural observations developed throughout this analysis.
Organizations should adapt them according to:
deployment scale;
operational risk;
regulatory obligations;
governance maturity;
business objectives.
Enterprise Operational Readiness Model
Figure 16. Professional publication figure to be
inserted during production.
This gives executives a concise “takeaway” model that encapsulates
the paper without requiring them to revisit every technical section.
Notably Absent: What the MCP Specification Intentionally
Does Not Attempt to Solve
This is one of the hallmarks of ODA3 publications. Rather than
criticizing the specification, it will explicitly identify the
enterprise concerns that remain outside its scope—such as business
governance, data classification, runtime assurance, extension trust,
forensic readiness, and organizational accountability. Done well, this
section demonstrates analytical maturity by clearly separating
protocol responsibilities from enterprise
responsibilities, reinforcing the paper’s evidence-driven and
practitioner-first perspective.
This section has quietly become one of the defining characteristics
of ODA3 publications. I think we should formalize it as a permanent
editorial discipline.
The objective is not to criticize MCP.
The objective is to clearly separate:
what the specification intentionally solves;
what enterprise architecture must solve;
what operational assurance must solve.
That distinction is intellectually honest and aligns perfectly with
ODA3’s evidence-driven approach.
Chapter 13 — Notably Absent: Enterprise Responsibilities Beyond the
MCP Specification
The architectural observations presented throughout this paper should
not be interpreted as shortcomings of the Model Context Protocol.
Protocol specifications necessarily define boundaries.
Their purpose is to standardize interoperability rather than
prescribe enterprise governance, organizational policy or operational
assurance.
Consequently, several topics that are essential for secure enterprise
deployment remain intentionally outside the scope of the 2026-07-28
specification.
Recognizing these boundaries is important.
Organizations should avoid assuming that protocol adoption implicitly
provides capabilities the specification never intended to deliver.
The following observations identify areas that remain organizational
responsibilities rather than protocol responsibilities.
1. Business Governance
The specification defines mechanisms for interoperability.
It does not determine:
These responsibilities remain entirely within enterprise
governance.
Protocols can enable operational capability.
They cannot determine organizational intent.
2. Business Authorization
The revised authorization model strengthens technical authorization
mechanisms.
It does not determine whether a particular business activity should
be permitted.
Examples include:
Technical authorization and business authorization should not be
treated as equivalent.
3. Data Governance
The specification does not define:
Organizations remain responsible for ensuring protocol-enabled
interactions comply with enterprise data governance and applicable legal
obligations.
4. Extension Trustworthiness
The specification provides mechanisms for extensions.
It does not certify:
extension quality;
extension security;
operational suitability;
publisher reputation;
lifecycle governance.
Extension Assurance therefore remains an organizational
responsibility.
5. Runtime Assurance
The specification defines protocol behavior.
It does not establish that runtime execution remains trustworthy.
It does not evaluate:
orchestration quality;
planning correctness;
workflow integrity;
runtime monitoring;
execution safety.
These responsibilities belong to applications and organizations
rather than the protocol.
6. Prompt Injection Resistance
The protocol standardizes communication.
It does not eliminate:
Organizations should continue treating prompt injection as an
application and operational security challenge.
8. Operational Monitoring
The specification does not prescribe:
telemetry architecture;
alerting;
anomaly detection;
operational dashboards;
forensic collection;
evidence retention.
These remain implementation decisions.
9. Incident Response
Although protocol exchanges become valuable evidence, the
specification does not define:
Operational response remains an organizational capability.
10. Operational Assurance
Perhaps most importantly,
the specification does not demonstrate that deployed
protocol ecosystems remain trustworthy over time.
It cannot determine:
whether governance is effective;
whether authorization remains appropriate;
whether extensions remain trustworthy;
whether identity remains attributable;
whether operational evidence remains sufficient.
Those are precisely the responsibilities addressed by operational
assurance.
ODA3 Observation
A recurring pattern emerges across every “Notably Absent” topic.
The specification consistently answers:
How should systems interoperate?
It intentionally leaves organizations to answer:
Should this interaction occur?
Under whose authority?
Under what governance?
With which evidence?
Under which operational constraints?
With what accountability?
These questions cannot be standardized by protocol alone because they
depend upon organizational objectives, legal obligations and operational
risk.
ODA3 Insight
The maturity of a protocol should not be measured by how many
enterprise problems it attempts to solve.
It should be measured by how clearly it defines the boundary
between protocol responsibility and organizational
responsibility.
This distinction reflects good protocol design rather than missing
functionality.
What This Section Is NOT
On the contrary, the deliberate separation of protocol
responsibilities from enterprise governance is consistent with sound
protocol engineering.
Organizations should therefore resist the temptation to expect
protocol specifications to replace:
These disciplines remain complementary.
Summary Table
Alternative Interpretation
A fair reading of this publication could reasonably object that the
governance responsibilities discussed throughout are not created by MCP
at all, but arise from any enterprise deployment of distributed software
systems — that MCP “is still just a protocol,” and this analysis is
describing enterprise architecture in general rather than something
specific to this revision.
This publication agrees with that premise rather than disputing it.
Its argument is not that MCP invents identity governance, authorization
accountability, or evidence retention as enterprise concerns — those
responsibilities exist independently of any single protocol. The
contribution of this analysis is narrower: the 2026-07-28 revision makes
those pre-existing responsibilities considerably more explicit and
operationally load-bearing by placing identity, authorization,
extensibility, and application-managed state at the centre of how the
protocol itself operates, rather than leaving them as surrounding
infrastructure the protocol could previously ignore. In that sense, MCP
is best read as a concrete case study of a broader pattern affecting AI
interoperability protocols generally, not as an exception to it.
Two further objections deserve the same direct treatment. A reader
might point out that everything argued here would apply equally to other
AI interoperability protocols — A2A, ACP, or whatever succeeds them.
That observation is correct, and it strengthens rather than weakens the
argument: if the analytical concepts developed in this publication only
explained MCP, they would be release notes with better vocabulary.
Because they generalize to any protocol that takes on identity
propagation, authorization, extensibility, and operational state as core
responsibilities, they describe a pattern in AI infrastructure rather
than a property of one specification.
A second, sharper objection is that Protocol Assurance is simply
enterprise architecture or security governance under a new name. That is
only partially fair. Enterprise architecture and security governance
rarely treat an interoperability protocol itself as a distinct assurance
object with its own evidence requirements, lifecycle, and failure modes
— they typically govern the applications and infrastructure around a
protocol while treating the protocol layer as a fixed, trusted given.
Protocol Assurance’s contribution is to argue that this assumption no
longer holds once a protocol takes on the operational responsibilities
this publication documents, and that the protocol layer itself therefore
needs the same continuous evidentiary scrutiny as any other component an
organization depends upon.
Limitations
This analysis intentionally does not:
- assess the security of any individual MCP implementation or vendor
product;
- verify specific software products’ claims of MCP conformance;
- evaluate protocol performance, latency, or scalability
characteristics;
- prescribe a specific implementation architecture;
- define certification requirements or conformance criteria;
- predict future specification changes beyond the 2026-07-28
revision;
- compare MCP against competing AI interoperability protocols.
The publication focuses exclusively on the operational governance and
assurance implications of the publicly documented architectural changes
in the 2026-07-28 specification. Readers seeking implementation-level
technical guidance should consult the specification and its accompanying
release documentation directly.
Transition to Chapter 14
The paper has now established:
what changed in the specification;
why those changes matter architecturally;
how they affect governance;
how they influence incident response;
what remains outside the protocol’s scope;
where a fair reader might reasonably push back, and why the
analysis holds regardless.
The final analytical question is forward-looking:
What should enterprise leaders watch over the next three to
five years?
The concluding chapter will explore how MCP reflects a broader trend
toward protocol-centric AI ecosystems and why operational
assurance is likely to become a foundational enterprise
capability as AI interoperability standards continue to
mature.
Chapter 14 — Looking Ahead: AI Protocols as Critical Enterprise
Infrastructure
The 2026-07-28 revision of the Model Context Protocol should not be
viewed as an isolated protocol update.
It represents one point within a broader architectural transition
occurring across enterprise AI.
As AI systems evolve from isolated conversational interfaces toward
distributed, tool-enabled, agentic ecosystems, interoperability
protocols are becoming increasingly central to enterprise
operations.
This transition is unlikely to be unique to MCP.
Future AI interoperability protocols—whether focused on agents,
memory, orchestration, governance or model interaction—are likely to
encounter similar architectural pressures:
distributed execution;
delegated authority;
machine identity;
protocol extensibility;
operational scalability;
enterprise governance.
The observations developed throughout this paper should therefore be
understood as architectural rather than protocol-specific.
The Next Evolution
Historically, enterprise software evolved through several
recognizable phases.
First came applications.
Then APIs.
Then service-oriented architectures.
Then cloud-native platforms.
AI ecosystems now appear to be entering a comparable phase where
standardized interoperability protocols become foundational enterprise
infrastructure.
As this transition continues, organizations are likely to evaluate
protocols not only through interoperability and developer experience but
also through:
governance maturity;
operational resilience;
assurance capability;
lifecycle management;
evidentiary support.
Protocol engineering and enterprise governance will become
increasingly interconnected.
From Integration to Infrastructure
One recurring theme throughout this paper is that protocols no longer
function solely as integration mechanisms.
They increasingly coordinate:
identity;
authority;
capability;
workflow;
operational context.
This evolution changes enterprise expectations.
Organizations will increasingly ask:
Can the protocol scale?
Can it be governed?
Can operational behavior be demonstrated?
Can trust be preserved during change?
Can incidents be reconstructed?
Can assurance be maintained?
These questions extend well beyond software interoperability.
Operational Assurance Will Become Foundational
The architectural transition described throughout this paper suggests
a broader conclusion.
As protocol ecosystems mature, operational assurance becomes
increasingly important.
Organizations cannot indefinitely rely upon assumptions that:
identities remain trustworthy;
authorization remains appropriate;
extensions remain safe;
operational state remains consistent;
protocol evolution remains controlled.
Instead, these assumptions require continuous validation through
governance, monitoring and operational evidence.
Operational assurance therefore becomes an enduring organizational
capability rather than a project deliverable.
ODA3 Observation
A pattern appears repeatedly throughout modern enterprise
technology.
Every successful abstraction simplifies one architectural layer while
increasing governance responsibility elsewhere.
Cloud computing simplified infrastructure.
Container platforms simplified deployment.
Identity federation simplified authentication.
AI interoperability protocols simplify integration.
None of these technologies eliminate operational complexity.
They relocate it.
Recognizing where complexity has moved is essential for maintaining
enterprise trust.
ODA3 Insight
Technology rarely removes governance
responsibilities.
It changes where those responsibilities must be
exercised.
The architectural significance of the 2026-07-28 MCP revision is not
that it eliminates enterprise complexity.
It changes where organizations must establish, monitor and
demonstrate operational trust.
Research Implications
Several areas merit continued research as AI interoperability
protocols evolve.
These include:
Identity propagation across autonomous agent ecosystems
How should delegated authority persist across multiple independently
operating agents?
Operational evidence for distributed AI workflows
What evidence should organizations retain to reconstruct
protocol-enabled activity?
Extension governance
How should organizations evaluate operational capability introduced
through protocol extensions?
Machine identity governance
How should enterprises govern AI identities operating independently
of individual users?
Cross-protocol assurance
How should organizations establish operational assurance when
multiple AI interoperability protocols coexist within the same
enterprise architecture?
Protocol assurance metrics
What measurable indicators would let an organization demonstrate,
rather than merely assert, that its protocol-enabled ecosystem remains
trustworthy over time?
Protocol software bills of materials
As extensions become independently versioned operational
capabilities, how should organizations maintain an inventory of what is
actually running, comparable to a software bill of materials for
traditional dependencies?
Agent-to-agent trust chains
As agents increasingly invoke other agents rather than only tools,
how should delegated authority and evidentiary continuity be preserved
across chains of AI-to-AI interaction rather than AI-to-tool interaction
alone?
These questions extend beyond the current MCP specification and
represent broader enterprise AI governance challenges that this
publication treats as a research agenda rather than as unresolved
defects in any single protocol.
Final Observation
This paper has intentionally avoided evaluating whether the Model
Context Protocol is “secure” or “insecure.”
That binary framing oversimplifies a more important architectural
reality.
Protocols provide mechanisms.
Organizations establish trust.
Specifications define interoperability.
Organizations demonstrate operational assurance.
The 2026-07-28 revision illustrates this distinction particularly
well.
As protocols become more capable, enterprise responsibility does not
diminish.
It becomes more visible.
Conclusion
The 2026-07-28 revision of the Model Context Protocol represents
substantially more than an incremental protocol update.
While the individual changes—stateless communication, strengthened
authorization, structured extensibility, application support and
governance improvements—are significant in their own right, their
collective importance lies in what they reveal about the future
direction of enterprise AI infrastructure.
MCP is evolving from an interoperability protocol toward an
operational platform supporting increasingly distributed, identity-aware
and governance-dependent AI ecosystems.
This transition has implications that extend beyond protocol
engineering.
Organizations adopting AI interoperability protocols should
increasingly evaluate not only technical interoperability but also
operational trust, governance maturity, evidentiary readiness and
continuous assurance.
The central observation developed throughout this paper is therefore
not that AI interoperability protocols have become more complex.
Rather, enterprise responsibility has become more
explicit.
Trust Boundary Migration, Explicit State Governance, Extension
Assurance and Protocol Assurance are not presented as new protocol
requirements.
They are analytical perspectives that help explain where
organizations must increasingly establish and demonstrate operational
trust as AI ecosystems mature.
Ultimately, protocol conformance answers an important question:
Can systems communicate correctly?
Operational assurance answers a different question:
Can organizations continuously demonstrate that those systems
continue to operate within their intended security, governance and
operational boundaries?
As AI interoperability standards continue to evolve, the second
question is likely to become just as important as the first.
Callout 14-1 — Final Insight
Protocols establish interoperability. Operational assurance
establishes trust.
Appendix A — Specification Change Cross-Reference
The table below maps each major 2026-07-28 specification change to
the chapters in this publication that analyze its operational,
governance, and assurance implications, so that every analytical
conclusion in this publication remains traceable to the underlying
specification text.
This cross-reference distinguishes documented protocol changes, which
are drawn directly from the Model Context Protocol specification and its
accompanying release documentation, from ODA3’s analytical
interpretation of their enterprise governance and assurance
implications, which is original to this publication.
Appendix B — Glossary
Trust Boundary Migration. The architectural
transition in which responsibilities previously assumed to exist within
a protocol, platform, or infrastructure component become explicitly
distributed across identities, authorization systems, applications,
operational workflows, and governance processes.
Explicit State Governance. The disciplined
management, protection, validation, and evidentiary preservation of
application-managed operational state after responsibility for
continuity has moved outside the transport protocol.
Extension Assurance. The continuous evaluation and
governance of protocol extensions to establish that their origin,
integrity, operational behavior, lifecycle, and security characteristics
remain consistent with the organization’s trust requirements throughout
deployment and change.
Protocol Assurance. The continuous demonstration
that protocol implementations, operational behaviors, identities,
authorization decisions, extensions, and governance processes
collectively preserve the security, integrity, accountability, and
intended operational properties of a protocol throughout its
lifecycle.
Enterprise AI Protocol Assurance Stack (EAPAS). A
protocol-agnostic reference model identifying the layers — from
enterprise governance through identity, authorization, protocol,
extensions, applications, tools, data, observability, and operational
assurance — across which organizational trust must be established and
evidenced in an AI-protocol-enabled deployment.
Identity Continuity. The capability to establish,
preserve, validate, and reconstruct the identity under which authority
is exercised throughout a complete operational workflow, including
delegation, transitions between services, long-running execution, and
post-incident investigation. Treated in this publication as a supporting
analytical observation rather than a foundational concept.
Stateless protocol core. The 2026-07-28 MCP
architecture in which the initialize handshake and the
Mcp-Session-Id header are removed; every request instead
carries its own protocol version, client identity, and capabilities.
Extension. A protocol capability negotiated
independently of the MCP core specification, identified by a reverse-DNS
identifier, that can version and evolve on its own timeline. MCP Apps
and Tasks are the two extensions formalized in the 2026-07-28
revision.
MCP Apps. An official MCP extension (SEP-1865)
allowing servers to ship interactive HTML interfaces that hosts render
in a sandboxed iframe.
Tasks. An official MCP extension supporting
long-running, server-directed operations, replacing the experimental
core Tasks capability of the prior specification.
ODA3 Insights • Operational Assurance Analysis (OAA) •
ODA3-2026-07-INS-078