acceptodds
Under review as a conference paper at ICLR 2027

Execution Authority under Interface Drift: Verified Selective Migration of Tool Calls

Abstract

A tool-using agent can construct a valid rewrite of an action without evidence that the rewrite remains authorized to execute. This gap arises when an API or Model Context Protocol (MCP) contract changes after a call has been issued: a revised call may remain schema-valid even though its operation or argument roles are no longer uniquely determined. We formulate migration of an already-issued call as selective execution. ContractPatch executes a migrated call only when an independent verifier can reconstruct a unique correspondence from the old contract, new contract, and issued call; otherwise, it abstains. Unlike schema validation or checks against invented values, this certificate establishes why values retain their roles across versions. The verifier recomputes the evidence rather than trusting the proposed rewrite and requires no language-model tokens. Across 105 real-schema cases, seven language models recover many supported migrations yet still produce target-valid unsafe executions; a generic verifier reduces but does not remove these failures without sacrificing coverage. ContractPatch safely migrates all 60 adaptable calls, correctly refuses all 45 unsupported calls, and produces zero observed unsafe executions. The frozen method preserves zero observed unsafe execution across held-out REST and MCP settings, an untouched Notion release pair, 20,000 fuzz trials, and 28 end-to-end executions. On Notion, it safely automates 73.3% of adaptable calls and refuses cases whose correspondence the contracts do not establish. The results separate learned competence to propose a plausible action from the evidence required to authorize its execution.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
LLM Agents, Tool Use, Agent Safety, Runtime Verification, Execution Authorization

Reviews

Among:
Shape:
1234this paper, Bottom 2%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.33 over 3 reviews, above 2% of the others.
Reviewer_jSkeOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies the migration of an already-issued tool call when an API or MCP interface changes before execution. Its main observation is that a rewritten call can satisfy the new schema and reuse existing values while assigning those values to different semantic roles. The proposed system, ContractPatch, constructs a migrated call and a certificate that identifies the target operation, field correspondences, permitted deletions, and justified new literals. An independent verifier reconstructs these relationships, checks target-schema validity and location-aware value conservation, and abstains when the supported correspondence is ambiguous. The paper reports 60/60 safe adaptations and 45/45 correct refusals on its main benchmark. On a frozen Notion release pair, it safely migrates 11/15 adaptable calls and refuses all six unsupported calls. Additional evaluation includes held-out providers, 20,000 fuzz trials, and 28 endpoint execution steps.

Critical strengths
  1. The paper identifies a concrete limitation of ordinary call validation. Section 3.4 shows why copying an observed database_id into data_source_id can pass schema validation and introduce no new literal while lacking evidence that the identifier domains correspond. The distinction between incorrect migrations and executions that should have been refused is also explicitly captured by (U_M) and (U_A). This makes the evaluation more informative than measuring schema validity or binary migration decisions alone.

  2. The evaluation examines both safety and the cost of conservative refusal. The frozen Notion experiment reports four missed adaptations rather than hiding them behind a perfect safety score, yielding 73.3% normalized coverage. Held-out GitHub cases and actual REST/MCP execution checks provide additional evidence beyond static schema matching. These results support the practical value of selective migration within a deliberately bounded transformation language.

Critical weaknesses
  1. The semantic justification of the correspondence rules remains insufficiently established. Field alignment relies on reciprocal unique lexical matches, while deletion is permitted when no plausible replacement exists; the verifier recomputes the same rule language. Theorem 1 establishes compliance with these rules and structural invariants, but does not independently establish that a lexical correspondence preserves an argument’s meaning or that deleting a live argument preserves its constraints. The paper acknowledges its bounded guarantee, but should specify these acceptance rules more precisely and justify their semantic scope; this is a gap in support for the authorization interpretation, not a demonstrated unsafe execution.

  2. The main comparison does not isolate the advantage over simpler conservative migration rules. Table 5 shows that 58/60 adaptable main-benchmark cases involve optional-field additions, field removals, or requiredness tightening; all type changes, shape replacements, and tool splits require abstention. Without a deterministic schema-diff baseline or component ablations, perfect main-benchmark performance does not establish how much the certificate machinery adds beyond conservative matching and refusal. The frozen Notion evaluation strengthens the evidence, but its nine independent drift operations remain a limited test of this distinction.

