
Dogwood Across the Wire: Making Agent Intent Both Enforceable and Portable
Dogwood made intent enforceable inside one agent. But a rule that cannot cross a trust boundary does not survive a handoff. This post proposes treating delegation as compilation: each hop must provably narrow the policy it received, and signed event history travels with the task so temporal rules evaluate across organizational boundaries.
Personal research and a forward-looking proposal. Not an official AWS position or product roadmap commitment.
Takeaway: Dogwood made intent enforceable. Reasoning Anchored Delegation makes it portable. A rule nobody can carry does not survive a handoff; a commitment nobody can evaluate does not stop anything. You need both, and the way to get both is to treat delegation as compilation.
How I got here
Yesterday I published Reasoning Anchored Delegation (RAD). The argument was that identity protocols for agents tell you who an agent is and what it is allowed to touch, but never why it is acting. Once an agent holds a valid token, nothing on the wire distinguishes "doing its job" from "gone rogue." RAD proposed signing the original intent at the root of a delegation chain and checking every downstream action against it.
I left one question open on purpose. The Reasoning Commitment Hash was a commitment to intent, but intent expressed as reasoning is hard for a deterministic system to evaluate; a verifier can check that two things are identical, not that one is consistent with the other. I listed "a formal grammar for intent" as the problem that would unlock the rest.
I shared the post with my manager the same day. He sent back the AWS Open Source post introducing Dogwood, which had come out a couple of weeks earlier. My first reaction was the obvious one: had a team at AWS already solved this, and was RAD a duplicate effort? I spent time working through what Dogwood was actually built to do. Dogwood extends Cedar, the policy language behind AgentCore Policy, with one new ability: a policy can look back at what an agent has already done. It is not solving the delegation problem. It is solving the grammar problem (the exact piece I had left open) and it stops precisely where RAD starts. Different pieces of the same puzzle, and they fit.
Along the way I also spent more time with the two IETF drafts closest to RAD: the Intent Provenance Protocol (IPP) and the Human Delegation Provenance protocol (HDP). Both carry signed intent in a token, and HDP's draft notes that checking an action against that intent is "application-defined." That phrase is the whole story: the intent is on the wire, and nothing evaluates it. This post is about closing that distance.
What Dogwood does, in one example
Traditional authorization asks "is this request allowed?" and looks only at the request. Dogwood can also ask "given what happened before?" Here is a rule that says once an agent has read member data, it may never send anything outside:
forbid ( principal, action == AgentCore::Action::"SendExternal", resource )when temporal { formerly within 24h AgentCore::Action::"ReadMemberRecord"::response{ output.member_id: _ }};Deterministic, readable, built on a formal logic; the same inputs always give the same verdict. The authors were equally clear about what it does not do yet: it governs one agent's history, it expresses what must not happen but not what must happen, and multi-agent orchestration is "where we ultimately want to go."
One thing to hold onto as you read the rest: most of the pieces below exist. Signed intent in a token is IPP and HDP. Temporal policy is Dogwood. "Delegation can only narrow" is a long-standing idea from capability systems like UCAN and Macaroons. Chained signed receipts are HDP's hop chain. Two things here are new, and I'll be direct about which: the claim that history should travel with the task, and the framing that ties everything together.
Where a delegation chain breaks
Picture a claims pipeline: a human authorizes an orchestrator agent, which delegates to a retrieval agent, often in another account and increasingly in another company. The rule above protects the orchestrator. At the handoff it fails twice:
- The rule does not travel. The retrieval agent's policy engine has never seen it, and nothing proves any copy it holds is the one the human signed.
- The history does not travel. The retrieval agent's log does not contain the orchestrator's read. The rule looks back, sees nothing, and permits the send.
Those two breaks are exactly what RAD was built for. It needed something evaluable to carry. Dogwood is that something.
The proposal
Commit to a policy, not to prose. The root of the chain signs a Dogwood policy bundle and its schema. The hash of that bundle is what travels with the token. "Is this consistent with intent?" becomes "does the signed policy allow this, given the signed history?" A deterministic interpreter answers that. No classifier in the enforcement path.
Delegation can only tighten. When an agent hands off, it may add
forbid rules or shorten windows; it may never remove or widen anything. Because forbid always beats permit in Cedar, the check is a diff: every change must be a restriction. For permits without temporal clauses, Cedar's automated reasoning can prove the narrowing outright. For temporal clauses it cannot yet (and Dogwood's authors say so plainly), which is exactly why the rule matters: "shorter window or added forbid" is checkable by syntax alone, so refinement stays verifiable in microseconds even where the analysis tooling does not reach. Capability systems have done attenuation for permissions; extending it to time is a small definition, but it is the one that keeps the next step honest.Ship the history with the task. Every tool call is logged as a signed receipt, chained to the previous one. A receipt is just a Dogwood event with a signature. When the retrieval agent receives a task, it receives the receipts too, replays them into its own interpreter, and only then evaluates its first request. The rule above now sees the orchestrator's read and denies the send, across an organizational boundary, with no shared policy server. Every design I know of, Dogwood included, assumes the evaluator owns the log. Making the log a signed, prunable artifact that moves with the work is what lets a temporal policy cross a trust boundary at all.
Revocation and completion as events. Dogwood lets you declare event types beyond tool calls. Add
Chain::revoke and Chain::complete . Revocation becomes one inherited rule: forbid everything once a revoke for this chain has been seen. Completion gives you the "what must happen" half Dogwood lacks today: by the token's expiry, a verified completion must exist, which catches the agent that answered from training data instead of doing the work.Delegation is compilation
The human's policy bundle is source code. Each hop emits a strictly narrower version of it, the way a compiler emits a lower-level program that must preserve the original's meaning. The receipt chain is the execution trace. Verifying a delegation chain is then the same problem as verifying a compiler: confirm that each translation preserved what the source said, then confirm that the trace is consistent with the program that was actually emitted.
Compiler people solved the first half decades ago. Translation validation does not prove the compiler correct in general; it checks, for this one compilation, that output refines input. That is why the tightening check can be a diff instead of an argument, and why it runs in microseconds on a drone or a pacemaker with no cloud in reach. The second half (trace consistency) is what Dogwood's interpreter already does for one agent. Carrying the trace across hops lets it do the same job for a chain.
This lens is useful because it tells you what not to build. You do not need an agent to reason about whether a peer is trustworthy. You need each hop to prove its output refines its input, and each action to prove it is consistent with the output. Agents become untrusted compilers of intent, and we already know how to check those.
Where this meets Dogwood's own roadmap
The Dogwood post describes where the authors want to take it: to ensembles of agents, where the questions become "who may hand off to whom, which agent holds a lock, whether the group as a whole is making progress." That list maps almost one to one onto the proposals above. Who may hand off to whom is the tighten-only refinement rule. Whether the group is making progress is the chain-level completion event. What the roadmap does not yet name is the transport: how the policy and the history reach the next agent at all. That is the piece this post adds.
What you can build today
If you run multi-agent workflows on AgentCore, here is the version you can try this quarter:
- Write the root intent as a Dogwood bundle instead of a prose prompt.
- Sign it and attach its hash to whatever delegation token you already use: HDP, A2A task metadata, or a JWT claim.
- Log every tool call as a signed receipt chained to the previous one.
- At each handoff, ship bundle and receipts together, and replay before evaluating.
None of this requires a change to Dogwood. The refinement check and the receipt format wrap its existing parser and event model. I'm building this as a reference implementation and will share it once it runs end to end.
Does this fix agent security?
No, and you should be suspicious of anyone who claims their protocol does. Here is the ledger.
Buildable today. Intent and history both survive handoffs. No hop can loosen the rules. Revocation is a policy, not infrastructure. Exfiltration and incomplete output are caught at the schema boundary.
Open, with a plan.
- Trusting the evaluator. A signed receipt proves who signed, not that a policy check actually ran. Run the interpreter in attested execution (Nitro Enclaves or similar) so each receipt carries proof the genuine engine produced it. Engineering, not research.
- Privacy of the history. Shipping events across companies leaks data. Dogwood's sandboxed information providers are the seam: a provider that answers "a qualifying read exists in the chain," backed by a zero-knowledge membership proof, lets the rule evaluate without exposing the record.
- Slow drift. A gradual compromise never fails a single check. The receipt chain is a shared-schema log across the fleet, exactly the data a behavioral baseline needs. Statistical, with false positives.
- Liveness, trust roots, authoring. Dogwood's authors list liveness as next. Cross-company keys are standard PKI work. Readable policies need a macro library.
Not fixable by this, and why.
- Intent to policy is lossy. A policy can only forbid what its schema can name. Formal policy catches violations of what was written, never of what was meant. The compiler analogy holds here too: a compiler preserves the program you wrote, not the program you intended. Narrower schemas help, at the cost of autonomy: a business trade, not a technical one.
- Done cannot be undone. The chain proves a transfer happened; it does not reverse it. Rollback is domain logic designed in beforehand.
- Revocation cannot be guaranteed delivered. A partitioned peer keeps acting until its token expires. Short expiry bounds the damage; nothing eliminates it.
What I'm doing next
I'll be taking the proposals here (monotone refinement, portable traces, and chain-level events) to the Dogwood team, who are collecting design feedback before they open contributions, and to the A2A Technical Steering Committee. If you work on cross-organization agent pipelines, the IETF delegation drafts, or zero-knowledge predicates over event logs, reach out. I'd like to compare notes.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article