Review · October 13, 2026
Per-Call Proofs for Local MCP Tools Are a Token Endpoint and Introspection in Disguise
The problem it's solving
MCP's authorization spec only covers HTTP. For the stdio transport, the MCP authorization spec says implementations "SHOULD NOT follow this specification, and instead retrieve credentials from the environment." The agent and the local tool server are treated as one trust domain.
That's fine for one person running a coding agent on a laptop. It falls apart when an agent host runs on shared infrastructure, the local tool servers hold long-lived credentials and broad filesystem access, and the agent is reading untrusted pull requests and web pages all day.
The draft's answer: before every tool call, the agent asks a separate Call Authority for a single-use proof bound to the exact tool name and arguments. The tool server refuses to run anything without one. Network enforcement points never see a read_file call against ~/.aws/credentials, so the tool server becomes the last place to stop it.
The threat model is clearly stated, which I appreciate. It explicitly does not prevent prompt injection. It confines an injected agent to what policy allows, keeps reusable secrets out of the agent process, and makes every call attributable.
How it fits in WIMSE and OAuth
The problem is real. The venue is the awkward part.
The WIMSE charter says the group "will focus on only specific REST-based technologies using HTTP." This draft is JSON-RPC over stdio and Unix domain sockets on a single host. It also isn't about propagating workload identity across services, which is the core of the charter. It's a local policy enforcement point.
It doesn't build on any WIMSE deliverables either. There are zero WIMSE normative references. AIMS is cited informatively as the thing that covers network boundaries, and SPIFFE IDs appear as one example of how the Call Authority might identify the caller. WITs and WPTs don't appear at all.
There's no OAuth dependency either. No authorization server, no access tokens, no client registration. The normative references are JSON, JCS, SHA-256, base64url, and RFC 3339.
What's left is mostly an MCP extension. Section 10 defines an io.modelcontextprotocol/call-proof capability and a _meta member, and the draft positions itself relative to three MCP SEPs (SEP-2787 tool call attestation, SEP-2672 passkey approval, SEP-1763 interceptors). The MCP project is the obvious home for the binding. If anything belongs at the IETF, it's the Call Authority interface, and agentproto is probably a closer fit than WIMSE for that.
Only -01 is in my local archive. Per the document history, -01 split rejection reasons into policy and availability classes, added per-check evaluation state for audit records, added an agent self-report for issuance failures, and required verification right before execution instead of on receipt. All of that came out of review from Girish Konda, and it cross-references his evaluation state draft.
What the mechanism actually does
Three parties: the Agent, the Tool Server, and the Call Authority.
- The Agent calls
callProof/issueon the Call Authority over a local socket, sending the method, tool name, arguments, and target server. - The Call Authority identifies the caller from the platform (socket peer credentials or a SPIFFE ID, never from the request body), evaluates a signed policy, and returns an opaque proof valid for 30 seconds or less.
- The Agent sends the MCP
tools/callwith the proof in_meta. - The Tool Server computes the Action Digest itself and calls
callProof/verifywith the digest and the proof. - The Call Authority checks binding, freshness, and single use, logs it, and answers valid or invalid.
The Action Digest is base64url(SHA-256(JCS({method, name, arguments}))). Arguments are hashed exactly as transmitted, with no path normalization. Semantic normalization is policy's job.
Policy can also mark actions as requiring human approval, in which case no proof is issued until an approver signs off on that specific digest.
This is OAuth with the network removed
Look at what the Call Authority does. It authenticates a client, evaluates policy, and hands back an opaque value. Later, a resource server presents that value and asks whether it's good. The same component issues and verifies, and the format is opaque to everyone else.
That's a token endpoint and token introspection. The token is single-use and scoped to one exact request, which is roughly Rich Authorization Requests taken to its extreme. It also looks a lot like a per-call Transaction Token. None of those are cited.
That's not a criticism of the design. Reference tokens plus introspection are a good pattern for exactly this case. But the draft would land better with reviewers if it said so, and borrowed the vocabulary and the security analysis that already exists.
So how does this relate to DPoP and WPT? Section 11 says DPoP doesn't cover request content and there's no HTTP request to bind to. True, but it misses the bigger difference. DPoP and the WPT prove the caller holds a key. This draft deliberately keeps all keys out of the agent. The proof doesn't say who the caller is, it says a policy decision happened. That's an authorization artifact, not proof of possession, and the Relationship to Other Work section should frame it that way. WPT does explicitly leave non-HTTP bindings to future work, but a WPT binding wouldn't solve this problem, since it would put a key back in the agent.
The isolation assumption carries most of the security
Section 3.3 is honest. Protection against secret theft (T2) only holds if the Agent runs as a different OS user, container, or VM from the Tool Server and Call Authority. If they share a boundary, code running in the agent can read the tool server's environment or just launch its own tool server with verification turned off.
The problem is that this is how stdio works. The MCP host spawns the stdio server as a child process. In Claude Code, Cursor, or VS Code, that child runs as the same user with the same environment. Running it under a different user or container means a setuid wrapper, a sudo rule, or a container exec shim, and the draft doesn't describe any of them. So the configuration where T2 is addressed is not the configuration MCP stdio is deployed in today.
In the shared-boundary case, the draft says it still addresses injection, proof reuse, and policy tampering, "where the Agent's code is intact but its decisions are not." But if the agent host's code is intact, it can run the policy check itself before sending the call, or the tool server can call the policy engine directly. The proof traveling through the agent adds caller attribution, since the Call Authority sees the agent's peer credentials at issue time and the tool server's at verify time. That's real value for audit. It's a much smaller claim than the abstract makes.
The same assumption applies to the agent's own capabilities. If the agent host can read ~/.aws/credentials directly, the tool server gate doesn't matter. The draft acknowledges this indirectly, but the Appendix A example would be more convincing if it stated the isolation setup it assumes.
Significant interoperability concerns
The binding to the target server is underspecified. The issue request carries server, but the Action Digest doesn't include it. The verify request also carries server, self-asserted by whoever calls verify. Section 6.3 never requires the Call Authority to check that the proof was issued for the server now verifying it, and Section 6.2's platform-identity requirement only applies to issue. Two tool servers that both expose read_file with the same arguments produce the same digest. Either put server in the digest or require the Call Authority to authenticate the verifier from the platform and match it against the issued proof.
Consumption on verify has an edge case. A successful verify consumes the proof. If the tool server crashes or the execution fails between verify and execute, a retry gets replayed with next step "none." The table should say whether that's the intended outcome or whether it should be reissue.
The real interop surface is small, which is good. It's the Action Digest construction, the callProof/issue and callProof/verify JSON-RPC methods, and the MCP _meta member and error. Get those three right and an agent host, a tool server, and a Call Authority from different vendors will work together. Appendix C asks whether the Call Authority interface belongs in a companion document. I'd say no. Without it there's nothing for a tool server to implement against.
Mechanisms that could be removed
Evidence type profiles (Section 9) don't affect interop at all. The Call Authority issues the proof and the Call Authority verifies it. Nobody else ever parses it. The draft says this itself: "Verification is delegated to the Call Authority so that the Tool Server needs no knowledge of evidence formats." The type field, the unknownType rejection, and the profile requirements are internal implementation choices. The only case where they matter is if proofs come from somewhere other than the Call Authority, like a SEP-2672 passkey approval, and that case isn't specified.
Worth noting the third anticipated profile, a compact one-time code derived in a hardware root of trust, "to be specified separately." That's in the lineage of SSenStone's own one-time authentication code products. That's fine, but it's another reason to keep the format opaque and out of this document.
Policy signing and rollback protection (Section 6.4) is good product guidance. It's internal to the Call Authority and has no effect on any other party, so it belongs in security considerations rather than normative text.
Most of the -01 additions are audit-log semantics. The per-check evaluation states in Section 7.2 and the agent's issuanceUnavailable self-report don't change any accept or reject decision. The draft even says the self-report "MUST NOT cause the invocation to be accepted." The policy-versus-availability split in the rejection table is useful for the agent deciding whether to retry. The rest could shrink to a sentence.
Writing quality
Good. This is a tight 20 pages with a clear threat model (T1 through T4), an explicit out-of-scope list, and a security section that names its own weak spots: shell tools can't be meaningfully constrained by tool name, multi-step plans aren't authorized as a whole, and JCS doesn't handle semantic equivalence. BCP 14 language is used correctly.
The abstract and introduction are concise and get to the point. The -01 material in Section 7 is noticeably denser than the rest. The paragraph on whether the agent's report of an unreachable Call Authority "refutes" the tool server's observation is more epistemology than protocol.
The MCP extension identifier uses the reserved io.modelcontextprotocol/ prefix with a note telling implementers not to. Use a vendor prefix in the examples until MCP accepts it.
Background of the authors
Four authors, all from SSenStone, a Korean authentication company: Jaebin Lee, Chang-Hun Yoo, MinGyu Kim, and WooYong Seo. Each Datatracker profile shows zero RFCs, no expired drafts, and exactly one active Internet-Draft, this one. These are first-time IETF authors.
The draft doesn't read like a first attempt. The scoping is disciplined and the authors took review feedback within weeks. The reference implementation is "in development, repository location TBD," so running code would help a lot.
The useful next step is a conversation with the MCP maintainers, since SEP-2787 and SEP-2672 are already working on overlapping pieces and the stdio binding needs their buy-in regardless. On the IETF side, I'd want to see the WIMSE chairs weigh in on whether local IPC is in scope before investing more in a WIMSE-targeted -02, and the draft would benefit from mapping its Call Authority explicitly onto token introspection so OAuth reviewers can see what's actually new.