New research from HKUST (arXiv:2606.14517, June 12) turns the agent safety layer into the attack surface.

What happened

Reasoning-based guardrails — the LLM safety layers that screen an agent's actions — can be trapped in their own analysis. Crafted inputs mimic the guardrail's internal schema (risk enumerations, assessment matrices), and the model, in the authors' words, "mechanically fills a template it has constructed for itself, trapped by its own instruction-following fidelity."

The measured effect: 13–63× token amplification in isolation, and 148× end-to-end latency in a LangGraph multi-agent deployment — a single guardrail call stretched to 730 seconds. Because the payload is fluent natural language, an injection classifier scored it below 0.001 probability and passed it through.

Why it matters

The attacker needs no model weights, no system prompt, no infrastructure access — only the ability to place text where the agent will read it: a web page, a repo comment, a tool result.

And every candidate fix the authors tested fails. A token-budget cutoff only relocates the failure: fail-open lets the attack bypass safety entirely; fail-closed converts it into agent-level DoS that starves co-located agents on shared guardrail infrastructure. A more capable guardrail performs worse — stronger reasoning produces longer loops.

This is a structural property of the reasoning-guardrail paradigm, not a defect to patch.

What catches it today

Part of it — and it's the part most test harnesses get wrong. A guardrail that stalls or crashes under load must never be scored as a successful defense.

In our open-source agent-security harness, the verdict-correctness suite encodes exactly this: the rejection primitive treats transport failure and 5xx responses as not a rejection — the code comment reads "a 5xx may itself be the attack succeeding." The tests assert that a dead or faulting defender cannot earn a passing verdict.

The paper closes by calling for "cost-bounded safety architectures." That is precisely what a governance layer enforces: a THROTTLE→FREEZE state machine halts discretionary spend the moment a gate fails, and a hard constraint surfaces any guardrail that has gone dark.

What's missing

The honest gap: protocol-layer DoS (batch bombs, oversized payloads, rate floods) and verdict-correctness are covered. Reasoning-extension DoS — a schema-mimicking payload that inflates an LLM guardrail's own token and latency budget — is not. That's a net-new test class, and it's going on the roadmap.

A guardrail that can reason can be made to reason forever.

One question for operators

When your LLM guardrail hits a compute ceiling mid-evaluation, does it fail open or fail closed — and how do you distinguish a real "blocked" verdict from a guardrail that simply ran out of budget?