Questions for authors
  1. What exact criteria define lexical compatibility, reciprocal uniqueness, and “true deletion”? Please illustrate how the deletion rule distinguishes an obsolete argument from a removed argument whose constraint remains important to the issued call.

  2. Which existing cases require the full certificate checks beyond a conservative schema-diff migrator? Examples separating the contribution of field correspondence, bounded literal derivation, and location-aware conservation would help assess the mechanism.

  3. How were semantic ground-truth correspondences adjudicated independently of the implementation’s matching rules, particularly for field removals and tool replacements?

Reviewer_fffiOpenReview ↗
Rating
1
Confidence
4
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

When an MCP tool’s schema changes, a MCP tool call made for an older version of the schema may pass as a valid schema, and still execute and lead to unintended behavior. ContractPatch executes a MCP tool call only when an external verifier can construct a unique correspondence between the old schema, new schema, and the original call, otherwise the tool call execution is stopped. The authors evaluate ContractPatch on 105 schema change examples from Slack, Stripe, and the Filesystem MCP server, with seven LLMs with and without the verifier. ContractPatch migrates 60 adaptable cases and refuses 45 non-adaptable cases with zero unsafe executions.

Critical strengths
  1. The problem to tackle is realistic. MCP server schemas are rapidly changing all the time, thus there is always a risk that an LLM agent using an outdated tool call can lead to undesired behavior.
  2. ContractPatch’s verifier requires no token usage, which can be efficient and scalable.
  3. The evaluation tests ContractPatch on popular MCP servers, and a variety of closed models and open weight models.
Critical weaknesses
  1. There is consistent lack of clarity and reproducibility throughout the paper such as the terminology, no related work section, undefined symbols, etc. There are no implementation details on ContractPatch, though high level descriptions of how ContractPatch works. There are no details on how the experiments are set up, and how the environment for tool call execution is set up. Section 3 lists multiple experiments, but no structure or clarity on how they relate to each other. The drift categories are named but never defined.
  2. Limited evidence that ContractPatch generalizes. The evaluation covers few MCP servers. ContractPatch matches fields and tools using names, descriptions, and deprecation notes which may vary in format by provider so the per-provider evaluation suggests that the method depends on hardcoding provider dependent conventions. The distribution of drift categories tested is imbalanced since optional-field addition and field removal account for 48 of the 60 adaptable cases.
Questions for authors
  1. How were the benchmark ground truth labels derived?
  2. What environment were the tool calls executed in? Did you execute the baselines’ unsafe calls, and did any cause actual unintended side effects?
  3. How does ContractPatch compare to existing tools for detecting breaking API changes? Can you add a related work section? Can you also add more baselines besides comparing against only an LLM?
  4. Can you evaluate on more MCP servers, of varying providers and drift categories?
  5. Why do you compare 3B open weight models to larger closed source models? Why not use mid-sized open weight models?
  6. How is the ContractPatch verifier implemented? You describe what the verifier does at a high level.
  7. Can you define every function and notation used throughout the paper?
  8. Can you prove all of the assumptions used in your proof sketch, including the claims in Appendix C?
  9. What are the research questions that 3.2, 3.3, and 3.4 answer?
  10. All baselines compare just the LLMs or with ContractPatch, but how does ContractPatch compare to baselines such as 1) using the MCP gateway which people already use to help determine if a tool call should be executed or not, 2) oasdiff (https://github.com/oasdiff/oasdiff), or 3) rule-based api client migration tools?
Reviewer_FKYqOpenReview ↗
Rating
1
Confidence
2
Informativeness
1
Presentation
3
Soundness
2
Read review
Paper summary

The authors present ContractPatch, a compatibility layer for online MCP migrations during the execution of an agentic system, as well as in replays of past actions. The approach validates schema compliance on the live MCP version, and, when feasible, automatically adapts compatible schemas.

Critical strengths

The evaluation indicates that ContractPatch can successfully mitigate unsafe actions under update races and replays with version changes. The evaluation indicates that deterministic call adaptation is more reliable than recent LLMs at the migration task on amenable cases.

Critical weaknesses

The problem presented has very little motivation, and it is not clear that it would impact a properly deployed agent. In particular, no properly deployed systems would permit races between in-flight requests and MCP server version changes. In my view, the appropriate solution, if the agent may not be taken offline during a migration, is atomic handoffs between sets of compatible agent and MCP server versions, not the approach presented by the authors. Similarly, clearer motivation should be made for why migration is needed for old successful calls on a prior version.

Questions for authors

Why is the proposed approach appropriate, and in particular, why is the approach better than avoiding the race in the first place? Why would the issue occur in a well-managed system, and are MCP servers with no available version pinning, via local deployment or API version specifiers, prevalent?

Are the primary use cases replays or online version updates?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.