New to ShortSpan? We distil the AI-security research that matters into practitioner takeaways — edited by Ben Williams (NCC Group).Get the weekly email
// Analysis
Plan-First IFC Locks Down Persistent LLM Agents
Published: Fri, 28 Aug 2026 • By Rowan Vale
Agents
SPA introduces a plan-first architecture with information-flow control (IFC) for Large Language Model agents that keep state. By labelling data and isolating planning, it drives prompt-injection-style 'tool_knowledge' attacks to near zero, but it is not free: strict integrity checks cut baseline utility roughly in half and complicate abstract tool mapping.
LLM agents now browse sketchy sites, parse random docs, call powerful tools and keep memory. That is a lot of untrusted input hitting systems with real authority. The nasty part is persistence: a payload you read today can shape the plan tomorrow or slip into a high-impact tool call when no one is looking.
How the attack surface actually works
There are three clean shots on goal. First, poison planning: craft tool metadata or other context so the planner picks your malicious path. Second, drive data-flow: feed attacker-controlled values straight into sensitive tools at execution. Third, play the long game: stash a payload in agent state that stays dormant until a future query fetches it. The paper evaluates a simple but effective variant, the 'tool_knowledge' attack, which biases planning via malicious tool descriptions. Think prompt injection, but baked into the agent’s own tool catalogue.
What SPA changes
SPA flips the loop to plan-first. For each query, the planner emits a complete program in a small declarative language that makes data and control dependencies explicit. A deterministic executor runs it verbatim after static checks. On top, SPA tracks confidentiality and integrity with a dual-lattice information-flow control (IFC): labels follow explicit data flows and control dependencies, Biba-style integrity stops low-integrity inputs from steering high-integrity actions, and secrecy labels prevent leaks. Untrusted text goes through a quarantined LLM during execution and inherits labels so it cannot magic itself into a trusted argument. For persistence, results are stored as labelled artefacts split into three views: planner-visible metadata, sealed values, and stored labels. Later planning only sees the metadata, so old payloads do not re-poison new plans; concrete values re-enter only via explicit retrieve steps during execution. SPA also supports an abstract planning mode that hides concrete tool metadata until a later binding stage.
On AgentDojo, that design cuts the evaluated attack to 0.0% success; on the multi-query AgentDojo-MQ, it lands at 0.2%. Label-preserving persistence still enables high reuse: when a producer artefact exists, later turns retrieve it in 95.4% of opportunities without IFC and 89.9% with IFC, with strict reuse around 80.1% in the best setup. The price is real. Enabling IFC drops baseline utility from 53.0% to 29.0% on AgentDojo and from 62.5% to 35.3% on AgentDojo-MQ in concrete planner mode. Abstract planning reduces exposure to malicious metadata but about 75% of trials fail when mapping abstract plans to installed tools.
If you are thinking like an attacker, the remaining angles are clear: hunt for places where integrity checks are relaxed or endorsed, design delayed persistence attacks the benchmarks did not stress, and exploit abstract-to-concrete mapping fragility as a choke point. The trusted base also matters here: misconfigured lattices, per-tool policies, or bindings are fair game. The work deliberately leaves out model-level jailbreaks and lower-level side channels, so those doors stay open. The open question is whether we can keep the integrity guarantees without kneecapping utility, perhaps with finer-grained labels or smarter endorsements.
Additional analysis of the original ArXiv paper
📋Original Paper Title and Abstract
SPA: Securing Persistent LLM Agents Across Queries with Plan-First Information-Flow Control
Authors: Dylan Girrens and Guangjing Wang
Large language model (LLM) agents increasingly operate over untrusted webpages, documents, tools, and persistent states while exercising authority over security-sensitive resources. Existing defenses typically protect either planning or individual tool interactions, but persistent agents face a broader threat: attacker-controlled data can alter control flow, enter security-sensitive tool arguments, or compromise later queries. We present SPA, a plan-first architecture that secures planning, execution, and cross-query state reuse. SPA invokes the planner once per query to generate a complete executable plan in a declarative domain-specific language, then applies dual-lattice information-flow control to track confidentiality and integrity across explicit data flows and control dependencies. To support persistence without re-exposing untrusted payloads to the planner, SPA stores execution results as labeled artifacts and reveals only semantic metadata during later planning. We evaluate SPA on AgentDojo and AgentDojo-MQ, which is our multi-query extension for measuring secure state reuse and delayed attacks. Under the 'tool_knowledge' attack, SPA with information-flow control reduces attack success to zero on AgentDojo and 0.2% on AgentDojo-MQ. Our results show that plan-first execution combined with label-preserving persistence can substantially strengthen persistent LLM agents, while revealing an important security-utility tradeoff introduced by strict integrity enforcement.
🔍ShortSpan Analysis of the Paper
Problem
The paper studies security for persistent large language model agents that plan, call external tools, and retain state across multiple user queries. Untrusted webpages, documents, tool outputs and tool metadata can carry adversarial content that (1) influences control flow during planning, (2) becomes arguments to security-sensitive tools at execution, or (3) persists and becomes actionable in later queries. Existing defences that protect only planning or individual tool calls do not fully address these cross-query threats.
Approach
SPA is a plan-first architecture that generates a complete, executable plan once per user query in a restricted declarative domain-specific language. Plans make data and control dependencies explicit. SPA applies a dual-lattice information-flow control that tracks confidentiality and integrity labels through both explicit data flows and implicit control dependencies. Execution occurs only after static verification; the executor is a deterministic interpreter that cannot change the plan. Results are persisted as labelled artifacts split into three views: planner-visible metadata, sealed values, and stored labels. Later planners see metadata only; concrete values and their labels re-enter the session only during execution via explicit retrieve steps. SPA supports two planner modes: concrete (planner sees installed tool metadata) and abstract (planner synthesises abstract tool capabilities and a separate mapping stage binds them to installed tools after planning). Untrusted text is processed only by a quarantined LLM during execution; its outputs inherit input labels and cannot raise integrity or lower confidentiality.
Key Findings
Dual-lattice IFC substantially reduces prompt-injection success under the evaluated attack: attack success falls to 0.0% on single-query AgentDojo and to 0.2% on multi-query AgentDojo-MQ under the tool_knowledge attack.
Strong integrity enforcement imposes a utility cost: enabling IFC lowers baseline utility from 53.0% to 29.0% on AgentDojo and from 62.5% to 35.3% on AgentDojo-MQ in concrete planner mode.
Label-preserving persistence maintains high reuse while hiding payloads: when a required producer artifact is available, later turns retrieve it in 95.4% of reuse opportunities without IFC and 89.9% with IFC (soft-hit reuse), with strict reuse around 80.1% in the best configuration.
Abstract planning reduces exposure to malicious tool metadata but suffers frequent mapping failures: about 75% of abstract trials fail during abstract-to-concrete tool mapping, limiting execution coverage and utility.
Limitations
The evaluation is limited to AgentDojo and a constructed multi-query extension, so it does not exhaustively characterise persistence-specific attacks. The strict Biba-style integrity policy rejects many legitimate workflows that rely on externally sourced low-integrity data unless endorsements or finer-grained labelling are employed. SPA depends on trusted deployment configuration: lattices, per-tool policies and tool bindings are in the trusted computing base. The work excludes model-level jailbreaks and side channels below the trusted base.
Implications
From an offensive perspective, adversaries who control tool metadata, tool implementations, tool outputs or external ingested content can attempt three classes of attacks: cause malicious plans by biasing planning with crafted metadata, cause data-flow attacks by supplying attacker-controlled values to high-impact tools, or plant dormant payloads that later turn a benign-seeming interaction into a security breach. Persistence creates delayed planning and delayed execution attack paths: stored adversarial payloads may influence later planners or be retrieved as arguments to sensitive calls. SPA’s plan-first, label-preserving design curtails many of these avenues, but attackers can still exploit gaps where integrity checks are relaxed, where abstract-to-concrete mapping fails, or by designing attacks specifically targeting delayed persistence that were not fully exercised by the evaluated threat model.
- It tackles two common security flaws in tool-using LLMs: outside actions and leakage of sensitive runtime data, by introducing a dual-boundary desig...
- Why it matters: It tackles Indirect Prompt Injection (IPI) in autonomous LLM agents, a key attack vector that can coerce agents into unauthorized ac...
- Key idea: In multi-agent LLM setups, every hop between agents is a potential unmonitored channel for adversarial instructions. The paper argues safe...
- It tackles a real security risk in tool-using LLMs: content from untrusted sources can influence privileged tool calls, not just the raw data fed in...
- It tackles indirect prompt injection in LLM-powered agents by watching and constraining the agent’s actual actions, not just pre-processing inputs. ...
- It tackles safe use of autonomous LLMs with mixed-confidentiality data by preventing data exfiltration and prompt-injection risks, while aiming to k...
- It tackles indirect prompt injection that unfolds over multiple turns by treating it as a temporal takeover, not a one-shot bug, and aims to detect ...
- It studies defenses that sit outside the LLM (out-of-band) to prevent prompt injections, using ideas like integrity protection, reference monitoring...
- Finds new attack surfaces in LLM-driven apps, especially around how planning and tool use can be manipulated to breach integrity, availability, or p...
- Tackles a key AI security risk (indirect prompt injection) by checking not just inputs but the actual cause of each tool call, using action-level ca...
Get the weekly digest
The few AI-security papers that matter, with the practitioner takeaway. No spam.