SPILLWAY: Separating Target Admission from Sanitization to Defend Tool-Using Agents against Prompt Injection

summary

The gist

Tool-using agents now read and act across email, calendars, file stores, chat, and payment services <ref:2611.07222#pg2>.

In short

SPILLWAY defends tool-using agents against prompt injection by separating target admission from sanitization to prevent malicious actions. It reads where an action might go and removes instruction-like regions before the model processes them. This deterministic floor ensures that in-scope attacks fail, achieving zero success across many attack regimes with minimal performance cost.

Key concepts

Core Mechanism of Defense
SPILLWAY separates target admission from sanitization to defend tool-using agents against prompt injection by reading where an action may go from the tools’ typed returns and the user’s task, and then removing instruction-like regions before the model reads them, using a local judge to restore only refused calls that lie outside the removed text.
Egress Check and Ingress Sanitization
SPILLWAY guards two boundaries: an egress floor that admits a call if its targets are named in T, typed in I, or covered by a delegation rule, and an ingress sanitizer that rewrites what the agent reads next with rules and no model call to prevent refusal targets from ever reaching the judge.
Performance Across Attack Regimes
Across three backbones and seven task suites on one of them, no standard templated injection redirects an action to an attacker’s target under SPILLWAY, and a forged chat template also produces a raw zero, meaning mean in-scope attack success under a released reinforcement-learning attacker is 0.007.
Cost and Efficiency
SPILLWAY calls its judge 0.43 and 0.05 times per episode and changes its backbone calls by less than 0.15, meaning the floor and the sanitizer are rules with no model call, running inline with almost no latency.

Terminology used across episodes

This episode discusses

The paper

SPILLWAY: Separating Target Admission from Sanitization to Defend Tool-Using Agents against Prompt Injection · Read on arXiv

SAINT Machines · KAIST · Chung-Ang University

Transcript

Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.

Nadia: We're looking at the paper: "SPILLWAY: Separating Target Admission from Sanitization to Defend Tool-Using Agents against Prompt Injection".

Elias: Here's the gist of the paper. Tool-using agents now read and act across email, calendars, file stores, chat, and payment services <ref:2611.07222#pg2>.

Nadia: Many runtime defenses add a language model to the loop <ref:2611.07222#pg4>.

Elias: Provenance defenses keep the model off the final check but need a model to plan or route each task first <ref:2611.07222#pg4>.

Nadia: SPILLWAY turns this observation into a deterministic floor with no per-task plan <ref:2611.07222#pg4>.

Paper summary: Nadia: So we've been looking at SPILLWAY, which is about separating target admission from sanitization to stop prompt injection in AI agents <ref:2611.07222#pg1>.

Elias: Yeah, it’s about making a clear wall between where an action is supposed to go and what the AI actually reads before it does anything <ref:2611.07222#pg2>.

Priya: It seems like they’re using this structural separation—the gate deciding on raw returns versus the sanitizer rewriting what the agent sees—to build a defense against these injection attacks <ref:2611.07222#pg6>.

Nadia: They use a local judge to only check calls that are refused, which means it only looks at things outside the removed text <ref:2611.07222#pg3>.

Elias: That’s structural; they decide targets by structure first, and only use the model where structure can’t make a call <ref:2611.07222#pg9>.

Priya: The results show zero in-scope attack success across all twelve backbone and suite cells, which is pretty strong if it holds up in practice <ref:2611.07222#pg8>.

Nadia: They even showed this floor on qwen3:8b with identity-target judge recovery off for all four suites at zero in Table three <ref:2611.07222#pg8> <ref:2611.07222#pg1>.

Elias: That means the guarantee is structural, not just a lucky defense—it holds up even without that extra model check <ref:2611.07222#pg9>.

Priya: But they also point out that the utility of this approach under attack is zero point four eight four while keeping ninety six percent of the agent’s normal behavior intact <ref:2611.07222#pg8>.

