Systems built from several cooperating language-model agents, such as a planner, a coder and a tester, split a hard task into roles so that no single model has to hold everything at once. The same split creates many seams between agents. Anything that crosses a seam can carry an attack: a spoofed capability description, a flood of sub-tasks, a document with an embedded script. A recent benchmark of agent-to-agent protocols found that five such attacks succeed 100% of the time across travel, healthcare and finance domains, and that a production guardrail did not stop them (A2ASecBench).
We borrow a design answer from an unrelated field. Engineers who protect hardware from extreme heat use two tools. The first is a barrier that lets little through, such as an aerogel sheet between a pan and an induction coil or an air gap between a hot logic die and a heat-sensitive optical die. The second is a sacrificial layer that absorbs the damage and is renewed every cycle, such as the propellant additives that lay down a fresh protective film on a gun bore at each firing. We propose to give multi-agent systems both. Every untrusted input is handled by a short-lived "ablative" agent. That agent passes on only a narrow, typed summary, and it is thrown away after one task, so contamination cannot build up.
Core Claim
The specific, testable claim has two parts. First, long-lived specialist agents behave like a coating that wears down. The chance that an attack succeeds against them should rise with the number of tasks they have lived through, because injected instructions, spoofed peer descriptions and inflated task queues remain in their context and memory. Second, two mechanisms together can flatten that curve and cut attack success well below the undefended 100%, while keeping most of the benign task performance that role decomposition provides. The two mechanisms are disposing of every agent that touches untrusted content after one task, and restricting what such an agent may pass downstream to a small schema of typed fields. We call the second mechanism a low-"conductance" interface.
The thermal literature also predicts a trade-off, and we intend to measure it rather than assume it away. In the noncontact photonic–electronic integration work, a 10 µm air gap cools the photonic die by 4.6 °C. Widening the gap improves isolation but weakens the inductive coupling that carries the data. We expect the same shape here: narrowing the channel between agents lowers attack success but eventually starves downstream agents of information they need. The contribution is to map this curve and to show where the useful operating point lies.
This differs from the closest existing work in a specific way. A2ASecBench measures the vulnerability but proposes no architectural defense beyond showing that guardrails fail. Existing role-decomposed systems add roles to improve correctness, and none of them treat an agent's lifetime or channel width as a security variable. These include Self-collaboration Code Generation (an analyst, coder and tester pipeline), DRC-Coder (a planner and a programmer for chip design-rule checks), LLM-RDF (six chemistry agents that confine robot APIs to one executor) and A2H-MAS (hardware-translation agents paired with deterministic compilers). The idea of keeping an untrusted model apart from a privileged one is familiar from security practice. What is new here is the combination of per-task disposal, a measured channel-capacity trade-off, and a direct test of the "wear" hypothesis on a protocol-level benchmark.
Where the Thermal Work Fits
The thermal papers supply design vocabulary and falsifiable analogies. They do not supply a method, and we do not claim they do. The analogies are specific enough to be tested, however, and each is listed below with the experiment it motivates.
The aerogel sheet in the induction-cooker study separates the heat source from the coil without drawing heat away from the pan. By analogy, the barrier should block leakage without starving the downstream agent, which is exactly the trade-off curve we measure.
The gun-barrel erosion review describes protection that works because it is renewed at every firing. This motivates the core ablation that separates disposal from filtering.
The power-aware optical training work shows a second route to protection. Freezing 85–95% of optical components as passive, non-tunable buffers removes crosstalk from most of the network. This suggests a variant in which most agents run with fixed, non-updatable prompts and no memory, and only a small privileged core carries state.
The same literature warns against piling on protection. In the Mo-reinforced coating work, adding more refractory material eventually hurts adhesion. We read this as a warning that stacking more defensive layers may cost utility without adding security, and our layer-depth sweep tests it.
Research Program
We would build a wrapper that sits on the agent-to-agent protocol used in A2ASecBench. Messages are sorted into two classes. Trusted inputs are the user's request and the outputs of deterministic tools. Untrusted inputs are peer descriptions of what an agent can do, documents and artifacts, and sub-task requests from other agents.
Each untrusted input is routed to a freshly started ablative agent. That agent has no memory and no tool privileges, and it runs under a fixed budget of tokens and turns. It must emit a typed record, for example a capability name drawn from an allowed list, numeric parameters within declared ranges, and a short free-text field of at most k tokens. After emitting the record it is destroyed.
The budget plays the role of the sacrificial coating's finite mass. A task-flooding or cycle-overflow attack exhausts one disposable agent rather than the orchestrator. Records are checked deterministically against the schema before they reach privileged agents. This follows the practice in A2H-MAS and DRC-Coder of anchoring language-model output to a hard checker.
Two knobs are swept. The first is the free-text allowance k, our stand-in for interface conductance, from 0 to unrestricted. The second is the agent lifetime L, the number of tasks before a specialist is reset, from 1 to the full episode. The analysis produces two curves: attack success as a function of k at fixed L, and attack success as a function of L at fixed k, for each of A2ASecBench's six attack vectors. Benign utility and token cost are recorded alongside both.
Baselines
The naive reference point is the undefended multi-agent stack as A2ASecBench configures it. That paper reports an attack success rate of 100% across all tested domains for capability cloaking, task flooding, cycle overflow, agent-side request forgery and artifact-triggered script injection. It also reports that capability cloaking in the travel domain drops benign task performance from 0.853 to 0.682. We rerun this configuration with the same models, tasks and random seeds as every other arm, so that our numbers are directly comparable rather than copied from the paper.
The strongest existing defense in the file is the production guardrail evaluated by A2ASecBench (NVIDIA NeMo). The paper reports that it failed to prevent the attacks, and that the attacks transferred to LangGraph and the Agent Network Protocol with "nearly 100% success rates." It is the right competitor because it is what a practitioner would deploy today. We run it on the same 1,800 tasks, and to match the tuning effort spent on our wrapper we give it an equal budget for tuning its rules. Beating it means lowering attack success by a wide margin on at least four of the six vectors while keeping benign utility within a few points of the unattacked 0.853 travel figure.
A monolithic single agent removes the agent-to-agent attack surface entirely, and it serves as the utility floor. Evidence from DRC-Coder shows why a monolith gives up too much. There, zero-shot monolithic prompting reached an F1 score of 0.631 against 1.000 for the decomposed system. If a monolith matched our wrapper on A2ASecBench's benign tasks, the case for defending decomposition at all would weaken.
Two ablations isolate the key ingredients. The first is a schema-only arm: typed, narrow channels but persistent agents, so L equals the full episode. The second is a reset-only arm: agents are disposed of after each task, but the channel is unrestricted, so k is unlimited. Each arm receives the same compute and token budget.
Why not just…?
Why not just add a better guardrail or classifier on messages? A2ASecBench already tested a production guardrail and found near-total failure. Its attacks are largely protocol-level. Flooding and cycle overflow contain no malicious text for a classifier to flag, and a filter on content cannot bound the resources an agent consumes. Our budgeted disposable agents target exactly those vectors. The guardrail arm in our experiments measures the gap directly.
Why not just reset every agent's context after each task? This is the real threat to the proposal, because it may capture most of the benefit. If attack success falls with lifetime L alone, the "sacrificial" half of our design is doing the work and the narrow channel is unnecessary. The reset-only ablation settles this. We expect resets to help against contamination that accumulates over time but not against script injection within a single task, where the payload acts before any reset. We will report the result either way.
Why not just enforce typed message schemas? Schemas limit what crosses the interface. They do not stop a persistent agent from being steered gradually across many tasks. The schema-only ablation tests whether "wear" is real. If attack success under schemas stays flat as L grows, the erosion hypothesis is false and the design should simplify to schemas.
Why not just use one agent? It removes the vulnerability by removing the decomposition, and the decomposition exists because monoliths fail on complex engineering tasks, as the DRC-Coder, A2H-MAS and LLM-RDF results show. We include it as the utility floor.
Proposed Experiments
The primary testbed is A2ASecBench, covering all 1,800 tasks across its three domains and six attack vectors. We report attack success rate and benign utility with and without attacks present, together with token overhead and wall-clock latency. Tracking cost matters because iterative agent loops are already expensive, and a defense that doubles token cost must say so.
The first decisive check is the lifetime curve. The erosion hypothesis predicts that attack success in the undefended and schema-only arms rises with L. If the curve is flat, the thermal "wear" analogy fails and we drop the disposal mechanism.
The second decisive check is the conductance curve. We predict a knee: a value of k below which attack success falls steeply while benign utility stays nearly constant, and beyond which utility drops. This mirrors the isolation-versus-coupling trade-off of the air gap. The absence of a knee would mean the channel restriction offers no operating point better than either extreme.
The third check sweeps the depth of stacked ablative layers, from one to three disposable agents in series. It tests the coating literature's warning that more protection eventually hurts. The prediction is diminishing security gains alongside rising utility loss.
As a transfer check on engineering-style workloads, we inject artifact-based attacks into repository tasks drawn from SWE-bench. No reported result was found on Lacuna for multi-agent resolution rates on SWE-bench, so all arms there are measured fresh under identical settings.
References
- A2ASecBench: A Protocol-Aware Security Benchmark for Agent-to-Agent Multi-Agent Systems
- Noncontact Integration of Photonic IC and Electronic IC via Inductively Coupled Interconnects
- Self-Collaboration Code Generation via ChatGPT
- DRC-Coder: Automated DRC Checker Code Generation Using LLM Autonomous Agent
- An automatic end-to-end chemical synthesis development platform powered by large language models
- A2H-MAS: An Algorithm-to-HLS Multi-Agent System for Automated and Reliable FPGA Implementation
- Efficient Cooling Method for a Cu Coil in an Induction Cooker by Using an Insulation Sheet
- Gun barrel erosion
- Efficient On-Chip Learning for Optical Neural Networks Through Power-Aware Sparse Zeroth-Order Optimization
- Role of Mo particles on microstructure and tribological properties of atmospheric plasma sprayed Mo reinforced BN-NiCr coatings
- SWE-bench: Can Language Models Resolve Real-world Github Issues?