Loom, the partner-agent tool never runs the pause that was patched onto it
In-group invoke on an ADK agent that already has A2A enabled. Loom rebinds check_require_confirmation on the AgentTool. google-adk 2.13.0 AgentTool.run_async never awaits it, so the partner call completes. The same policy still pauses a FunctionTool and the Strands partner tool.
- Name
- Loom, the partner-agent tool never runs the pause that was patched onto it
- Type
- 0-day analysis
- CVE
- n/a
- CVE Risk
- medium
- Disclosure Status
- public
- Vendor
- Loom
- Affected
- Loom for AWS ADK image. Container SUCCESS on v1.9.0 (a3050669f5b4c83210a44ed4346f17e01641e82f) against google-adk 2.13.0. v1.10.3 (cc10ab08573087fa12154f7c8181ffcd985fea88) still pins google-adk==2.13.0 in agents/adk_agent/requirements.txt and still returns AgentTool. Not re-run in a container on v1.10.3. Not the websocket omit.
- Published
- 16 Nov 2026
- Updated
- 16 Nov 2026
- Tags
- 0-day, loom, aws, cwe-862, adk, a2a, hitl, authenticated
The stamp is on the tool. The run method never reads it.
The comment above the patch says the confirmation method works for any tool, because the signature is shared. I believed that for about twenty minutes. The signature is shared. The call is not. FunctionTool.run_async awaits check_require_confirmation. AgentTool.run_async in google-adk 2.13.0 does not. Loom's A2A client returns an AgentTool.
The pack is abraxas/loom-adk-a2a-hitl, and the loopback client is loom-adk-a2a-hitl-Abraxas-Labs.py. @abraxas_null. Upstream is awslabs/loom.
A person who can already invoke an agent in their group, when that agent is the ADK image and a partner agent is already turned on, can have the partner call finish without the pause the operator configured. An ordinary function tool under the same rule does pause. The Strands partner tool pauses too. Nobody new gets in. HTTP still attaches the policy list for Strands. This is a class that never consults the method, not a missing field on a socket. That socket bug is a different pack, loom-ws-hitl.
Loom again, still no CVE. CWE-862. Medium 6.5 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N). Remote. Low privilege, in-group invoke, no second click, scope unchanged. Integrity high because the pause does not run and the tool completes. Confidentiality and availability none. Confidence about 90 percent. The counter on the predicate was zero, and the tool returned. Not code execution. Not an unauthenticated bug.
A2A, said without the acronym, is the agent handing a question to a second agent. The pause was supposed to happen before that handoff. On this image the handoff is a tool class that never looks at the pause.
Where I was when I found the comment
HTTP invoke already puts approval_policies on the AgentCore payload. That part works. Strands registers one hook and runs it before every tool, including the partner tool it names a2a_partner. ADK rebinds check_require_confirmation on each tool and the ADK tests call that method directly. They do not drive AgentTool.run_async. A unit test of the predicate is not a test that the framework enters it.
I am not refiling CVE-2026-103956, fixed in v1.6.1, or CVE-2026-103957 and CVE-2026-103958, fixed in v1.7.0. Websocket invoke without a token is closed: first frame JWT, close 1008. The caller here is authenticated, in the group, on an agent that already has the partner enabled.
google-adk is not vendored. On v1.10.3, agents/adk_agent/requirements.txt still pins google-adk[a2a,extensions,mcp]==2.13.0. The lab imported that version and printed AgentTool.run_async. The string check_require_confirmation is not in it. It is in FunctionTool.run_async. Assigning the method does not change a run_async that never looks the attribute up.
The rebind, and the return
apply_confirmation_to_tools at agents/adk_agent/src/integrations/approval.py line 158:
for tool in tools:
async def _check_require_confirmation(
self: BaseTool, args: dict[str, Any], tool_context: ToolContext
) -> bool:
...
policy = matcher.find_matching_policy(self.name)
if policy is None:
return False
...
return True
tool.check_require_confirmation = types.MethodType(_check_require_confirmation, tool)The docstring says MCP tools and A2A tools cannot take a FunctionTool predicate at construction time, so rebinding sidesteps that, and that this works for any BaseTool because only the signature is standardized. The second claim is the mistake. When the matcher hits an enabled require_approval policy the rebound method returns true, which is the signal to pause. Returning true into a method nobody calls does not pause anything.
a2a_client.py line 168 is the construction:
return AgentTool(agent=remote_agent)remote_agent is a RemoteA2aAgent. The tool on the list is google.adk.tools.agent_tool.AgentTool. The lab found _check_require_confirmation bound on that instance. run_async still finished without calling it.
A name mismatch sits beside this and is not the bug. Strands keeps a2a_partner. ADK sanitizes the name, so a rule copied from Strands can miss. An empty list or a star still matches inside find_matching_policy, and AgentTool.run_async never asks, so the star does not save you. The code-interpreter name gap is a different miss. I am not writing it up here.
In plain words: a teammate who can already chat with that ADK agent. No new permission. The partner is already on.
The turn the comment cost me
I read "works for any BaseTool" and went hunting for a policy that failed to match, which is the boring cousin of this bug. Empty rules match every name. A star matches. I put that policy on three tools and counted calls.
The function tool's predicate ran. The body did not. The framework asked for confirmation instead. Lab: the predicate would pause, and the call count was 1.
The AgentTool predicate stayed at 0. The wrapped agent returned its result. I had replaced the remote partner with a recording stand-in so the lab would not need a second live runtime. The stand-in still proves the control flow: run_async finished, and the counter on the method Loom rebound did not move. agenttool-completed=yes.
Strands, same empty or star policy, tool name a2a_partner: the before-tool hook would pause. Same table, two images, opposite results. That was the point at which I stopped defending the comment.
I also almost filed this as the websocket omit. It is not. HTTP still ships approval_policies for Strands. The ADK HTTP path can carry the list, attach the matcher, and rebind the method, and the partner tool still will not call it. Fixing the socket would not fix this.
What actually happens
| Method | What it grants | Axis | Lab or inferred |
|---|---|---|---|
In-group invoke on an ADK agent that already has A2A enabled |
Reaches the AgentTool wrapping RemoteA2aAgent. |
The precondition. Not a new grant. | Lab built that tool from the product client. |
apply_confirmation_to_tools |
Rebinds check_require_confirmation on every tool, including the AgentTool. |
The patch lands. It is not the gate. | Lab-proven. Both tools showed the patched name. |
FunctionTool.run_async under an empty or star require_approval policy |
Predicate runs. The tool would pause. | Integrity gate works on this class | Lab-proven. Predicate calls 1. Would pause: yes. |
AgentTool.run_async (google-adk 2.13.0) |
Does not await the predicate. The tool completes. | Integrity. The pause never starts. | Lab-proven. agenttool-predicate-calls=0. Completed: yes. |
Strands tool a2a_partner under the same policy |
The before-tool hook would pause. | Contrast. The other image still gates. | Lab-proven. strands-would-pause=yes. |
| HTTP AgentCore payload for Strands | Still includes approval_policies when rows are enabled. |
Closed for that path | Source, and the socket pack is the one that drops the list. |
| Unauthenticated websocket | Unauthorized, close 1008. |
Closed | Not this lab's oracle. The handler is the closed one. |
| Decide-owner on an approval row | Still refuses a different caller. This path never creates the row. | The check is not reached | Inferred. No approval row, so no decide call. |
| Reading the other group's data, or taking the process down | Not what the counter shows. | Confidentiality none, availability none | Not claimed. C:N / A:N. |
I:H is the fourth row. The tool completed inside the lab process. I did not point it at a production partner and I am not dressing the stand-in up as one. The missing pause is the issue.
What I am not also claiming
| Surface | Why it stays closed |
|---|---|
| Unauthenticated anything | Invoke is in-group. The socket without a JWT closes 1008. |
| CVE-2026-103956, CVE-2026-103957, CVE-2026-103958 | Public, fixed on older tags. Not refiled. |
| The websocket policy omit | Different pack. HTTP still ships the list for Strands. |
FunctionTool and ADK MCP tools |
Those run_async methods do await check_require_confirmation. The lab's function tool paused. |
| A policy that matches nothing | Correctly does not pause. The bug is a policy that matches, on a class that never asks. |
Strands a2a_partner |
Would pause under the same empty or star policy. |
| Cross-group | The caller is inside the group of an agent that already has A2A on. |
| Code execution | The partner call returns. That is not a shell. |
| google-adk floating upward by itself | The lock on v1.10.3 is still ==2.13.0. |
An ADK agent with no partner configured does not hit this return. The client only builds the AgentTool for an enabled A2A entry.
The run
google-adk 2.13.0 on the import path. Product apply_confirmation_to_tools and product _build_a2a_tool. One policy. Three counters: function tool, agent tool, Strands hook.
python3 loom-adk-a2a-hitl-Abraxas-Labs.pySUCCESS LOOM-190-ADK-A2A-HITL agenttool-predicate-calls=0 LOOM-190-ADK-A2A-HITL-WITNESSThe zero came from a container of Loom v1.9.0, commit a3050669f5b4c83210a44ed4346f17e01641e82f. v1.10.3, commit cc10ab08573087fa12154f7c8181ffcd985fea88, still returns AgentTool from a2a_client.py and still rebinds the method in approval.py. The dependency line is still google-adk[a2a,extensions,mcp]==2.13.0. I did not re-run these three containers on v1.10.3. Same functions, same pin, no second SUCCESS line.
What to change
Do not treat a rebound check_require_confirmation as a gate on AgentTool until AgentTool.run_async awaits it the way FunctionTool.run_async does. Until then, wrap the partner in a class whose run_async calls the predicate and requests confirmation on true, or do not expose A2A on the ADK image under this policy. A star rule that returns true inside a method nobody calls is a comment. Move the lockfile only when the new AgentTool.run_async contains the call, and test run_async rather than the unbound predicate. The Strands hook was the control, and it paused.
References
- awslabs/loom v1.9.0
a3050669f5b4c83210a44ed4346f17e01641e82f, v1.10.3cc10ab08573087fa12154f7c8181ffcd985fea88 apply_confirmation_to_toolsAgentToolreturngoogle-adk==2.13.0- CWE-862
- CVSS 3.1 calculator
abraxaslabs.tech · github.com/abraxas · abraxas.null@proton.me