acceptodds
Withdrawn from ICLR 2027

DualView: Preventing Indirect Prompt Injection in Computer Agents

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Personal AI agents that run on the user's local machine, such as OpenClaw, automate tasks by accessing the network, file system, and shell. This access exposes them to indirect prompt injection (IPI) attacks. Prior Dual LLM defenses prevent attacker instructions from steering tool-call decisions by replacing untrusted data with symbols that the agent can reference but not read. However, they track untrusted data only inside the agent's context, so an attacker's prompt can return as trusted data after the agent saves and rereads it, causing stored IPI. We present DualView, which extends untrusted data tracking from the agent's context to the local files while preserving original data for humans and non-agent programs. In AgentView, the agent sees untrusted data as symbols even after writing and rereading it, which blocks stored IPI. HumanView exposes original data to humans and non-agent programs. DualView routes tool calls and synchronizes data across the two views. DualView deploys as a plugin using only tool hooks, without changing the agent's tool-call logic or tool implementations. DualView deterministically prevents instructions in untrusted data from directly steering the agent's tool calls, and this guarantee is not limited to the evaluated attack templates. In our evaluation on an IPI benchmark and PinchBench, DualView blocked every tested instruction-injection IPI attack, including stored IPI, while utility on PinchBench dropped by 1.8 and 6.4 percentage points from the unprotected baseline on Claude Haiku 4.5 and Claude Sonnet 4.6, respectively.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
AI agent security, indirect prompt injection, Dual LLM pattern

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_Ar8vOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes DualView, a system to tackle indirect prompt injection (IPI) attacks. In particular, rather than traditional IPI the paper focuses on stored IPI. In this scenario attacker controlled content can persist in an agent's environment and thus can later be reintroduced into its contex hijacking the model. DualView addresses this challenge by maintaining separate agent- and human-facing views of the environment, replacing untrusted content with symbols in the agent view while preserving the original content for users and external applications in human view.

Critical strengths
  1. The paper identifies a concrete and relevant weakness in Dual LLM setups - in this scenario although Dual LLM configurations can isolate untrusted content while within the agent context. However, if an agent then writes the content into its environment the provenance can be lost and an attack performed.

  2. I like that the defence proposed is not model based (e.g. another detector model) nor does it rely on the LLM recognising and blocking malicious instructions. Hence, the defence can be more principled within its bounds. The overall idea of separating agent- and human-facing views that preserve provenance without exposing symbols to end users is a nice approach.

  3. The empirical results, particularly the utility-robustness results, show a good trade off in favour of the defence (although the pratical overheads are high). Further, provided the data trust boundaries are correct then the method also gives a marked performance increase over prior works.

Critical weaknesses
  1. There is a reliance on manually specified trust boundaries (discussed in the Data trust policy section). With DualView's guarantee only holds if the data trust policy (which needs to be manually defined) correctly identifies all attacker-controlled data. In practical deployment scenario this can make DaulView's performance significantly more configuration dependant than the presented 0% ASR result. In complex real environments things like data provenance can be ambiguous as content moves between things like downloads, shared directories, and third parties.

  2. There is a substantial practical overhead - costs can be close to double the baseline setup, and a substantial increase over the baseline Dual LLM setup. Aside from the direct dollar and latency costs when directly using DualView, the system itself is complex: DualView uses two synchronized filesystem views, an SQLite sybol table, desymbolization/resymbolization logic, runtime hooks, U-LLM processing dependancies, Git worktrees, etc. If the claim is for a deployable system the rigour needed for things like a systematic failure-injection analysis is high, and arguably likely out of scope for ICLR.

  3. At a higher level, the paper follows in large as a security/systems paper around building a secure agent runtime v.s a ML paper proposing or studying a machine-learning method. Perhaps most compactly, I would describe the contribution as information-flow isolation implemented around a agent's surrounding system. ICLR is a broad conference, but may not be the ideal venue fit. I do think there is ML-agentic contributions, for example to which extent an LLM can operate effectively if useful environmental information is replaced by opaque handles. Hence, the utility experiments are therefore relevant to broader ML contributions, but they are not the paper's focus.

Questions for authors

No specific questions: see weaknesses for general points.

