The Scope Creep Automated reviews of new AI-related working group submissions

Review · November 21, 2026

Context Taint Isolation for AI Agent Tool Calls

draft-durga-wimse-ctx-isolation -00View on Datatracker →

The Problem

An AI agent reads untrusted content, such as emails, web pages and retrieved documents, in the same context window it uses to decide which tools to call. A malicious document can talk the agent into making a privileged call. This is indirect prompt injection.

OAuth access tokens and WIMSE workload credentials say who the caller is and what it's allowed to do. They say nothing about what the model had read when it picked the tool.

This draft wants every tool call to carry a signed statement of how "tainted" the agent's context was. The receiving service must reject a state-changing call from a tainted context unless an approval receipt is attached.

How It Fits In

The header says "WIMSE / OAuth Working Group". The draft uses nothing from either.

There is no access token, no authorization server, no Workload Identity Token and no Workload Proof Token anywhere in the mechanism. OAuth, GNAP and WIMSE appear only in the abstract and introduction, as things that don't solve this problem. The four normative references are RFC 2119, RFC 8174, JCS (RFC 8785) and EdDSA (RFC 8032).

Is this in WIMSE's charter? No. WIMSE covers identifying and authenticating workloads. This is a claim about the internal state of an LLM runtime, which is a different topic from the identity of the workload running it.

The one real dependency is the author's own trace verification draft, draft-durga-agenttrust-trace-verification. This draft says it complements that one. It isn't listed in the references.

It also creates two new roles without defining them: an "independent policy decision engine or human verifier" that signs approval receipts, and a "relying-party gateway" that enforces the rules.

What It Defines

The whole mechanism is about one page.

The Context Taint Attestation. The agent runtime signs a JSON object and sends it with every tool call. Over HTTP it goes in an Agent-Ctx-Isolation header. In MCP it goes in a _meta.ctxIsolation object. It contains:

  • A digest of the system prompt
  • A Merkle root over every retrieved document and tool output in the context window
  • A taint level: TRUSTED_ONLY, MIXED_TAINT, UNTRUSTED_INGESTED or QUARANTINED
  • An effect class for the tool being called, such as STATE_MUTATING
  • A hash of a step-up approval receipt
  • A 60-second validity window and an Ed25519 signature

Three rules. Once the context takes in any byte from an unverified source, the taint level can't go back to trusted until a "cryptographic context-reset boundary". A service receiving a state-changing call from a non-trusted context must reject it unless a valid approval receipt is attached. The Merkle root must cover everything in the context window.

That's the entire spec.

Interoperability Concerns

The agent grades itself. The runtime that might be compromised by the injected prompt is the same party that sets the taint level and signs it. The receiving service has no way to check the label. The Merkle root doesn't help, since the service never sees the context it was computed over. The signature proves which runtime made the claim, and nothing about whether the claim is true.

The tool call isn't signed. The attestation has no digest of the request, the tool name or its arguments. An attestation can be lifted from one call and attached to a different one within its 60 seconds. Nothing says invocation_id must be tracked for replay.

The caller declares the tool's effect class. The rejection rule only fires when the caller says the tool is STATE_MUTATING. A caller that labels a delete operation as read-only passes. The service owns the tool and should be the one classifying it.

Verifiers can't find the key. kid is a hash. There is no issuer, no key discovery and no link to a WIMSE credential or any other identity. The draft never says who the verifier is supposed to trust.

The approval receipt is a hash of something undefined. The rule requires a "valid, unexpired" receipt "signed by" an independent party. The attestation only carries a hash, which can't be expired or signed. An Agent-Step-Up-Receipt header is registered in the IANA section and never described anywhere else.

The serialization contradicts itself. The abstract says COSE_Sign1. Section 3 says JCS or deterministic CBOR. The example is JSON with the signature embedded inside the object being signed. The security considerations require JCS for everything. A 600-byte JSON object in an HTTP header also needs an encoding, and none is given.

Most terms have no definition. "Unverified external origin", "context-reset boundary", QUARANTINED, PRIVILEGED_ACTUATE, the difference between MIXED_TAINT and UNTRUSTED_INGESTED, Merkle tree construction, chunk boundaries, and how ERR_TAINTED_CONTROL_PLANE is returned are all left open. None of the fields are marked required or optional.

It blocks almost everything useful. An agent that reads an email and then sends a reply is tainted. So is one that reads a web page and files a ticket. Under these rules nearly every real agent action needs a step-up approval. At that point the spec is a human-approval requirement, and the approval mechanism is the part it doesn't define.

What Could Be Removed

There's very little to remove. The useful question is what's needed on the wire at all.

  • The first rule governs how a runtime tracks taint internally. No peer can observe or verify it, so it isn't a protocol requirement.
  • system_prompt_digest and data_plane_merkle_root are never checked by any verification rule. They're audit data, and belong in the companion trace draft.
  • QUARANTINED and PRIVILEGED_ACTUATE are registered or mentioned and never used.

What's left is one self-asserted label and one approval receipt. The receipt is the part with real security value, since it comes from a party other than the agent.

Writing Quality

The draft has the right boilerplate and uses BCP 14 keywords. The substance is thin.

It's far too short. Five pages, of which about one is mechanism. There's no terminology section, no field definitions, no processing rules for the sender, no error format and no threat model.

The security considerations section is two sentences, both about canonicalization and clock skew. It doesn't mention that the attester is the party under attack. For a security mechanism, that's the first thing reviewers will ask.

The vocabulary runs ahead of the content. "Taint lattice" is used throughout and no lattice is defined, only four labels with no ordering. "Deterministic invariants" are three rules, one of which can't be verified.

The IANA section asks for a media type, a new registry and two header fields in one sentence, with no registration templates.

Author

Raghuvar Karthik Durga (Microsoft) has no published RFCs and no expired drafts. Their Datatracker profile lists eight active individual drafts, all on AI agents: lineage, revocation, post-quantum delegation, trace verification, metering, model activation binding, transaction compensation, and this one.

This is a new IETF author producing a lot of drafts at once across several working groups. None have been adopted.

Bottom Line

So what should WIMSE do with this? Nothing yet. It has no connection to WIMSE credentials, and the same is true for OAuth.

The problem is real. Prompt injection turning an agent into a confused deputy is one of the main open risks in agent deployments. A self-signed taint label from the agent doesn't fix it, because the service has to trust the very component that was attacked.

The idea worth pulling out is the independent approval receipt. A draft that defined that receipt, bound it to a specific tool call, and tied the signer to a WIMSE workload identity would give the working groups something concrete to evaluate.