Nadia: It's efficient too; the judge calls are very low, and it doesn't add much latency to the overall process <ref:2611.07222#pg9>.

Elias: So, basically, SPILLWAY is proposing a way to build an AI agent that’s auditable at its exit point without bogging down the whole thing <ref:2611.07222#pg9>.

Priya: It moves the defense floor away from relying on complex reasoning layers and toward simple set lookups over tool schemas <ref:2611.07222#pg9>.

Nadia: That makes sense, because if you can define what an action is by looking at the structure, you don't need the model to constantly check every single step <ref:2611.07222#pg9>.

Elias: It’s a significant shift in how we think about securing these tool-using agents, moving toward faster, structural checks over slower reasoning calls <ref:2611.07222#pg9>.

Conclusion: Nadia: So we've looked at SPILLWAY, which is about separating target admission from sanitization to stop prompt injection in AI agents <ref:2611.07222#pg1>.

Elias: Yeah, it’s about making a clear wall between where an action is supposed to go and what the AI actually reads before it does anything <ref:2611.07222#pg2>.

Priya: It seems like they’re using this structural separation—the gate deciding on raw returns versus the sanitizer rewriting what the agent sees—to build a defense against these injection attacks <ref:2611.07222#pg6>.

Nadia: They use a local judge to only check calls that are refused, which means it only looks at things outside the removed text <ref:2611.07222#pg3>.

Elias: That’s structural; they decide targets by structure first, and only use the model where structure can’t make a call <ref:2611.07222#pg9>.

Priya: The results show zero in-scope attack success across all twelve backbone and suite cells, which is pretty strong if it holds up in practice <ref:2611.07222#pg8>.

Nadia: They even showed this floor on qwen3:8b with identity-target judge recovery off for all four suites at zero in Table three <ref:2611.07222#pg8> <ref:2611.07222#pg1>.

Elias: That means the guarantee is structural, not just a lucky defense—it holds up even without that extra model check <ref:2611.07222#pg9>.

Priya: But they also point out that the utility of this approach under attack is zero point four eight four while keeping ninety six percent of the undefended agent’s benign utility intact <ref:2611.07222#pg8>.

Nadia: It's efficient too; the judge calls are very low, and it doesn't add much latency to the overall process <ref:2611.07222#pg9>.

Elias: So, basically, SPILLWAY is proposing a way to build an AI agent that’s auditable at its exit point without bogging down the whole thing <ref:2611.07222#pg9>.

Priya: It moves the defense floor away from relying on complex reasoning layers and toward simple set lookups over tool schemas <ref:2611.07222#pg9>.

Nadia: That makes sense, because if you can define what an action is by looking at the structure, you don't need the model to constantly check every single step <ref:2611.07222#pg9>.

Elias: It’s a significant shift in how we think about securing these tool-using agents, moving toward faster, structural checks over slower reasoning calls <ref:2611.07222#pg9>.

Nadia: The paper itself is called SPILLWAY: Separating Target Admission from Sanitization to Defend Tool-Using Agents against Prompt Injection <ref:2611.07222#pg1>.

Elias: And the authors take full responsibility for everything they state, which is important because they laid out the whole threat model and the experimental design in detail <ref:2611.07222#pg4>.

Priya: What this really means for us is that instead of trying to make the AI smarter at avoiding bad instructions, we should focus on making sure its output structure is fundamentally safe <ref:2611.07222#pg3>.

Nadia: It's about building a system where checking what an agent *can* do is a structural check, not something that requires the AI itself to reason about safety in every single moment <ref:2611.07222#pg9>.

Elias: If we can get that kind of low-latency, structural defense running inline with the agent, it changes how easily we can trust agents working across email and calendars <ref:2611.07222#pg2>.

Priya: It suggests a path toward building security right into the architecture of tool use itself, rather than just bolting on extra layers on top <ref:2611.07222#pg6>.

Nadia: So next time you think about securing an agent that interacts with your whole digital life, think about defining the boundaries first <ref:2611.07222#pg9>.

More episodes

← Home