
Reasoning Anchored Delegation (RAD): A Protocol Proposal for Trustworthy Multi Agent Chains
Current AI agent protocols verify who an agent is but not whether what it is doing matches its original mandate. This post proposes RAD (Reasoning Anchored Delegation), a protocol primitive that anchors every delegation in the cryptographic hash of the delegating principal's reasoning, enabling verifiable intent continuity across multi agent chains with no central authority required.
Author: Abdul Muqit, Solutions Architect, Amazon Web Services
Date: August 2026
Audience: Solutions Architects, ML Engineers, Agentic System Builders
1. The Gap: Identity Disconnected from Protocols
Every production AI agent needs six things to run reliably: identity and access, safety and policy, observability and evaluation, the right tools and actions, knowledge, and memory. The protocols that connect agents to each other sit below all of that, at the interoperability layer. MCP handles agent to tool connections. A2A handles agent to agent delegation.
Here is the problem. Identity and access sits at the top of the stack, defined at deployment time, managed by IAM, enforced by the production control plane. Protocols sit at the interoperability layer, carrying messages between participants. These two layers do not talk to each other in any current standard.
Once an agent receives a valid delegation token, no protocol in existence can tell the difference between "this agent is doing exactly what it was asked to do" and "this agent has gone rogue." It looks identical on the wire.
The missing layer is runtime behavioral authorization: the ability to verify not just who an agent is, but whether what it is doing right now is semantically consistent with what it was originally asked to do.
What Exists Today and Where It Falls Short
Protocol | What it solves | What it does not solve |
|---|---|---|
MCP (Anthropic) | Agent to tool connections, OAuth 2.1 for server auth | Identity travels with the session, not the delegation chain |
A2A (Google, Linux Foundation) | Agent to agent task delegation, agent card signing | Signs the card at registration, not the action at runtime |
HDP (Helixar Delegation Protocol) | Signs each delegation hop in an append only chain | Signs the hop metadata, not the reasoning behind the hop |
DRP (Delegation Receipt Protocol) | Signs task scope and operator instruction hash | Scope boundary only, no semantic continuity check |
AIP (Agent Identity Protocol) | Invocation-Bound Capability Tokens for identity and scope | Identity and permission, not intent |
AgentCore Behavioral Contracts | Post-execution validation of process steps and ordering | Single agent, post hoc, no delegation chain awareness |
Every existing protocol answers "who" and "what." None of them answer "why." That is the gap.
A scan of approximately 2,000 MCP servers in 2026 found every one of them lacked authentication in practice. And Microsoft's own Entra Agent ID team acknowledged the deeper problem directly: "An agent can hold a valid Entra-issued token, pass Conditional Access checks, and still be doing something it should not."
Signing the agent card at registration time is not the same as verifying the agent's intent at execution time. No current standard bridges those two moments.
The Concrete Threat: When a Sub Agent Goes Rogue
Consider a standard multi agent pipeline. An orchestrating agent receives a task from a human, delegates subtasks to specialist agents, and assembles the final output. This is the most common agentic pattern today, and it is the pattern that existing protocols leave entirely unprotected at the semantic level.
Path 1: Prompt injection. Agent B reads a document containing hidden instructions. It follows them because it cannot distinguish malicious content from legitimate task input. It then propagates that behavior to every peer agent it coordinates with via A2A. Agent A, the delegating orchestrator, has no way to detect this because Agent B's A2A messages are structurally valid.
Path 2: Compromised sub agent. Agent A delegates to Agent B. Agent B is compromised mid-execution. It holds a legitimate identity token. There is no kill switch. Tasks it already forwarded to Agent C continue running even after Agent B is detected and terminated.
Path 3: Delegation abuse. An agent authorized for a narrow task delegates to a peer and grants it a scoped permission. The delegated agent misuses that permission to request actions from a higher-privileged agent, escalating effective permissions beyond what the original human authorized. Each individual hop looks valid. The chain as a whole is not.
All three paths share one root cause: the authorization set at delegation time does not travel with the action at execution time.
2. The Proposal: Reasoning Anchored Delegation (RAD)
This post proposes a new protocol primitive: the Reasoning Commitment Hash (RCH).
To be precise: RAD is not a standalone protocol from scratch. It is a protocol extension on top of A2A. It defines new fields in the delegation token format, a new attestation handshake before message forwarding, a revocation broadcast message type, and a shared Merkle chain data structure. Any conforming participant can implement it regardless of their internal framework. That is what makes it a protocol primitive rather than an internal process.
The idea has two names. Reasoning Anchored Delegation (RAD) emphasises the mechanism: the reasoning chain is the cryptographic anchor, not just the task or the scope. Intent Bound Delegation (IBD) emphasises the outcome: every agent in the chain is bound to the original human intent, not just to a permission boundary defined at registration time. Use either. They describe the same protocol.
Both names are original to this proposal as of August 2026. The RCH as a semantic root anchor does not appear in any existing IETF draft, academic paper, or protocol specification. Existing protocols sign what an agent is allowed to do. RAD signs why the agent decided to do it. That distinction is the entire contribution.
The Five Components
When a human or root agent creates a delegation, it signs not just the task and scope, but a hash of its causal reasoning: why this task is being delegated, what outcome is expected, and what constraints apply. This hash becomes the cryptographic anchor for everything that follows.
1. Reasoning Commitment Hash (RCH) Hash of causal reasoning, signed by the delegating principal. The hash proves the reasoning has not been tampered with in transit. The signature proves who authorized it. Without signing, any participant could inject their own valid-looking hash. Together they give tamper-evidence and root attribution at near-zero compute cost (SHA-256 + Ed25519, microseconds each). Travels with every downstream delegation token.
2. Action Attestation Before each action, the executing agent produces a reasoning chain. A lightweight verifier checks semantic continuity with the RCH. The action is blocked if reasoning diverges from original intent.
3. Output Commitment Hash (OCH) Hash of the expected result schema and scope, set at delegation time. On return, the delegating agent verifies: nothing more, nothing less. Catches both exfiltration (more) and lazy or incomplete agents (less).
4. Merkle Chained Verification Receipts Each executed action is appended as a signed receipt. The chain is anchored to the original RCH. Tamper evident and verifiable by any participant with only the root key.
5. In Flight Revocation Any participant can broadcast a revocation against a delegation token. All agents holding that token stop immediately. Outstanding delegated tasks are rolled back via the Merkle chain.How a Generic Agent Chain Looks with RAD
Take a standard three-agent pipeline: an orchestrator, a data retrieval specialist, and a decision agent. A human initiates a task.
Human signs task at T=0 Delegation Token = { task: "process insurance claim for member 001", scope: { data_sources: ["coverage-api", "formulary-api"] }, RCH: hash("process claim 001, check coverage first, decision must cite policy source, no access to billing history, no external data transmission"), OCH: hash({ decision, policy_citation, member_id }), signed: human_private_key }
Orchestrator Agent receives token Produces reasoning plan for the task Action Attestation: reasoning verified as continuation of RCH OK
Delegates to Retrieval Agent: token inherits RCH from parent scope narrows to coverage-api only new OCH: { coverage_status, policy_section }
Retrieval Agent executes Action Attestation: reasoning verified against RCH OK Fetches coverage data, returns result Verification Receipt appended to Merkle chain
Retrieval Agent (compromised version): Reasoning now includes "also query billing history" Action Attestation check against RCH: FAIL Action blocked. Revocation broadcast to chain. Orchestrator notified. Human escalation triggered.
Decision Agent receives retrieval result Produces decision with policy citation OCH check on final output: nothing more: no billing history, no full member record OK nothing less: decision and citation both present OK
Merkle chain: full audit trail verifiable by any participant. No external authority required.The nothing-more check catches exfiltration. The nothing-less check catches the lazy agent that answers from training data instead of doing the actual work. This is the same problem AgentCore behavioral contracts already surface, now enforced at the protocol level before the action executes rather than detected in audit afterward.
The Extreme Case: When There Is No Safety Net
The generic example above assumes a monitored environment, some human reachability, and network connectivity. RAD becomes most critical in scenarios where none of those are available.
Autonomous Drone Swarm. A fleet of drones executes a coordinated mission with no ground operator available mid-flight. The swarm uses a peer to peer A2A mesh. A human operator signed the mission at T=0 and is now unreachable.The command center is compromised mid-mission and broadcasts new target coordinates to Drone 7. With current protocols, Drone 7 has no way to distinguish a legitimate mission update from a malicious override. It follows the command.With RAD: Drone 7 checks the instruction against the original RCH signed by the human at T=0. The new coordinates fall outside the declared intent boundary. Attestation fails. Drone 7 ignores the command and broadcasts a revocation signal to the swarm. No cloud call, no latency, no central controller.Meanwhile, Drone 5 has been sensor-spoofed and is broadcasting false telemetry to its peers. Its A2A messages are structurally valid. Peer drones verify each report's action attestation against Drone 5's delegation token. The reports contradict Drone 5's own prior RCH (assigned to zone C, reporting from zone F). Peers reject the data. Swarm quorum excludes Drone 5. The mission continues on the correct course.This is RAD working with zero cloud dependency, on resource constrained hardware, with lives on the line. The same protocol that governs a claims processing pipeline governs a drone swarm. The threat model is the same. The stakes are different.
Who Needs This and How Much of It
RAD is a spectrum, not a binary. The right question is: if a sub agent in my chain acts outside its mandate, can the damage be undone in under an hour, and does it affect one person or many?
Full RAD is essential for defense and government, financial services (autonomous trading, fraud decisioning, AML chains), healthcare (diagnostic and care coordination chains), and critical infrastructure. In these industries, a rogue agent acts before anyone reviews the logs. Post hoc audit is not an acceptable answer.
The Output Commitment Hash alone delivers most of the value for insurance claims automation, legal and compliance agents, and enterprise SaaS workflows touching PII. The nothing-more check catches exfiltration. The nothing-less check catches incomplete or fabricated outputs. Together they cover the most common failure modes without requiring the full cryptographic stack.
Behavioral contracts (already available in AgentCore today) are the right starting point for marketing automation, internal productivity agents, research workflows, and customer support for low-stakes queries. RAD can be adopted incrementally as these systems grow in autonomy.
The key message: security is a day 0 concern for every business running autonomous agents, but it does not have to be a barrier to getting started. The Output Commitment Hash requires no new infrastructure. It is an extension of the behavioral contract YAML deployable on AgentCore today. Start there.
3. Three Hard Problems RAD Opens Up
RAD solves the root gap. But building it in the real world immediately reveals three open problems. These are not competitors to RAD. They are the research agenda that RAD makes necessary and coherent. The protocol is only as good as the solutions to these three problems.
Problem 1: How Do You Verify Reasoning Continuity Without Exposing It?
RAD's action attestation requires a verifier to check whether an agent's reasoning chain is semantically consistent with the original RCH. But the reasoning chain may contain proprietary business logic, confidential customer data, or sensitive model behavior that cannot be shared across organizational boundaries or with a third party verifier.
Zero knowledge proofs solve this. An agent proves "my reasoning is consistent with the RCH" without revealing the actual reasoning to anyone. The verifier receives only a cryptographic proof, not the thought process. A 2026 cryptography paper from IACR (zkAgent) proposes proofs of the complete LLM inference pipeline, from token embedding to output decoding, binding each tool call to an authenticated execution without exposing private inputs.
Without this, RAD requires every verifier node to be trusted with your agent's full reasoning. With it, RAD becomes viable in multi organization, cross vendor, and regulated deployments. This is the hard engineering problem that unlocks the broadest adoption.
Problem 2: How Do You Express Constraints Precisely Enough to Enforce?
The RCH is a hash of reasoning. But "check whether two reasoning chains are semantically consistent" is a vague instruction for a deterministic system. Free form text is difficult to enforce reliably at protocol level.
Deontic policy languages provide a structured grammar for obligations and prohibitions borrowed from formal logic and law. Instead of hashing unstructured reasoning, you express intent as machine-verifiable rules: the agent MUST check coverage before rendering a decision; the agent is PROHIBITED from accessing external endpoints unless triggered by a signed human approval event. The policy engine runs entirely outside the LLM, deterministically, and is auditable by engineers, lawyers, and regulators alike.
This makes RAD's constraints precise rather than approximate. It also makes the RCH itself more structured: not a hash of free form text but a hash of a formal policy expression, which any conforming verifier can evaluate consistently.
Problem 3: How Do You Catch Drift, Not Just Individual Violations?
RAD catches a rogue action in the current execution. But what if a compromise is gradual? An agent that shifts behavior incrementally across thousands of runs would never fail a single attestation check. Each individual action looks compliant. The pattern across runs is not visible until significant damage has occurred.
An agent-native immune system addresses this by having agents collectively learn a behavioral fingerprint for each peer and flag deviations over time, analogous to how a biological immune system learns to distinguish self from non-self. No single agent is the defender. Each participant maintains a probabilistic model of its peers and votes on whether an incoming message falls within normal behavioral range.
The Merkle chained Verification Receipts that RAD produces are exactly the data the immune system trains on. RAD provides the cryptographic evidence per execution. The immune system identifies patterns across executions. Together they cover both the acute rogue action and the slow drift.
4. Call to Action
The governance layer for agentic systems is being written right now. The A2A Technical Steering Committee (Google, Microsoft, AWS, Cisco, Salesforce, ServiceNow, SAP) is actively accepting proposals. The IETF has an open pipeline for agentic identity and delegation drafts.
Three open research questions define the frontier:
1. Semantic zero knowledge proofs at practical compute cost. zkAgent proves the full inference pipeline but remains expensive at scale. The open problem is a lightweight proof of semantic intent continuity that runs in near real time on resource constrained hardware, including embedded systems and edge devices.
2. Formal deontic grammars for agent intent. Expressing the RCH as structured, machine-verifiable obligations requires a policy language that is both expressive enough for real workflows and simple enough for people without engineering backgrounds to author and audit. This is a design problem as much as a technical one.
3. Behavioral baselines across heterogeneous agent fleets. Training an immune system on a Merkle chain requires establishing what "normal" looks like for agents built on different models, frameworks, and runtimes. Cross framework normalization is an open data problem.
RAD opens the door to all three. The ideas here are stronger with more hands on them. If you are building multi agent systems, working on agentic security, exploring zero knowledge proofs for LLMs, or have thoughts on any of the above, this is an open invitation to compare notes and build on these ideas together.
How RAD Relates to What Already Exists
RAD is not a replacement for existing work. It is the missing layer between what protocols already provide and what production agentic systems actually need.
Existing mechanism | What it does | How RAD complements it |
|---|---|---|
AgentCore Behavioral Contracts | Post-execution audit of process steps for a single agent | RAD prevents the violation before it executes. Contracts catch drift across many runs. RAD stops a rogue action in the current run. Together they provide prevention and longitudinal compliance. |
A2A with HDP | Delegation hop signing | HDP signs the metadata of the hop. RAD signs the reasoning behind the hop. Both chains can coexist, referencing the same session. |
DRP | Scope and instruction hash at delegation time | DRP covers what was allowed. RAD adds why it was decided and whether the downstream agent stayed within that intent. |
MCP with OAuth 2.1 | Agent to tool authentication | RAD operates above MCP. When an agent calls a tool, the action attestation for that call is verified against the RCH before the MCP call executes. |
Microsoft Entra Agent ID | Registration and identity governance | Entra confirms who the agent is. RAD confirms whether what it is doing is consistent with its original mandate. Identity and behavioral authorization become complementary rather than disconnected layers. |
Please Note: The ideas in this post emerged from individual's research/design and represent forward-looking proposals. Not an official AWS positions or product roadmap commitment.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article