From Tool Connection to Execution Control: Benchmarking Security Invariants in MCP-Style Agent Runtimes

arXiv:2606.29073 · cs.CR, cs.AI · Submitted 2026-06-27 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.

Nadia: I'm Nadia.

Elias: And I'm Elias, here with Priya.

Nadia: We're looking at the paper: "From Tool Connection to Execution Control".

Elias: Here's the gist of the paper. Model Context Protocol (MCP)-style ecosystems give language-model applications a practical connection layer for tools, resources, prompts, and transports <ref:2606.29073#pg2> As agents move from connection to execution, security decisions often remain split across clients, servers, prompts, approval dialogs, OAuth deployments, and logs <ref:2606.29073#pg2> This paper asks whether a runtime can make execution-layer invariants explicit and testable while preserving MCPlike workflows <ref:2606.29073#pg2> The results support a narrow claim: MCP-style agent systems need an execution-control layer in addition to connection-layer conventions <ref:2606.29073#pg2>.

Nadia: Defining the Execution Control Layer The paper defines eight security invariants for MCP-style agent execution, covering aspects such as metadata non-authority, grant-backed approval, and data flow authorization <ref:2606.29073#pg2> These invariants include: 1.

Elias: metadata non-authority <ref:2606.29073#pg2> 2.

Nadia: grant-backed approval <ref:2606.29073#pg2> 3.

Paper summary: Nadia: So, wrapping up this discussion on "From Tool Connection to Execution Control: Benchmarking Security Invariants in MCP-Style Agent Runtimes". The core argument is that connectivity alone isn't secure enough for agents <ref:2606.29073#pg1>.

Elias: They show that the Handle Capability Protocol, or HCP, provides a way to enforce those eight execution invariants by placing them in a runtime object model instead of just scattering prompts or logs <ref:2606.29073#pg1>.

Priya: It’s about making security decisions explicit and measurable by putting them in one place rather than relying on scattered approval dialogs or server conventions <ref:2606.29073#pg1>.

Nadia: The paper shows that this layer can be implemented as a runtime object model, which is different from just relying on prompts or logs for security enforcement <ref:2606.29073#pg1>.

Elias: They aren't claiming this is a production replacement for MCP or OAuth yet; it’s more of a reference runtime to evaluate how these execution controls work <ref:2606.29073#pg2>.

Priya: So, the contribution here is narrower—it shows that you can make a specific class of execution decisions explicit and measurable using this runtime model <ref:2606.29073#pg1>.

Nadia: It’s about making sure that when an agent tries to execute something, all those security checks—like checking the grant against the principal—happen in one defined sequence <ref:2606.29073#pg1>.

Conclusion: Nadia: So, we're wrapping up this look at "From Tool Connection to Execution Control: Benchmarking Security Invariants in MCP-Style Agent Runtimes". Basically, they’re showing that just connecting a tool to an agent isn't security enough.

Elias: Right. The paper focuses on how you can build a runtime layer that makes those security rules explicit and testable, instead of hiding them in prompts or logs.

Priya: It boils down to defining eight specific things—like making sure metadata doesn't grant extra authority, or checking data flow between sources and targets.

Nadia: Those eight invariants are the core idea here. They cover everything from who has permission to use a tool, to how data actually moves through the system.

Elias: And they test this using a reference runtime called HCP, which treats calls as principals and resources rather than just random network requests.

Priya: The results are pretty telling; when you run the naive connection layer, it lets all ten attacks through without catching anything in its audit logs.

Nadia: But when you use the HCP model, it blocks all those ten attacks and actually records evidence for each denial. That’s a big difference.

Elias: The authors show that specific parts of the HCP design, like checking if a grant actually matches a principal, are what stop certain kinds of trouble. It shows you need that execution control layer to make security decisions concrete and traceable.

Priya: So, the big implication is moving security from being scattered across different layers—clients, servers, and prompts—into one central execution path that you can actually measure against known threats.

Nadia: It suggests we need this kind of explicit enforcement mechanism if we want agents to be trustworthy when they start doing real work.

Elias: It's a step toward making agent security verifiable rather than just hoping the connection layer handles everything correctly.

Priya: What this means for us is that we have a blueprint for how to build those verification checks into the agent’s actual execution flow, not just its setup phase.

Ting Liu

SymbolicLight Research

cs.CR, cs.AI

Submitted: 2026-06-27

Updated: 2026-11-07

Comments: v2: Expanded evaluation with an independent gateway baseline, live-model AgentDojo experiments, and tests on third-party MCP servers. Includes supplementary appendices and machine-readable results

Code: https://github.com/SymbolicLight-AGI/handle-capability-protocol

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 87/100

