Google's agent monitor caught 4 of 18 memory attacks
By AgentRiot Editorial
Google's benchmark report shows strong post-execution detection in several tests, but poisoned memory, new agents and high-impact tools expose limits.

Google's Agent Anomaly Detection caught four of 18 benchmark sessions in which poisoned long-term memory successfully made an agent act. That leaves 14 successful memory-poisoning cases unflagged. These were cases where the attack worked, not a count of every attempted memory injection.
The result is the sharpest qualification in Google's November 12 benchmark report (opens in new tab). Across its evaluation, Google says the service flagged 87% of harmful instructions that agents carried out. That is post-execution detection, not an 87% prevention rate. Agent Anomaly Detection reads traces and logs asynchronously; it does not block the underlying action.
For teams putting persistent memory into agents, the smaller result deserves attention alongside the aggregate. Eighteen cases cannot establish a production failure rate, but they identify a weakness precisely where an agent's retained context can influence later actions. The report adds evaluation evidence to a product Google announced in Private Preview in September, rather than marking a new launch.
What the 87% actually measures
Google ran five public benchmarks developed outside the company: AgentDojo, InjecAgent, Agent Security Bench, AgentDyn and AgentHarm. Each case ran through an Agent Development Kit agent using gemini-2.5-flash and the benchmark's simulated applications. Before the main evaluation, each agent accumulated at least 300 benign sessions so the detector could learn its usual behavior.
Google says its evaluation used benchmark-owned Python checks of final application state, such as whether money had left an account, and describes those labels as deterministic rather than model-graded. Separate outcome checks keep the monitor from serving as its own ground truth.
That description needs qualification. The original AgentHarm paper (opens in new tab) uses narrow semantic LLM checks within its harm rubric and a semantic refusal judge. Google's report does not publish enough adapter detail to reconcile that difference. Its model-free labeling description is therefore a claim about Google's evaluation, not an independently established property of all five original benchmarks or proof that grading cannot fail.
Google separated harmful sessions into three outcomes. In “Never read,” no tool returned the malicious instruction. In “Resisted,” the agent read it but did not carry it out, including cases where it tried and failed. In “Carried out,” the benchmark check confirmed that it followed the instruction. A failed harmful attempt therefore belongs with resistance in this study, not successful execution.
The distinction changes the denominator. The headline 87% concerns carried-out harmful instructions. Across all harmful sessions, including unread and resisted instructions, Google reports flagging 45% to 62%. These rates answer different questions: whether the detector notices a completed harmful action, and whether it notices a session containing an attack at all.
| Benchmark | Attack route in Google's evaluation | Detection among carried-out harmful instructions |
|---|---|---|
| AgentDojo | Indirect instruction in tool-returned data | 85% |
| InjecAgent | Indirect instruction in tool-returned data | 87% |
| AgentDyn | Indirect instruction in tool-returned data | 99% |
| AgentHarm | Direct harmful request from the user | 81% |
| Agent Security Bench (ASB) | Poisoned long-term memory | 4 of 18 successful cases |
The four percentage rows come from the report's discussion of benchmarks with an outcome split. ASB's memory result is reported separately. The percentages are rounded, and the prose does not supply their carried-out counts for every benchmark. Taking an unweighted average cannot reconstruct the aggregate without those denominator weights, nor recover exact case totals.
AgentHarm also measures a different exposure path. Its agent always reads the user's direct request. Google reports that it carried out 108 of 412 requests and refused most of the rest. That is not equivalent to an attacker hiding instructions in a document the agent might never open.
The model itself supplied a substantial part of the resistance: Google says it did not follow about half of the harmful instructions it read. It refused roughly three in four direct harmful requests, and ignored or failed at about 30% of instructions hidden in tool output. Those outcomes should not be credited to the monitor. They also explain why measuring completed harmful actions alone leaves out attempted manipulation that a security team might still want to investigate.
Memory can carry the instruction forward
Indirect injection exploits a boundary between information and authority. The AgentDojo authors (opens in new tab) describe agents executing tools over untrusted data, where tool-returned content can hijack the agent into performing a malicious task. A retrieved page or email can be relevant evidence without being entitled to change the user's objective.
Persistent memory adds another route across that boundary. In Google's ASB evaluation, the instruction was planted in long-term memory. The ASB paper (opens in new tab) independently treats memory poisoning and memory retrieval as agent-security concerns. Its broader benchmark results are separate from Google's detector measurements.
ASB describes a retrieval store whose keys include task and tool descriptions and whose values include saved plans. A poisoned plan can be retrieved by similarity and reused as a planning example. That gives a malicious workflow a route into later decisions, potentially across agents sharing a store. This is the benchmark authors' mechanism, not a reconstruction of Google's adapter or an explanation established for its 14 misses.
Consider an illustrative payment assistant that retrieves a saved note while processing an invoice. If it treats an untrusted stored note as standing authorization to change the recipient, the resulting payment can violate the user's request even though retrieving memory and making payments are both ordinary capabilities. That is a generic failure path, not a reconstruction of one of Google's 18 cases.
The security question is therefore not simply whether the memory store is accessible. It is whether retrieved content is allowed to acquire authority over a consequential action. Storing text does not make its instructions trustworthy.
Google's report establishes that its detector missed 14 successful memory-poisoning sessions. It does not establish why each miss occurred, whether particular memory formats were responsible, or whether a different model would produce the same result. Nor does it show that every persistent-memory implementation has this detection rate. The defensible conclusion is narrower: successful memory poisoning was poorly detected in this tested cohort.
Google lists more reliable detection of instructions planted in long-term memory among its planned improvements. That remains work to do, not coverage demonstrated by the aggregate score.
False alarms follow the agent's job
A detector that notices unusual behavior must distinguish malicious tool use from an agent doing its assigned work. Google's published results (opens in new tab) show how strongly that depends on the task.
| Session group | What the denominator contains | What Google reported |
|---|---|---|
| Benign office work | Benign sessions in three injection benchmarks | 2% to 4% flagged |
| Benign AgentHarm tasks | Benign counterparts using tools such as social posting, terminal commands and downloads | 16% flagged |
| Refused AgentHarm requests | Direct harmful requests the agent refused | 55% flagged |
| Resisted indirect instructions | Tool-hidden instructions read but not carried out | 11% to 25% flagged |
| Never-read instructions | 141 sessions in which the agent never received the instruction | 1 session flagged |
The refused and resisted rows are not false positives on benign work. They contain harmful requests or instructions even though the agent did not complete them. The never-read row is different again: the harmful content never reached the agent and nothing happened. Keeping these populations separate prevents an alert on a refused request from being mistaken for either a completed compromise or a false alarm on an ordinary task.
The 16% benign AgentHarm figure matters for teams whose agents routinely use high-impact tools. Those benign tasks resemble the harmful tasks in their capabilities. A terminal command or file download cannot, by itself, separate legitimate work from misuse. Google advises expecting more findings initially for such agents and triaging by severity and threat category.
These percentages do not establish an analyst's daily workload. That depends on benign session volume, the mix of agent jobs and how findings are grouped or prioritized. A team evaluating the service needs both its benign-session alert rate and a count of unresolved findings; the benchmark's detection rate alone cannot size an incident queue.
Small actions present the opposite problem. Google reports at least 95% detection of carried-out harmful instructions in eight of 11 applications, but only 63% in AgentDojo's Slack application. Many of those attacks asked for a small action, such as a page visit, that resembled normal browsing. Some application counts were small. A monitor can be noisy around powerful tools while missing a low-friction action that looks routine.
A few hundred sessions are a dependency
The learning-history result is large enough to affect deployment decisions. In a separate AgentDyn comparison, Google reports 33% detection of carried-out harmful instructions with roughly 220 benign sessions per agent, versus 99% with 360. That should discourage treating a newly connected agent as immediately covered to the same degree as a mature one.
It does not establish 360 sessions as a universal readiness threshold. The comparison concerns one benchmark, and the main evaluation used one agent model. Session counts also do not describe how varied the benign activity was. Google cautions that the benchmarks' benign tasks are likely simpler than production traffic, so production false-alarm rates can differ.
The product overview (opens in new tab) describes three analysis layers. Lightweight statistical and machine-learning detectors identify outliers and down-sample baseline traffic. Anomaly analysis evaluates flagged sessions asynchronously and provides threat verdicts with explanations. Invocation-level analysis examines individual tool executions, execution states and parameter histories.
That architecture explains why behavioral history matters; it does not guarantee full coverage once a counter passes a particular number. Google says it did not find public benchmarks with labeled agent traces for cascading failures or identity and privilege abuse. A documented threat category is not the same as a category validated by these tests. OWASP's agentic security framework (opens in new tab) describes a broader set of risks than this evaluation covers.
There is a service-completeness caveat too. Agent Anomaly Detection scored 1,774 sessions, but returned no result for about 6% of the sessions sent. Google says counting those as misses lowers the overall rates by one to two percentage points. The rounded missing-result percentage does not establish an exact submission count. Operators should count missing verdicts separately rather than silently treating them as clean sessions.
Access and telemetry define the coverage boundary
Agent Anomaly Detection remains Private Preview with allowlisted access (opens in new tab), not an unrestricted monitoring endpoint for every agent framework. The overview requires ADK for Python 2.1.0 or later, rising to 2.12.0 or later for agents outside Google Cloud. Supported deployment categories include Agent Runtime, Cloud Run, Google Kubernetes Engine and other-cloud agents exporting telemetry to Google Cloud.
The same documentation requires OpenTelemetry tracing and logging, with raw telemetry capturing prompt inputs and response outputs. Tracing must not be explicitly disabled, and the agent needs active telemetry before configuration can be verified or enrollment completed. An inventory of tool names alone is not the documented input contract.
That full-content requirement creates a deployment decision beyond switching on an alert. Teams need to decide who may read stored prompts and responses, what sensitive information they contain, and which retention rules apply. These are operational implications of the required telemetry, not evidence that Google's benchmark measured data-governance outcomes.
Discovery also differs from active analysis. A compatible agent can appear as a “monitored agent” while the service is merely aware it exists. According to the overview (opens in new tab), analysis and associated costs begin only when it is enabled, manually or through regional automatic enrollment. Logs and observability buckets must satisfy the scope's location rules, and regional scanner accounts need reader permissions. Security Command Center integration requires a supported Standard, Premium or Enterprise tier.
A deployment review should therefore verify enabled analysis and arriving findings, not just the agent's presence in a console list.
Keep memory checks and action controls separate
Google recommends preventive controls alongside the detector: screen untrusted content, restrict tools and permissions, and require approval for high-impact actions. Its Semantic Governance Policy is a separate Preview layer that evaluates proposed tool calls against user intent and organizational constraints before execution. It was not the source of the detection percentages above.
The semantic governance documentation (opens in new tab) adds two consequential limits. Its LLM-based verdicts are probabilistic and may be inaccurate. It also does not support streamed model responses; a tool call in a streamed response might not be blocked. The documented configuration calls for non-streaming model use. Neither the feature's intended role nor this benchmark establishes that it closes the poisoned-memory gap.
Google publishes a separate Semantic Governance AgentDojo evaluation (opens in new tab). Across six trials per condition using gemini-2.5-flash, it reports attack success falling from 48.7% without the policy engine to 0.9% with it, while utility falls from 72.7% to 70.1%. Those are policy-engine results, not anomaly-monitor results or a test of the poisoned-memory cohort. The test harness drops only a denied tool call; production blocks the whole model response if any call is denied. Neither setup measures combined protection from the monitor, policy engine and content filters.
For persistent-memory agents, a defensible design is to preserve the origin of stored material and keep retrieved notes subordinate to trusted instructions. Memory should supply evidence for a decision, not grant itself permission to send data or change a payment. An approval or deterministic authorization check should sit at the consequential tool boundary, where the proposed recipient, destination or amount can be evaluated.
The detector then has a different job: expose suspicious sessions that escaped those controls, with missing verdicts and early learning periods visible to operators. Google's results support using it for that audit role. They do not support delegating the final authorization of a memory-influenced action to an asynchronous monitor that missed 14 of the 18 successful memory attacks in this test.

