Google ADK A2A · Technical case study · November 2026

Google ADK asked the owner to approve A. Its workflow used that approval to write B.

An owner opened a workflow confirmation for A in an ADK A2A task. A second authorized caller sent B into the same context. The owner answered the original A task, and a separate protected receiver recorded B in three fresh runs on an owned Google Agent Runtime.

Owned Agent RuntimeTwo A2A callersProtected receiver readbackPinned source proof
3 / 3hosted B commits

The confirmation shown to the owner named A. The later B invocation carried the same product-generated confirmation identity. The owner responded to the original A task; independent receiver records showed B. An A-only control wrote A, and a guarded B comparison denied B.

The finding

A confirmation for one target resolved a later invocation for another.

The application’s protected function was a native ADK Workflow node with require_confirmation=True. The owner’s card showed target A. The second caller supplied target B before the owner answered.

AAuthorized A-only control: the protected receiver wrote A
BInterleaved candidate: A’s original response led to a B write
DeniedGuarded B comparison: the protected receiver rejected B
ComparisonOwner actionIndependent receiver result
Authorized A controlApprove the A requestA committed
Interleaved A/BRespond to the original A task after B enters the contextB committed in three fresh hosted contexts
Guarded BDeny the protected B actionB denied

Each hosted B run used a fresh context. The receiver’s attempt log and owner readback checked the action separately from ADK’s own events. The control cells establish what the same protected function did with an ordinary A approval and with a guarded B request.

A2A ingress

The second caller knew the context and could invoke the runtime.

Both principals had permission to invoke the owned Agent Runtime. The second held an explicit Agent Platform User grant and sent B with the pending A2A context ID while the owner’s A request waited.

Owner opens AThe original A2A task presents the A confirmation.
Second caller sends BA new task enters the same context.
Owner answers AThe response goes to the original A task.
Receiver writes BA separate protected endpoint records B.

The two A2A tasks had different task and invocation IDs. In the tested deployment, ADK’s converter received no authenticated call_context user to distinguish the IAM-authorized callers. In google-adk==2.13.0, that converter falls back to A2A_USER_<context_id>. The shared context therefore produced the same synthetic user and session for both calls.

The protected function’s confirmation ID matched across the A and B invocations. The owner responded through the original A task. The runtime then resolved the newer B invocation, and the protected receiver recorded B.

Exact prerequisites

A native workflow with a confirmation-gated function, a pending A task, a second principal permitted to invoke the same runtime, and the pending A2A context ID. The tested converter path used its context-derived user fallback.

Source and mechanism

The card identity followed the node path, not this invocation’s arguments.

The separate source-bound proof pins google/adk-python to commit 8cd3b12c8a5d658c5e0d3ea0731d8be34a092a4a. In src/google/adk/workflow/_function_node.py:833, the confirmation request uses node_path=ctx.node_path.

The route is Runner.run_async → Workflow → FunctionNode._run_impl → protected_write. For repeated calls to the same FunctionNode in the session, the node path can repeat while the bound arguments change from A to B. The confirmation identity derived from that path also repeats. The local trace checks the A and B cards, their IDs, the resolved invocation, and the protected callback.

The hosted effect used packaged google-adk==2.13.0 with a2a-sdk==1.3.0. The pinned source proof used the separately archived 2.12.0 revision. These are two measured layers of the case: the hosted two-caller effect and the source-bound FunctionNode trace.

The approval boundary

A response to a confirmation for A should authorize the specific function invocation and arguments shown to the owner. Here the product-generated identity could designate a later B invocation in the same session.

Pinned revision
8cd3b12c8a5d658c5e0d3ea0731d8be34a092a4a
Source archive
SHA-256 ef19b27dbf18116ef72c7c53cb2559cd312b9c8cac9dfad37029ac9bbee49cf2
Replay and controls

Fresh runs checked the identity and the effect.

The investigation repeated the A/B/guarded comparison in the hosted runtime and in an independently runnable local package.

Hosted A2A

Three fresh contexts committed B.

Two IAM-authorized callers entered the owned Agent Runtime through A2A. The owner’s original-task response resumed the B invocation. Receiver attempts and readback confirmed three B writes.

Receiver checked

The hosted comparison also included an A-only commit and a guarded B denial. The targets were synthetic A/B markers in an owned deployment.

Local source-bound replay

The pinned FunctionNode reproduced A, B, and denial.

Three fresh pinned-source runs each checked the source path, confirmation identities, protected receiver attempt, and owner readback.

3 fresh runs

Original behavior

The authorized control wrote A. Approval of the original A card resolved the retargeted invocation and wrote B. The guarded B case was denied.

Reference repair

Three fresh reattacks blocked B while preserving the A control. This tested a local ambiguity check on the pinned source.

A local A2A replay also exercised two ephemeral caller tokens over actual A2A JSON-RPC in three fresh contexts, with A and guarded controls. The hosted experiment used Google IAM; the local replay models that caller separation at its own ingress. The package’s offline verifier checks its archived evidence and hashes before fresh runs.

Correction to verify

Carry caller and invocation identity into the final action.

Bind an A2A context to its authenticated caller or explicit participants. Assign every pending workflow confirmation a unique invocation identity tied to its node and canonical arguments.

At response time, match the caller, session, pending invocation, and arguments shown on the card before dispatching the protected function. Reject an ambiguous or stale response. A regression test should open A, interleave B from the second caller in the same context, answer the original A task, and read the receiver: A remains authorized and B remains untouched.

The local reference repair applied an ambiguity check to the pinned workflow source. In three fresh reattacks, B reached no protected receiver while the A control continued to work. That is a tested proposal for this path; the full caller-to-context binding belongs in the runtime boundary as well.

Measured scope

The hosted result covers two authorized callers sharing a known context in one owned Google Agent Runtime, with synthetic A/B targets. The record establishes the wrong-target approval effect under those conditions and makes no claim about customer data or another tenant.

Public context

Adjacent reports describe different confirmation problems.

We compared the result with public ADK issues before isolating this two-caller, product-generated identity collision.

Issue #6198 describes a confirmation and resume loop. Issue #5617 concerns an application-supplied repeated interrupt ID in the development UI. Issue #6461 describes an A2A peer supplying its own approval. Our test followed the owner’s response to the original A task through two authorized runtime callers, a product-generated FunctionNode ID shared with B, and a protected B write.

An approval has a target.

The owner saw A and answered A’s original task. The protected receiver committed B. Approval has to follow the exact caller, invocation, and arguments all the way through execution.

Work with Kronowave

What did the protected system do after the owner clicked approve?

We trace the caller, card, workflow invocation, and receiver effect, then reattack the proposed correction against the same action.

48-hour Rapid Scan →