The gist: Model Context Protocol (MCP)-style ecosystems give language-model applications a practical connection layer for tools, resources, prompts…

Key concepts

Execution Control Layer
This is a proposed layer added to agent systems that handles security decisions during the actual execution phase, not just initial connection. It makes security rules explicit and testable by centralizing checks for things like data flow and authorization, ensuring all security elements are bound together in one place.
Security Invariants
These are eight specific rules defined for agent execution, such as metadata non-authority and source-and-target data-flow authorization. They serve as explicit security requirements that the runtime must enforce during operation, moving security checks from scattered prompts into a single, verifiable model.
HCP (Handle-Capability Protocol)
HCP is a reference runtime implementation designed to manage agent interactions. It models calls using principals, resources, and grants to link permissions. It centralizes authorization and audit logging by treating tool metadata as descriptive rather than authoritative during execution.

Terminology

Summary

Model Context Protocol (MCP)-style ecosystems give language-model applications a practical connection layer for tools, resources, prompts, and transports <ref:2606. p. 029073#pg2> As agents move from connection to execution, security decisions often remain split across clients, servers, prompts, approval dialogs, OAuth deployments, and logs <ref:2606. p. 029073#pg2> This paper asks whether a runtime can make execution-layer invariants explicit and testable while preserving MCPlike workflows <ref:2606. p. 029073#pg2> The results support a narrow claim: MCP-style agent systems need an execution-control layer in addition to connection-layer conventions <ref:2606. p. 029073#pg2>.

Defining the Execution Control Layer

The paper defines eight security invariants for MCP-style agent execution, covering aspects such as metadata non-authority, grant-backed approval, and data flow authorization <ref:2606.29073#pg2> These invariants include:

  1. metadata non-authority <ref:2606. p. 029073#pg2>

  2. grant-backed approval <ref:2606. p. 029073#pg2>

  3. canonical resources <ref:2606. p. 029073#pg2>

  4. principal binding <ref:2606. p. 029073#pg2>

  5. scoped capability invocation <ref:2606. p. 029073#pg2>

  6. source-and-target data-flow authorization <ref:2606. p. 029073#pg2>

  7. deny-path audit <ref:2606. p. 029073#pg2>

  8. explicit protocol state <ref:2606. p. 029073#pg2>.

The Reference Runtime Implementation

The paper implements HCP, a Handle-Capability Protocol reference runtime, which represents calls through principals, resources, grants, capabilities, handles, policy decisions, data-pipe checks, and audit entries <ref:2606.29073#pg2>. HCP treats tool metadata as descriptive rather than authoritative and resolves resources through the provider <ref:2606. p. 129073#pg2>. The design centralizes runtime authorization, data-handle control, and audit, placing the runtime object model between agent intent and provider execution <ref:2606. p. 129073#pg2>. Key components of HCP include a Principal, a Resource, a Grant linking principal to scopes and capabilities, a Handle for output data storage, and DataPipe checks for source-to-target data movement <ref:2606. p. 629073#pg2>

Benchmark Methodology and Results

The evaluation uses 10 benchmark cases across three modes: B0 (naive connection-layer runtime), B1 (practice-informed mitigation baseline), and B2 (HCP runtime) <ref:2606.29073#pg2>. Table 4 summarizes the security outcomes, showing that B0 permits all 10 attacks while leaving zero blocked outcomes in the audit completeness dimension <ref:2606. p. 629073#pg2>. In contrast, B2 blocks all 10 cases and records audit evidence for each HCP denial <ref:2606. p. 829073#pg2>. Ablation studies demonstrate that specific components like grant matching or data-pipe target policy are necessary to block certain attack classes <ref:2606. p. 829073#pg2>.

Implications for Agent Security

The benchmark suggests that metadata linting and user approval are useful but insufficient because they do not create a single runtime decision binding all security elements <ref:2606.29073#pg2>. HCP's advantage lies in placing these checks into one execution path, making the invariants executable and testable <ref:2606.29073#pg2>. The results support the design principle that agent systems need an execution-control layer to make security decisions explicit and auditable <ref:2606. p. 029073#pg2>.

Auxiliary Evidence and Governance

Auxiliary experiments provide evidence regarding overhead, compatibility, and operator governance surfaces <ref:2606.29073#pg2>. The ecosystem measurement suggests that README-visible MCP-adjacent projects can expose authority surfaces relevant to the threat model <ref:2606. p. 629073#pg2>. These results motivate the need for runtime objects that can produce explanations for governance gaps, such as why a local server command is risky <ref:2606.29073#pg2>. The paper concludes that HCP shows this layer can be implemented as a runtime object model rather than scattered prompts or logs <ref:2606. p. 1 p. 029073#pg2>.

