When a team of language-model agents splits a job into pieces (one agent plans, another browses, a third writes code), each agent sees only its own piece. That is what makes the team effective. It is also what makes it unsafe. A harmful goal can be cut into steps that each look harmless, so every agent's safety training waves its step through. The obvious fix is to let everyone see everything, but full visibility is exactly what lets attackers steal private data and system prompts from the team. This note proposes a third option. Give an outside auditor a global view of what was actually done, meaning the executed tool calls reduced to coarse categories and linked by which agent handed work to which. Let the auditor send back nothing but allow or block. Our claim is that the information needed to catch a laundered harmful plan lives mostly in how the actions fit together, not in the private content, so this narrow, one-way view can catch it while leaking almost nothing.
The tension is documented on both sides. Architecture Matters for Multi-Agent Security shows identical models that refuse a task alone will execute it once decomposed. On RedCode-Gen under a chain of agents, planning refusal collapses from 84.4% to 8.1%, and dense peer visibility (a mesh) is what restores oversight on web tasks. Topology Matters: Measuring Memory Leakage in Multi-Agent LLMs and IP Leakage Attacks Targeting LLM-Based Multi-Agent Systems show the opposite pressure. Dense graphs leak personal data fastest, and a self-propagating prompt extracts system prompts at 87% and network structure at 92% accuracy. No existing design gets oversight and isolation at once. We think the reason is that existing designs carry both through the same channel: the agents' own messages.
Core Claim
Separating the oversight channel from the collaboration channel resolves the topology conflict. We impose three properties on that oversight channel.
First, the audit record is produced by the runtime from executed tool calls, not written by the agents. This sidesteps the honest-explainer assumption that XAudit flags as open.
Second, each record is coarse-grained before the auditor sees it. A file path becomes "system configuration", a URL becomes a domain category, a chemical becomes a hazard class, and a code call becomes a capability class such as "network exfiltration" or "privilege change". Records are linked by handoff edges between agents.
Third, the auditor's only output into the agent network is a one-bit allow or block per gated action. The network therefore learns at most one bit per decision from the auditor, and an injected prompt has no path to ride through the auditor and back into other agents.
The collaboration graph can then stay sparse, which protects against leakage, while the auditor alone sees the composition of the whole plan, which protects against laundering.
What would be new is the measured object. Prior work treats transparency as a property of the agent graph. We treat it as a separate, adjustable channel and measure a curve. On one axis is how well harmful plans are detected. On the other is how much an adversary holding the audit stream can reconstruct. The curve is traced by sweeping how coarse the action categories are.
Relation to Prior Work
Three papers supply the threat evidence above. Multi-Agent Security Tax supplies the strongest existing defense. It plants fake memories of past refusals ("active vaccines") in each agent and reaches 90.0% robustness at 87.6% cooperation on a seven-agent chemistry simulation. That defense is local: each agent still judges only its own context, which is precisely what intent laundering exploits. Terrarium uses a central blackboard as a passive observer and shows prompt-level privacy rules fail completely, with 100% confidentiality-attack success. Our auditor is likewise a central observer, but it is active (it gates actions), it sees abstractions rather than plain text, and it cannot write content back.
On the cryptographic side, DAO-Agent and zkUCB verify scalar computations with zero-knowledge proofs, which are cryptographic proofs that a computation was done correctly without revealing its inputs. Neither reaches natural-language reasoning. We deliberately do not try to prove anything about reasoning. We audit executed actions, which are discrete and checkable. Proofs could later make the audit log tamper-evident, but they are not the core claim.
Two further papers constrain the design. DOGe protects reasoning by deliberately corrupting intermediate traces, which would break any monitor that reads traces. Because our auditor never reads traces, it remains compatible with such protections. Contextual Integrity in LLMs via Reasoning and Reinforcement Learning frames privacy as appropriate information flow, meaning whether a given piece of information should travel between given parties in a given context. Our coarse-graining is a concrete, measurable instance of that idea: the auditor receives exactly the attributes its job needs. Finally, P2NIA shows auditing can be done without raw visibility for single tabular models, but it does not address decomposed pipelines.
Research Program
We will build a runtime wrapper around existing multi-agent harnesses. It has three parts. The first intercepts every tool call and maps it to a category from a fixed vocabulary. The vocabulary is defined at several levels of coarseness, from near-raw arguments down to tool name only. The second records which agent's output fed which agent's input. The third holds high-risk actions until the auditor returns a bit.
The auditor sees only the categorized action graph. It will be tried in two forms: a prompted frontier model, and a small model fine-tuned on synthetic decomposed plans. Training uses BrowserART-style tasks, and testing uses OS-Harm and RedCode-Gen so that the result reflects transfer across domains rather than memorized patterns.
We will then run two kinds of adversary. The first is a laundering adversary who knows the category vocabulary and tries to choose action sequences whose categories look benign. The second is an extraction adversary who receives the full audit stream and tries to recover the personal data and system prompts behind it.
The two adversaries pull in opposite directions as the categories change. Finer categories should catch more laundering but leak more. Coarser categories should leak less but be easier to evade. The shape of that curve, and whether it has a "knee" where detection is high and leakage is near the floor, is the central scientific question.
Baselines
The naive reference point is the decomposed system with no oversight, run in the chain and star topologies from Architecture Matters. That paper reports harmful-task completion rising from 10% for a standalone agent to 31–38% for specialized multi-agent setups on BrowserART, and the 84.4%-to-8.1% planning-refusal collapse on RedCode-Gen. We also run the standalone single agent from that paper as a second reference. Beating this reference means pulling harmful-task completion below the multi-agent level, toward or under the standalone 10% on BrowserART, without giving up the benign-task advantage that motivates decomposition.
The topology baseline is the mesh with shared memory. It is the configuration that paper found safest for browsing, and it is the natural "just make it transparent" answer. Beating it means matching its harm reduction while showing SPIRIT and MASD leakage at sparse-graph levels instead of complete-graph levels.
The strongest existing defense is active vaccines from Multi-Agent Security Tax, with the reported 90.0% robustness and 87.6% cooperation. We will re-run it in our harness, with the same base models and the same task sets, and tune its vaccine prompts with the same budget we spend tuning the auditor's prompt. Beating it means higher robustness at equal or better cooperation on our harness, measured on both the chemistry simulation and the laundering benchmarks.
The most dangerous competitor is a full-trace monitor: an LLM that reads every inter-agent message and also returns only allow or block. No reported result was found on Lacuna for a full-trace monitor on BrowserART, OS-Harm, or RedCode-Gen, so we establish it ourselves with the same model and tuning budget as our auditor. We also run a version of it that can write feedback into the network, and a version that reads traces with personal data scrubbed.
Two ablations isolate the key ingredients. The first replaces runtime-derived records with agent-written self-reports, which tests whether grounding the record in executed actions matters. The second gives the auditor each agent's actions separately rather than the linked graph, which tests whether seeing how the actions compose is what catches laundering.
Why not just…?
Why not just pick the right topology per task? Architecture Matters and Topology Matters jointly show that the topology best against laundering, the dense mesh, is the one worst for leakage. A per-task topology choice therefore just picks a point on a bad tradeoff. Our mesh-versus-chain baselines measure both axes for each topology, and the proposal must dominate both points to be worth building.
Why not just a full-trace LLM monitor with one-bit output? This is the real threat. It may detect laundering as well as or better than our auditor, because it sees strictly more. The difference is who learns what. A full-trace monitor reads all personal data and system prompts by construction, so for a third-party auditor it fails the privacy requirement before any attack is run. The experiments settle this by placing both monitors on the same detection-versus-reconstruction plot. If the full-trace monitor's detection advantage is large and our coarsest useful categories still leak heavily, the separation idea fails. In that case we would report that composition alone is insufficient.
Why not just harden each agent with active vaccines or safety prompts? Passive prompts cut cooperation to 52.3% in Multi-Agent Security Tax. Prompt rules leaked in every run in Terrarium. Vaccines are stronger, but they act locally, and laundering by construction makes each local step look benign. The ablation that removes the linked graph directly tests whether a local view can catch decomposed harm.
Why not just use one monolithic model? Specialized teams beat standalone agents on OS-World and BigCodeBench in Architecture Matters, so dropping decomposition gives up utility. And MASLEAK finds stronger instruction-followers are more, not less, extractable.
Proposed Experiments
Harm is measured on BrowserART, OS-Harm, and RedCode-Gen, using the planning-refusal, execution-refusal, harmful-action, and harmful-task metrics from Architecture Matters. Utility and false blocks are measured on OS-World and BigCodeBench. Spread of injected prompts is measured on the chemistry simulation from Multi-Agent Security Tax. Leakage to the auditor is measured in two ways. We run MASLEAK-style reconstruction on the MASD configurations against the audit stream, scoring the fraction of system prompts and topology recovered. We also run personal-data extraction against audit streams generated from SPIRIT's 104 seeded items, against the 29%-to-6% adjacency-dependent baseline reported for circle topologies. Terrarium's Collab tasks provide a second confidentiality check.
The decisive check has four parts, all of which must hold for the claim to stand. Some granularity level must cut harmful-task completion in a chain topology to at or below mesh level. That same level must keep auditor-side recovery of SPIRIT personal data and MASD system prompts near the score of an attacker given no audit stream. An injected propagating prompt must provably fail to cross the one-bit channel. And the linked-graph auditor must clearly outperform the per-agent ablation.
If the adaptive laundering adversary can drive detection to chance at every granularity that keeps leakage low, the claim is refuted. We will report that outcome as a negative result about how much of a harmful plan can be read from its structure alone.
References
- Architecture Matters for Multi-Agent Security
- Topology Matters: Measuring Memory Leakage in Multi-Agent LLMs
- IP Leakage Attacks Targeting LLM-Based Multi-Agent Systems
- XAudit : A Learning-Theoretic Look at Auditing with Explanations
- Multi-Agent Security Tax: Trading Off Security and Collaboration Capabilities in Multi-Agent Systems
- Terrarium: Revisiting the Blackboard for Multi-Agent Safety, Privacy, and Security Studies
- DAO-Agent: Zero Knowledge-Verified Incentives for Decentralized Multi-Agent Coordination
- Privacy-Preserving UCB Decision Process Verification via zk-SNARKs
- DOGe: Defensive Output Generation for LLM Protection Against Knowledge Distillation
- Contextual Integrity in LLMs via Reasoning and Reinforcement Learning
- P2NIA: Privacy-Preserving Non-iterative Auditing