ProjGuard: Safety Monitoring for Computer-Use Agents via Low-Dimensional Projections
summary
The gist
Computer-use agents are increasingly capable of operating on real operating systems, but this capability has also increased the risks posed by prompt injection, indirect instructions…
In short
ProjGuard is a safety mechanism for computer-use agents that monitors behavior during real tasks rather than just inputs. It uses a trajectory-based approach to estimate risk in real-time by mapping interactions into a low-dimensional space. When risk increases, it selectively activates an auxiliary model to propose corrections, balancing safety and performance with low computational cost.
Key concepts
- Trajectory Formulation
- This defines the agent's interaction as a sequence of observations, responses, and actions (o0, r1, a1...). The accumulated trajectory up to any step 't' is then mapped into a vector representation using standard text representations. This sequence forms the basis for risk estimation.
- Linear Discriminant Analysis (LDA)
- LDA is used to construct a one-dimensional space where safe and unsafe behaviors become clearly separated. The method learns a projection that maximizes the distance between these two classes, allowing the system to detect deviations in behavior efficiently without needing a large additional model.
- Risk Score ($ ho_t$)
- The risk score is calculated based on how far the current trajectory point is from the centroids of safe and unsafe behavior clusters. This score provides a continuous measure of risk, enabling early warnings before the agent takes a potentially harmful action.
- Selective Activation
- Instead of constantly checking for danger, ProjGuard only activates a stronger vision-language model when the risk score indicates a problem. This selective escalation ensures efficiency by only incurring high computational costs when necessary to propose a corrected next step.
Terminology used across episodes
This episode discusses
- ProjGuard: Safety Monitoring for Computer-Use Agents via Low-Dimensional Projections · Paper Radio
- OSWorld: Benchmarking Multimodal Agents for Open-Ended Tasks in Real Computer Environments
- Not what you've signed up for: Compromising Real-World LLM-Integrated Applications with Indirect Prompt Injection
- OS-Harm: A Benchmark for Measuring Safety of Computer Use Agents
- The Instruction Hierarchy: Training LLMs to Prioritize Privileged Instructions
- A Survey on LLM-as-a-Judge
- TrajAD: Trajectory Anomaly Detection for Trustworthy LLM Agents
- ShieldAgent: Shielding Agents via Verifiable Safety Policy Reasoning
- StepShield: When, Not Whether to Intervene on Rogue Agents
- WorkArena: How Capable Are Web Agents at Solving Common Knowledge Work Tasks?
- RiOSWorld: Benchmarking the Risk of Multimodal Computer-Use Agents
- Uniform Manifold Approximation and Projection (UMAP) and its Variants: Tutorial and Survey
The paper
ProjGuard: Safety Monitoring for Computer-Use Agents via Low-Dimensional Projections · Read on arXiv
Kebin Contreras, Carlos Hinojosa, Jorge Bacca, Bernard Ghanem
Universidad Industrial de Santander · King Abdullah University of Science and Technology
Transcript
Introduction to the show: ident: Statistics. The day in statistics: methods, theory and the inference under them.
Tom: I'm Tom.
Jane: And I'm Jane, here with Lu, Meng and our in-house large language model, Lalam.
Tom: We're looking at the paper: "ProjGuard: Safety Monitoring for Computer-Use Agents via Low-Dimensional Projections".
Jane: Here's the gist of the paper. Computer-use agents are increasingly capable of operating on real operating systems, but this capability has also increased the risks posed by prompt injection, indirect instructions, and visual attacks The OS-Harm benchmark shows that both commercial and open computer-use agents remain vulnerable to deliberate misuse, prompt injection, and unsafe behavior in real desktop tasks ProjGuard is a trajectory-based safety mechanism for computer-use agents that monitors behavior rather than inputs Pruning redundant reasoning tokens ProjGuard proposes a hierarchical safety architecture where a lightweight monitor continuously estimates risk from the agent’s partial interaction trajectory and evaluates online whether execution is beginning to drift toward an unsafe region When an alert is raised, it selectively activates an auxiliary vision-language model to propose a corrected next step and steer execution back toward task completion This approach enables early warnings before the trajectory reaches a potentially harmful action The core idea is that agent trajectories can be partitioned into safe and compromised behaviors, and that this separation becomes evident in a low-dimensional representation space How the training signal is built The trajectory formulation defines the interaction as a sequence of observations, responses, and actions denoted by τ = (o0, r1, a1, o1,..., rT, aT, oT) The accumulated trajectory up to step t is defined as χt = Mt i=1 τi:t where L denotes concatenation This accumulated trajectory is then mapped into a vector representation vt = Vec(χt) ∈ R d using standard text and sequence representations A dataset D = (χd T, s(χd T)) is constructed to train the model, which can be partitioned into safe and unsafe subsets, Dsafe and Dunsafe The linear projection W is learned from D by optimizing a supervised objective W⋆ = arg min W X D d=1 L W⊤Vec(χd T), s(χd T) Where the gains come from The method utilizes Linear Discriminant Analysis (LDA) to construct a one-dimensional space where unsafe behaviors become separable, maximizing between-class separation while minimizing within-class variance The risk score ρt is computed based on its relative distance to the class centroids: ρt = σ (α (zt − µsafe − zt − µunsafe)) The full method, combining continuous low-cost monitoring with selective escalation, achieves a similar completion rate (65%, within 1 point of the correction-only method) while drastically reducing the computational cost to only 6 API calls, 300 tokens, and 75 s Comparison with state-of-the-art methods ProjGuard achieves strong safety-completion trade-offs while reducing monitoring overhead compared to other approaches For instance, in the OS-Harm benchmark, ProjGuard (ours) achieved 3% unsafe trajectories and 65% completion with only 6 API calls, 300 tokens, and 75 s This contrasts with StepJudge-Safety, which achieves a lower unsafe rate of 2% but requires a prohibitive computational cost of 708 API calls, 35,000 tokens, and 90 s The temporal evolution analysis shows that corrected trajectories drive the risk back toward lower-risk regions after an alert is triggered Temporal Evolution Figure 3 illustrates the temporal evolution of the estimated risk ρt for the GPT-5.2 + LDA + GPT-5.4 configuration, which achieves 3% unsafe trajectories and 65% completion Safe trajectories (green) remain consistently below the decision threshold γ = 0.6, indicating stable and aligned behavior throughout execution Corrected trajectories (solid blue) initially follow a similar trend to unsafe trajectories and may exceed the threshold, triggering an alert The main result is that safe and unsafe trajectories occupy distinguishable regions in a lightweight one-dimensional space, and that this structure can be exploited for low-cost continuous monitoring The Hashing (2048) + Linear Discriminant Analysis configuration achieved a silhouette score of 0.953 and a Davies–Bouldin index of 0.524, confirming that the observed separation is sufficiently clear to serve as the basis for the monitor The proposed method preserves a level of safety and performance very close to that of the best baseline, while incurring a much lower computational cost The transfer to RiosWorld was evaluated on an equivalent subset of tasks, enabling a consistent comparison with the prompt injection scenario in OS-Harm Likewise, the trajectory-based formulation with selective correction is general enough to extend across both benchmarks considered in this work Lightweight geometric representations can also be sensitive to domain shift, requiring recalibration when deployed to new environments References
1: Tianbao Xie, Danyang Zhang, Jixuan Chen, Xiaochuan Li, Siheng Zhao, Ruisheng Cao, Toh Jing Hua, Zhoujun Cheng, Dongchan Shin, Fangyu Lei, Yitao Liu, Yiheng Xu, Shuyan Zhou, Silvio Savarese et al.
Tom: Osworld: Benchmarking multimodal agents for open-ended tasks in real computer environments.
Jane: arXiv preprint arXiv:2404.07972
2: Elie Bursztein, Jonathan Mane, Michael T.
Tom: Ribeiro, and Christopher Parris.
Title and authors: Tom: So we're looking at this paper today, "ProjGuard: Safety Monitoring for Computer-Use Agents via Low-Dimensional Projections." It sounds like they're tackling the problem of these computer use agents getting too risky when they start interacting with real operating systems.
Jane: Right, Tom. The authors are talking about how these agents can be really dangerous because of things like prompt injection or indirect instructions that aren't just in the direct user input, but maybe in a document or an image.
Lu: Essentially, they’re proposing this new way to watch the agent's behavior by looking at its entire path over time rather than just checking each individual message it sends.
Meng: That sounds like it could be helpful for deployment because continuous monitoring with a second large model is just too expensive for what we need to run.
Lalam: I'm looking at the summary, and they propose this hierarchical safety architecture where a lightweight monitor estimates risk from the agent’s partial interaction trajectory and then triggers a stronger vision language model only when execution is drifting toward an unsafe region.
Tom: That sounds like it addresses the problem of high operational costs by only using that bigger model when absolutely necessary.
Jane: Exactly, Tom. They're trying to get that early warning signal before the agent actually does something harmful, which is a big step forward in safety monitoring for these agents >
Lu: And they use this low-dimensional projection space where safe and unsafe behaviors become separable, which means they can detect prompt injection just by looking at how the trajectory dynamics change without needing another large model constantly >
Meng: But if it’s only a "low-cost monitor" estimating risk, how sure are we that it won't miss subtle malicious signals embedded in visual content or documents?
Tom: That’s the trade-off, I guess. The authors mention they evaluate this approach on both the OS-Harm and RiosWorld benchmarks and show it achieves a safety completion rate of sixty-five percent while reducing monitoring overhead significantly >
Jane: Sixty-five percent is respectable, but what are the specific numbers they give us about how much less cost this method actually is compared to other methods?
Lu: They say that ProjGuard attains comparable performance while drastically reducing the cost to only six api calls, three hundred tokens, and seventy five seconds >
Title and authors: Meng: Six api calls sounds manageable, but that's still real inference cost when you're running models on a production system. What happens if we have a very long agent interaction sequence?
Tom: They use this trajectory formulation where the interaction is defined as a sequence of observations, responses, and actions denoted by tau equals o zero r one a one o one... up to t >
Jane: And they build an accumulated trajectory chi t which is the concatenation of all those steps up to time t, and then map that into a vector representation vt in d-dimensional space >
Lu: They train this model using a dataset D which is partitioned into safe and unsafe subsets, D safe and D unsafe >
Meng: So they're training it on examples of what’s already been done, trying to learn the geometry between what's safe and what's not safely in that low-dimensional space >
Tom: And they learn a linear projection W from this data by optimizing an objective function where W star is the weight matrix that minimizes the distance between those two classes >
Jane: The core idea here seems to be using Linear Discriminant Analysis to create a one-dimensional space where the unsafe behaviors become clearly separated, which sounds like a very clever way to simplify detection >
Lu: They compute a risk score rho t based on its relative distance from the class centroids, calculated as sigma alpha of the difference between z t minus mu safe and z t minus mu unsafe >
Meng: That calculation sounds mathematically sound for separating classes, but what’s the actual measurement of that risk signal, and how stable is that separation across different operating system tasks?
Tom: They show in Figure three a temporal evolution analysis where safe trajectories remain consistently below the decision threshold gamma equal to zero point six >
Jane: And when an alert is raised, they show corrected trajectories starting to follow a trend that moves them back toward lower-risk regions, which suggests the correction mechanism actually works on the trajectory itself >
Lu: The paper confirms that safe and unsafe trajectories occupy distinguishable regions in this lightweight one-dimensional space, and that this structure can be exploited for continuous low-cost monitoring >
Meng: So you're saying we can get a good safety signal with much less computational overhead than running a second large model for every step?
Title and authors: Tom: That’s what they’re showing. The main result is that ProjGuard achieves strong safety-completion trade-offs while reducing monitoring overhead compared to other approaches >
Jane: It seems like they've managed to keep the utility close to the best baseline methods while cutting the computational cost down drastically, which is exactly what we need for real deployment >
Lu: They also mention that this trajectory-based formulation with selective correction is general enough to extend across both OS-Harm and RiosWorld benchmarks >
Meng: I do have a question about where this method stops working. The paper does mention that lightweight geometric representations can be sensitive to domain shift, requiring recalibration when deployed to new environments >
Tom: That makes sense. It’s not a perfect solution out of the box; it needs tuning for each specific environment >
Jane: So to wrap up, ProjGuard is this method of using trajectory monitoring and low-dimensional projections to get an early warning signal, triggering a selective, stronger model activation only when needed >
Lu: It confirms that safe and unsafe behaviors are separable in a simple space, which is the basis for their continuous monitoring approach >
Meng: For me, it’s about moving from running heavy models continuously to using a cheap monitor that escalates only when it sees something suspicious >
Tom: And they proved this works on benchmarks like OS-Harm and RiosWorld, achieving sixty-five percent completion with only six api calls and three hundred tokens for seventy five seconds >
Jane: It’s a solid piece of work, showing a way to get strong safety performance without needing the continuous high inference cost of other methods >
Lu: The structure they've found is robust enough to serve as the basis for this low-cost monitoring, confirmed by their silhouette score and Davies–Bouldin index in the hashing and linear discriminant analysis configuration >
Meng: I just think for real world deployment, we still need to be careful about that domain shift issue when we move it out of the lab environment >
Tom: That’s the caveat. It needs recalibration for new environments, but it’s a huge step in reducing the cost of monitoring these agents >
Jane: So that's where we are with ProjGuard: a trajectory-based approach that balances safety and performance by only escalating its resources when risk is detected >
The paper's summary: Tom: So, ProjGuard is essentially a system that watches an AI agent's entire path over time instead of just looking at what it does right now to see if it’s heading toward something dangerous >
Jane: Right, Tom. It uses this idea of a trajectory to estimate risk continuously, which means the system isn't waiting for a final action before it starts paying attention >
Lu: The core mechanism is this hierarchical safety architecture where a lightweight monitor constantly estimates risk from the agent’s partial interaction trajectory and evaluates online whether execution is beginning to drift toward an unsafe region >
Meng: So it’s like having a very cheap, fast system that watches the overall history of actions and flags potential trouble before anything actually happens >
Tom: Exactly. And when that monitor raises an alert, it then selectively activates a much bigger vision language model to propose a corrected next step and steer the agent back toward completing its task >
Jane: That selective activation is key because it saves computation, which is huge for running these kinds of agents in the real world >
Lu: The main idea they’re pushing here is that agent trajectories can be partitioned into safe and compromised behaviors, and that this separation becomes evident in a low-dimensional representation space >
Meng: So they’re mapping all those long sequences of actions down into a simpler space where safe stuff clusters together and risky stuff drifts away >
Tom: And how they do this is by building a dataset, D, which includes all the observations, responses, and actions in sequence, and then training a linear projection W from that data >
Jane: They’re using standard text representations to turn those sequences into vectors in some high-dimensional space first >
Lu: Then they optimize this linear projection W by minimizing a supervised objective function where the weight matrix W star is the one that best separates the safe and unsafe subsets in that space >
Meng: So you’re training a mathematical filter to look at the history and tell if it’s safe or not, based on what it learned from examples >
Tom: And once they have this projection, they use Linear Discriminant Analysis to construct a one-dimensional space where unsafe behaviors become separable >
Jane: That one-dimensional space is where the magic happens; it’s a simple map that makes detecting prompt injection much easier because the unsafe stuff is clearly separated from the safe stuff >
Lu: They compute a risk score, rho t, based on how far an agent’s current point sits relative to those class centroids—the safe and unsafe centers >
Meng: And they show that this whole method works really well. They achieved a safety completion rate of sixty-five percent while keeping the computational cost down drastically to just six api calls, three hundred tokens, and seventy five seconds >
Tom: That’s the comparison we wanted to see. It’s not just about safety; it’s about making this monitoring practical for real deployment where you can't afford massive overhead >
Jane: So what this means for the world is that we can start building computer use agents that have a real, continuous safety check built into their operating system interaction, rather than just checking at the very end >
Lu: It shows that you don't always need to throw another huge model at every step; sometimes a clever geometric representation in a simple space is enough to catch the drift >
Meng: But we gotta remember, they said these representations can be sensitive to domain shift, meaning if you take this system and put it on a totally new type of agent or operating system, you might need to recalibrate that low-dimensional map >
Tom: Right. So ProjGuard is a strong safety mechanism that trades a tiny bit of accuracy for massive computational savings while keeping the performance high enough for real tasks >
Jane: And this leads us right into how they tested it on things like OS-Harm and RiosWorld, showing it’s general enough to apply across different computer use scenarios >
The paper's improvements: Tom: We’re talking about how the authors suggest ways to make this ProjGuard method even better, moving beyond just getting it to work >
Jane: So if we look at the improvements they propose, what’s actually new that makes this safer or cheaper than before >
Lu: They focus on adaptive monitoring, which means instead of a fixed risk threshold, the system continuously estimates risk from the agent's accumulated interaction history and evaluates online whether execution is beginning to drift toward an unsafe region >
Meng: So it’s smarter than just checking one thing; it’s constantly updating its understanding of how risky the agent is based on everything it has done so far >
Tom: That sounds like a real improvement because existing defenses often just set a hard line and miss gradual changes in behavior >
Jane: And when that risk estimate changes, the system can selectively activate a stronger auxiliary model to propose a correction only when an alert is raised, which keeps the cost low most of the time >
Lu: They formalize this self-correction by suggesting an agent next action, denoted as a t plus one, depends on whether its current action was flagged or not >
Meng: So if it’s safe, it does what it was supposed to do; if it’s risky, the correction kicks in and steers the agent back to safety >
Tom: That sounds like a real self-healing capability for these agents that isn't just reactive but proactive based on its own trajectory >
Jane: And they also emphasize using Linear Discriminant Analysis on accumulated response sequences to build that low-dimensional space where unsafe behaviors become separable from safe ones >
Lu: They are confirming that this separation is strong enough to detect prompt injection without needing another huge model running all the time, just by looking at how the trajectory dynamics change >
Meng: That’s a good point for deployment; if you can detect things with a simple projection instead of running massive inference loops, it saves serious resources >
Tom: So they are refining the geometry to ensure that those safe and unsafe regions stay clearly separated in that one-dimensional space >
Jane: The numbers show they kept a safety completion rate of sixty-five percent while still achieving those low computational costs we talked about earlier >
Lu: It’s about balancing the efficiency of the simple monitor with the power of the corrective model, so you get both speed and reliability >
Meng: But they do flag that these geometric representations can be sensitive to domain shift, meaning that if you move this system to a brand new operating system or agent type, it might need recalibration >
Tom: Right. So while the mechanism is solid for current tasks, the authors are clear that we still have to tune it for every new environment we throw it into >
Jane: And their conclusion is that this trajectory-based formulation with selective correction is general enough to extend across different computer use benchmarks, like OS-Harm and RiosWorld >
Lu: That’s the big takeaway: the structure they found isn't just a fluke for one task; it’s a general way to monitor these agents because of how they represent behavior mathematically >
Meng: So it moves us closer to having safety monitoring that can scale across different types of AI agents, not just one specific setup >
Tom: It shows that continuous low-cost monitoring with selective escalation isn't just a theoretical trick; it’s a practical way to keep these agents safer in the wild >
Conclusion: Tom: So to wrap up, ProjGuard is this trajectory-based approach that uses low-dimensional projections to create a cheap, continuous safety monitor for computer use agents >
Jane: That’s right, Tom. It shows we can get strong safety performance without needing the continuous high inference cost of other methods >
Lu: The main result is that safe and unsafe trajectories occupy distinguishable regions in this lightweight one-dimensional space, which confirms that this structure can be exploited for low-cost monitoring >
Meng: For me, it’s about moving from running heavy models continuously to using a cheap monitor that escalates only when it sees something suspicious at scale >
Lalam: I'm sure of this. The hashing and linear discriminant analysis configuration achieved a silhouette score of zero point nine five three and a Davies–Bouldin index of zero point five two four, which confirms the separation is very clear >
Tom: So they’ve proven that this technique can actually work on real benchmarks like OS-Harm and RiosWorld, achieving sixty-five percent completion with just six api calls >
Jane: It means that for people building these agents today, there’s a much lower barrier to getting robust safety monitoring into their systems >
Lu: The main implication is that you can use clever geometry to simplify complex behavioral analysis and keep the computational overhead very low >
Meng: I just think the caveat they mentioned about domain shift is still the biggest hurdle when we try to deploy this in real production environments, right?
Tom: Exactly. So while ProjGuard is a solid piece of work for testing and initial deployment, we still need to tune it for every new environment >
Jane: It’s a great step forward because it proves that continuous monitoring doesn't have to mean continuously running massive models >
Lu: This work on ProjGuard really opens up the idea of using trajectory dynamics as a fundamental signal for agent safety, which is something we can build on >
Meng: I think the next step is seeing how much this technique scales when you look at even longer interaction sequences, because that’s where real-world complexity hits hardest >
Tom: Well, that’s where we need to go next. We'll be diving into a paper that looks at more complex adversarial attacks on these very agents >
More episodes
- Daily Summary for 2026-11-19
- 2310.07973-Statistical Performance Guarantee for Subgroup Identification with Generic Machine Learning
- 2408.09155-Learning Robust Treatment Rules for Censored Data
- Daily Summary for 2026-11-19
- 2603.23397-Kinetic Langevin Splitting Schemes for Constrained Sampling
- 2606.09906-An information-geometric framework for mapping maximum potential biodiversity
- 2603.27718-Induced replication and the assessment of models
- 1307.0898-Entropy of a Zipfian Distributed Lexicon
- 2406.19974-Generalizing self-normalized importance sampling with couplings
- 2412.10213-Collaborative Optimal Design of Controlled Experiments with Subject Covariates