Limitations and Scope

A central limitation is that the evaluated runtime is in-memory, meaning grants and audit entries are not durable in the prototype <ref:2606.29073#pg2>. This omission isolates execution-control invariants before evaluating production platform machinery <ref:2606. p. 529073#pg2>. The benchmark is intentionally adversarial but not exhaustive, as prompt injection and supply-chain attacks can still matter even when HCP invariants hold <ref:2606.29073#pg2>. The compatibility results are also scoped, covering only MCP-like primitives implemented by the reference shim <ref:2606. p. 929073#pg2>. The contribution is narrower, showing that a runtime can make a specific class of execution decisions explicit and measurable <ref:2606. p. 0 p. 029073#pg2>. The paper does not claim production readiness for HCP <ref:2606. p. 329073#pg2>. The evaluation is an invariant-coverage benchmark rather than an exhaustive exploitability study <ref:2606. p. 129073#pg2>.

Related Work Context

MCP security is an active topic, with prior work modeling tool poisoning and indirect prompt injection <ref:2606.29073#pg2>. HCP differs by focusing on runtime enforcement rather than model robustness alone <ref:2606. p. 029073#pg2>. Capability systems and confused-deputy analysis motivate HCP’s rejection of ambient server authority, requiring explicit binding of grants to operations <ref:2606. p. 229073#pg2>. Information-flow control motivates treating data movement as a security object, leading to the practical requirement for source ownership checks in data pipes <ref:2606. p. 229073#pg2>. Provenance and audit systems motivate recording entities and activities, which HCP audit follows by making failures traceable <ref:2606. p. 229073#pg2>. The paper applies these concepts to agent execution by binding grants to principals, resources, scopes, and capability identifiers <ref:2606. p. 029073#pg2>.

Conclusion

MCP-style protocols have made agent-tool connectivity easier to build <ref:2606.29073#pg2>. This paper argues that connectivity is not enough for secure execution <ref:2606. p. 129073#pg2>. HCP demonstrates one way to enforce explicit invariants while preserving MCP-style workflows <ref:2606. p. 029073#pg2>. The result is evidence for a design principle: agent systems need an execution-control layer, and that layer should be evaluated with reproducible security invariants <ref:2606. p. 029073#pg2>. HCP shows this layer can be implemented as a runtime object model rather than scattered prompts or logs <ref:2606.29073#pg2>. The paper does not make a production-security claim <ref:2606. p. 329073#pg2>. The contribution is narrower, showing that a runtime can make a specific class of execution decisions explicit and measurable <ref:2606.29073#pg2>.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Implement an execution-control layer in addition to connection-layer conventions by treating principal, resource, capability, approval, handle ownership, data flow authorization, deny-path audit, and explicit protocol state as runtime objects rather than scattered prompts or logs. This allows for a single point where principal, resource, capability, approval gate checks enter the invocation path.

  2. Design agent runtimes that enforce eight specific security invariants to ensure execution integrity across MCP-style workflows. These invariants include metadata non-authority, grant-backed approval, and data pipe authorization, making failure modes explicit and testable through a controlled benchmark.

  3. Develop mechanisms where data movement is treated as a new authorization event by checking both source ownership and target capability policy before moving data, rather than relying on simple content filters. This enforces the invariant that Source ownership and target capability policy must both pass for any data pipe operation.

  4. Create a system where tool descriptions are explicitly defined as non-authoritative, preventing them from granting permission or overriding policy, satisfying the invariant Tool metadata is not policy authority. This ensures that Tool descriptions and prompts cannot grant permission or override policy.

  5. Establish a mechanism for audit evidence recording that captures all deny decisions with specific reason codes, fulfilling the invariant Deny paths are auditable. This ensures that a denial produces an entry detailing which principal, resource, capability, and grant caused the denial, providing forensic accountability.

  6. Integrate session and protocol state checks into the execution path to ensure that Missing initialization, wrong versions, and stale sessions fail predictably. This prevents protocol method calls before initialization or with incompatible versions from proceeding to provider execution.

  7. Implement a mechanism for canonical resource resolution where caller-supplied resource strings cannot override the provider's decision, satisfying the invariant Caller resource cannot override provider canonical resource. This ensures that Policy uses provider-resolved resources regardless of caller input.

  8. Build a capability binding system that links principals to grants, tasks, handles, and audit entries simultaneously to satisfy invariant I4: Principal is bound to grant, task, handle, and audit. This ensures Wrong principals cannot invoke or inspect owned handles.

Sources

Related papers