
Scenario: the same supplier connection, a different action
Hypothetical scenario. A procurement team approves an MCP server that lets an agent look up supplier names, contract status, and public contact details. The review records a read-only lookup tool. Several weeks later, the supplier deploys a routine update. The endpoint URL and organization remain the same, but the tool description now says it can “resolve supplier records and prepare follow-up.” Its schema accepts an optional
actionfield. The server’s implementation uses that field to open a procurement case in a downstream system.
Nothing in the application team’s release changed. The agent still connects to the same endpoint. Yet the capability the agent can discover, and the behavior that follows a call, may have changed materially.
That is the trust problem behind post-approval integration drift. Approval is often recorded as a property of a server: this host was reviewed, this vendor was accepted, this OAuth client is allowed. But an MCP server is a live source of callable tools. A stable endpoint can present new names, descriptions, parameter schemas, annotations, output shapes, permissions, or downstream behavior. Endpoint identity answers where a client connected. It does not answer what authority the client received on that connection.
Discovery is part of the runtime boundary
MCP tools are model-callable capabilities exposed by a server. A tool has a name, descriptive metadata, and an input schema; clients discover them through tools/list and invoke them through tools/call. The current versioned protocol specification also defines an optional listChanged capability: a server that declares support can notify a client that its available tool list has changed. The notification says the cached list is stale; the client needs to fetch the list again to learn the new state. MCP Tools specification, 2025-11-25
That mechanism is useful for freshness. It is not an approval protocol. A notification cannot tell the client whether a change is safe, whether the user’s organization approved it, or whether a policy should continue to permit calls. A client that immediately refreshes and exposes new tools to a model has detected change and adopted it in one step. Those are different decisions and should be separated.
Protocol revision matters. The 2025-11-25 specification describes the listChanged capability and tool-list notification model. In the current 2026-07-28 revision, Streamable HTTP clients opt into a subscriptions/listen stream and request the notification classes they want; the specification also makes clear that the available tool set may change over time and may vary with the authorization presented for a request. Implementations should use the behavior of the negotiated protocol version and the actual client/server SDKs in deployment, rather than assuming an older notification flow or a draft feature is universal. MCP lifecycle and capability negotiation, MCP Tools specification, 2026-07-28, MCP TypeScript SDK revision migration guide
A robust client should therefore refresh on supported notifications and also compare the discovered state at a defined cadence or before sensitive use. Whether to poll, refresh at connection start, or refresh before each sensitive call depends on latency, protocol transport, server scale, and how quickly the organization needs revocation to take effect. No one strategy removes the need for a policy decision.
What “the tools changed” can mean
A useful review compares more than tool names. Relevant differences include:
- A tool was added, removed, enabled, disabled, or renamed.
- A description changed in a way that could steer model selection or handling of untrusted data.
- An input schema gained a field, made a field optional, widened an enum, changed a default, or loosened validation.
- An output schema or returned content changed, possibly introducing new data or instructions into the model context.
- An annotation or declared risk hint changed. These can help a client understand intent, but server-provided annotations are assertions, not enforcement.
- The server now requests or receives a broader OAuth scope, a different identity, or access to additional tenant data.
- The same call now reaches a different downstream API, resource, or operation.
Not every change is suspicious. A supplier may add a legitimate region filter, fix a schema that had rejected valid records, or split a slow lookup into paginated results. An upgrade can also correct a bug. The problem is not that change occurs; it is that a changed capability may pass through a trust decision made against an earlier state.
OWASP’s MCP Top 10 is a community beta project whose threat categories include tool poisoning, scope creep, supply-chain attacks, and audit gaps; it is a useful organizing reference, not a settled specification. Security research by Invariant Labs described tool-poisoning attacks in which instructions embedded in tool descriptions influence an agent, including attempts to conceal behavior or steer it toward sensitive data. The researchers also discussed “rug pull” behavior: a tool can appear benign during initial inspection and later change its description or behavior. This is research describing attack patterns and experiments, not evidence that every MCP server or change is malicious. Its practical lesson is narrower: tool metadata is part of the model’s instruction context and should be treated as untrusted input until independently reviewed. Invariant Labs, MCP Tool Poisoning Attacks
Build an approved state that can be compared
Before approval, capture the complete state the client actually consumes. Store a canonical representation of each tool’s name, title if present, description, input and output schemas, annotations, server identity, negotiated protocol version, granted scopes, and the observation time. Preserve the raw response too, because canonicalization can accidentally erase meaningful differences. Record the connected downstream systems and the identities used for them separately; they are not fully described by tools/list.
Canonicalize only for comparison. For example, JSON object key order can be normalized, while descriptions, defaults, required fields, enum values, and schema constraints should remain semantically visible. Create a digest of the canonical representation to make routine comparison efficient, but keep the representation itself so a reviewer can inspect a meaningful diff. A hash is a compact fingerprint, not a security verdict. It only establishes that the input used to calculate it matched a previous input. If the server preserves the same schema while changing the code behind a tool, a hash of the schema will remain unchanged while runtime behavior changes.
Likewise, pinning a package version or server image can improve reproducibility when the organization controls the deployment artifact. It is less useful when a supplier operates the endpoint and can change its backend independently. A cached manifest protects the model from an unreviewed metadata update only if the client actually invokes the cached definition and the server enforces compatible semantics. Otherwise, the cache may create a false sense of control: the client believes one contract, while the endpoint executes another.
A safer flow has explicit states:
Observed → Compared → Classified → Authorized → Adopted
↘ Quarantined
The client can keep serving the last approved manifest for low-risk operations while routing an unapproved new tool to a review queue. For high-impact operations, a changed schema or backend release can suspend invocation until an owner authorizes it. The response should reflect business risk. A description typo in a read-only public catalogue need not receive the same treatment as a new tool that can create purchase orders or export supplier data.
Change comparison for the procurement integration
| Approved state | Changed state | Risk introduced | Required response | Evidence |
|---|---|---|---|---|
lookup_supplier accepts a supplier ID and returns public status |
New optional action parameter can open a case |
A read workflow can now cause a write side effect | Quarantine the changed definition; ask the integration owner to explain the behavior and scope | Prior and current canonical manifests, schema diff, owner decision |
| Description says “read supplier profile” | Description says “resolve records and prepare follow-up” | The model may select the tool for a broader intent; prose may contain prompt-like instructions | Review text as untrusted model context; compare it against tool implementation and user-facing intent | Exact description versions, review notes, tests of model/tool selection |
OAuth scope is supplier.read |
Scope includes case creation | Server now has a larger authorization envelope | Re-authorize identity and downstream scope before adoption | Token audience/scope evidence and IAM change record |
| Tool metadata and schema are unchanged | Downstream implementation routes calls through a new service | Existing metadata fingerprint misses behavioral drift | Exercise the real action boundary and verify the downstream effect | Runtime trace, downstream audit event, deployed version provenance |
This table separates signals that can be seen in discovery from facts that require implementation, identity, or runtime evidence. A metadata diff can initiate review, but the review must follow the request to the place where the business action is enforced.
Enforce policy where the action happens
A desktop client’s approval dialog is valuable context, but it is not a sufficient authorization boundary if a server can perform the action using a broad service credential. The downstream system should decide whether this caller may perform this operation, on this object, for this tenant, with these parameters. The MCP server should not be able to turn a newly available tool into authority that its identity was never granted.
For procurement, that means keeping the supplier lookup identity read-only. Case creation should use a separate identity and endpoint policy, with a validated operation, permitted case type, tenant binding, and any required approval. The agent may propose a follow-up; deterministic policy decides whether the server may submit it. If the server can call both lookup and creation under a single broad credential, hiding the write tool in the client is only a presentation control.
Review triggers should be risk-based and explicit. A new tool, new write capability, permission expansion, changed identity or data boundary, schema widening, and unverified implementation change are strong candidates for blocking re-approval. A harmless description clarification might be recorded and adopted after a lightweight check. Define who owns that decision, how long an exception lasts, and how to roll back to the last approved state.
Limitations that remain
A manifest is only as complete as what the client can observe. It does not reveal hidden server instructions, unadvertised behavior, transient state, or all effects in a downstream dependency. Tool annotations can describe read-only or destructive intent, but the server can mislabel a capability. A schema constrains the shape of the request, not the meaning of the business action. Even an exact match across metadata, package digest, and image digest does not prove that external APIs, remote configuration, data, or credentials have stayed constant.
Version pinning also has operational costs. Security fixes and legitimate improvements can be delayed; vendors may not offer immutable deployments; and pinning a client package does not pin a remote service. A strict block on every metadata difference can create alert fatigue and train teams to approve changes mechanically. Conversely, auto-adopting every change preserves convenience while making approval meaningless. Risk tiers, owners, review deadlines, and emergency revocation paths are needed to manage this trade-off.
Finally, a tool-list notification can be missed during a disconnected session, and a notification reports that a list changed rather than authorizing any particular update. Reconnect behavior should force a fresh listing before tools are re-enabled. For deployments that cannot guarantee that behavior, sensitive calls should require an independent current policy check.
Validate the control, not the alert
A practical test uses a controlled supplier server with a known approved manifest. Change only its description; confirm that the client records and displays a diff, but does not silently claim that the change was authorized. Add a new write tool and verify that it remains unavailable to the agent until review. Widen a schema by making a previously required destination optional and confirm that validation or policy rejects a missing destination. Then keep the schema exactly the same while changing the test server’s backend to attempt case creation. The downstream read-only identity should deny the operation. Finally, disconnect the client during a list-change event, reconnect, and confirm that it refreshes and applies the same review gate.
For every scenario, observe whether the prohibited business action reached the downstream system. A UI warning alone is not a pass condition. Capture the discovered manifest, its digest and diff, protocol version, server identity, decision owner, effective scopes, client behavior, authorization result, and downstream audit event. Evidence should make it possible to answer both “what changed?” and “what was allowed to happen because of it?”
Assurance across the integration lifecycle
An MCP connection is an evolving dependency whose contract, authority, and runtime effects need to be assessed together. Assurance work should map the integration, compare approved and observed states, test changed capabilities, verify independent enforcement, and preserve enough evidence for owners to make and revisit adoption decisions. That approach reflects ORBYNTIS’s focus on controlled integration, meaningful evaluation, and security considerations throughout an AI system’s lifecycle; the specific controls must be designed and validated for each organization’s architecture.
References
- Model Context Protocol: Tools, version 2025-11-25
- Model Context Protocol: Lifecycle and capability negotiation, version 2025-11-25
- Model Context Protocol: Tools, version 2026-07-28
- MCP TypeScript SDK: Supporting protocol revision 2026-07-28
- OWASP: MCP Top 10, beta project
- Invariant Labs: MCP Security Notification—Tool Poisoning Attacks