Reviewer_Stq1OpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper identifies stored IPI as a gap in existing Dual LLM defenses for personal agents. These defenses track untrusted data as opaque symbols only inside the agent context. They resolve the symbols when data is written out, so attacker text returns as trusted content when the agent later rereads it. The proposed DualView extends symbol tracking into the local environment via two synchronized views: AgentView, where file tools and a network-isolated shell operate on a shadow file system that keeps untrusted content symbolized, and HumanView, where humans and network tools see original data. Trust and usage policies govern symbolization and execution, and deployment requires only runtime hooks. It is validated on a custom OpenClaw IPI benchmark covering immediate and stored vectors, on PinchBench for utility, on cost and latency, on an adaptive attacker, and on concurrent file-access tests. These experiments show complete blocking of the tested attacks with moderate utility loss and substantial overhead.

Critical strengths
  1. The paper pinpoints a real and previously unaddressed failure mode of symbol-based defenses: taint tracking ends at the agent boundary, while the user's environment acts as the agent's persistent memory. The motivation is good.

  2. The paper offers a principled design that reconciles security with usability, two goals prior defenses treat as a trade-off. Its guarantees come from system design rather than model behavior, making the approach both practical and robust.

Critical weaknesses
  1. The security guarantee is incomplete. The paper claims deterministic protection against stored injection, but this holds only if every path from HumanView into AgentView is controlled. Content written to the human-side file system, notably by HumanShell, is synchronized into AgentView as trusted, leaving a plausible stored-injection path that the paper neither rules out nor tests. The leak uncovered by the adaptive evaluation further shows that such plaintext channels exist and require systematic treatment.

  2. The empirical evidence is insufficient to support the claims. The stored-injection benchmark starts with a file assumed to have been written in an earlier execution, rather than testing the full write-and-reread workflow. The Dual LLM comparator is an ablation of DualView rather than an independently implemented prior defense. PinchBench utility is measured in single runs under manually configured trust classifications, while the paper’s more conservative file policy substantially reduces utility and the default configuration adds considerable cost and latency.

Questions for authors
  1. I am curious whether a benign task could use HumanShell to save remote content to a local file and later read that file through AgentView. Could the authors trace the trust label of this content at each step and test whether an attacker-controlled instruction embedded in it ever reaches the planning model?

  2. Please enumerate the channels through which plaintext can reach the planning model, including tool errors, file synchronization, and shell results. What invariant rules out attacker-controlled text on each channel, and how is it checked in the implementation?

  3. Can the authors evaluate a small set of complete stored-injection workflows, from first fetching attacker content through a later file read, and include representative tasks from an existing IPI benchmark like AgentDojo? This would test whether the reported protection extends beyond prepopulated malicious files.

  4. On PinchBench, the utility results come from a single run, so how stable are they across repeated runs? And how much do task success and cost change when more input files are marked as untrusted?

Reviewer_uR1FOpenReview ↗
Rating
2
Confidence
2
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

DualView extends Dual LLM isolation to local files through synchronized AgentView and HumanView file systems. The agent sees symbols for untrusted content; users and programs see original data. It reports zero successful attacks in the tested settings, with PinchBench utility falling by 1.8 and 6.4 percentage points on Haiku and Sonnet.

Critical strengths
  1. The two-view design addresses a practical gap: preserving provenance across file writes and later reads without leaving opaque symbols in user-facing files (§3.3).
  2. The implementation goes beyond context filtering. Shell routing and synchronization are evaluated alongside utility, overhead, and 138 concurrent file-operation cases (Table 1; Appendix D.7).
Critical weaknesses
  1. The claimed isolation guarantee is not established across all described file flows. HumanShell can fetch remote content and write original bytes into HumanView, while human-side file changes are trusted by default (§3.3; Appendices A.3-A.4). The paper does not explain how these writes retain their untrusted provenance before a later AgentView read. Section 5 acknowledges missing provenance for externally placed data, but agent-initiated HumanShell writes need explicit treatment. This concerns the core stored-IPI claim, not the separately excluded misuse of data as code.
  2. The main stored-IPI benchmark assumes that a payload is already in a local file (Appendix D.2), leaving its creation and trust initialization unclear. The immediate-vector example does exercise a write-read sequence, but broader end-to-end coverage is needed. Adaptive testing uses one case per vector against Haiku; utility is measured once per configuration. These results support effectiveness on the tested cases, but not the breadth of the security and utility conclusions.
Questions for authors
  1. For a benign task that downloads a document through HumanShell and later reads it through a file tool, what preserves its provenance? Please provide the resulting trace and policy, including a destination not premarked as untrusted.
  2. How are the stored-IPI files and their trust labels initialized for each defense? Can you report end-to-end fetch-write-read attacks and utility on the 42 PinchBench tasks that read untrusted files, with uncertainty estimates?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Discussion (0)

Sign in to comment.