Google’s 16 November hands-on guide for Agent Anomaly Detection has a prerequisite worth reading before the setup steps: the detector looks at traces and logs that include prompt and response content. The sample deployment sets OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT to EVENT_ONLY and sends that content to Cloud Logging, where the detector reads it. Monitoring an agent means making a decision about where its conversations go. The benchmark report Google published four days earlier states it as an instruction:
“Send complete telemetry. Enable ADK tracing and logging, including prompt and response content.”
Google, Agent Anomaly Detection benchmark report, 12 November 2026
The same report adds a useful denominator. Google reports that the detector flagged 87% of harmful instructions an agent actually carried out, for post-execution review. That is not 87% blocked, and it is not 87% of all harmful sessions. A detector that reads conversation content can give responders another signal. It also becomes another system that stores sensitive text.
This is design analysis with an illustrative telemetry table. I haven’t deployed this preview service or tested its detectors. My running example is a hypothetical incident-response agent that reads alerts and runbooks and can request bounded changes to a service.
What goes into the trace
The incident agent sees more than a user’s opening request. It reads alert payloads, runbook passages and tool responses, then produces tool-call arguments and action requests. Some of those may contain customer identifiers, internal hostnames or credentials pasted into an incident by mistake. If the detector needs the full prompt and response content, sending that text to a logging system changes where the agent’s data goes.
The setup guide shows the deployment settings it uses to enable telemetry and capture message content. It routes the logs and an Observability dataset to the same US or EU multi-region. The feature is in Private Preview, and the guide’s sample uses Google’s Agent Runtime and Agent Development Kit. These are requirements of that integration, not claims about every agent-monitoring product.
| Data | Signal it can provide | Platform decision |
|---|---|---|
| User prompt | Requested task and scope | Which personal fields enter logs |
| Tool result | External instructions the agent saw | Who can read raw returned content |
| Agent response | What the agent said or attempted | Whether content needs redaction |
| Coverage signal | Which sessions were observed | How missing telemetry pages someone |
The table is a design review, not a claim that Google’s product offers a separate switch for each row. The guide enables prompt and response content capture as telemetry. I wouldn’t infer from the word “event” that the content is metadata, or assume that a log’s existing retention and access policy is suitable for transcripts. The feature-specific pages I opened don’t establish the right retention period, a redaction mechanism, or whether every organisation’s current logging controls apply unchanged. I would check those against the service’s own documentation and the organisation’s data policy before enabling it.
I would keep two views separate. The operations view needs to tell an on-call engineer that an agent ran, which tools it called, whether a policy decision passed, and where the run ended. The investigation view may need the raw text that explains why it went off task. Give the first view to the people who operate the service. Restrict the second to the people who investigate findings, and set its retention and access deliberately. If redaction or sampling changes the content the detector sees, replay known cases before relying on the modified feed.
That distinction matters in the running example. An alert might include a user-submitted log excerpt. The incident agent reads it, then calls a deployment tool. The tool call, target service and policy result are operational facts. The excerpt itself may include a pasted token. I want the trace to connect the excerpt to the tool call, but I don’t want every operator dashboard to become a search interface over raw incident text.
Read the denominator first
Google’s benchmark is more careful than a headline detection rate suggests. The company ran five public benchmarks with an Agent Development Kit agent using gemini-2.5-flash against simulated apps. Its report covers 1,774 sessions. At least 300 benign sessions were run first for each agent so the detector could learn its usual behaviour.
The 87% figure applies to harmful instructions the agent carried out. Include the harmful sessions the agent never read or resisted, and Google reports a 45% to 62% flag rate instead. The gap has a plain cause: of 141 sessions where the agent never read the harmful instruction, the detector flagged 1, and it flagged 11% to 25% of the sessions where the agent resisted. It reports false alarms on 2% to 16% of benign sessions, varying with the tools in ordinary use. For the sessions where poisoned memory made the agent act, it flagged 4 of 18. The report also says about 6% of sessions returned no result; treating those as misses lowered its overall rates by one to two percentage points.
Those numbers say where the product may help, and where a platform still has work to do. They do not tell me what will happen on a different model, tool set, customer population or workload. Google itself says the apps were simulated and benign tasks may be simpler than production traffic. Its benchmark is vendor-authored, although it uses public tests that Google says it did not write. I would use it to form questions for my own evaluation, not as a release guarantee.
Google’s report calls findings “post-execution review” and says the detector doesn’t block actions: it reads traces and logs asynchronously. The setup guide says findings usually appear within a few minutes. In the incident example, a service change can already have happened by the time the alert reaches the on-call queue. An anomaly finding may tell the team where to investigate. It doesn’t revoke a credential, roll back a deployment or decide whether a write is allowed.
That is why I would keep the enforcement path separate. A policy check at the tool boundary decides whether this principal can perform this action on this service, using current state. Approval remains a decision from a different principal when the action needs one. The detector can add evidence after the action or flag a session for review; it should not be the only thing standing between an agent and a production mutation. My release-evaluation post is about what evidence supports a release decision. This one is about what a running system must collect, and what its monitor can do with the data.
Coverage is part of the service
A detector can’t inspect a session it doesn’t receive. Google’s guide says an agent only appears in the monitored list after it has sent telemetry, and sessions that started before monitoring becomes active are not analysed. The setup takes around 30 minutes in the walkthrough. An onboarding dashboard that says “enabled” can therefore give the wrong impression if the agent has not produced a trace or if the trace lacks the content the detector needs.
The guide exposes a “Monitored agents” metric as well as “Detected events”, and suggests an alert for metric absence. I would treat the first as a coverage signal, not a success metric. A quiet detector may mean the agent behaved normally, but it may also mean no telemetry arrived. A missing observation should not look like a clean session.
Coverage also takes time to build. The detector learns how each agent usually behaves, and on one benchmark Google reports 33% of harmful sessions flagged when each agent had about 220 benign sessions behind it, against 99% with 360. A newly onboarded agent can be sending complete telemetry and still be weakly monitored.
For the incident agent, I would track three separate states: a session started, a complete trace reached the monitor, and a finding came back. Keep an identifier that joins the agent session, tool call and policy result without copying the full conversation into every operational log. When a finding is raised, the investigation view can fetch the associated raw content under its own access policy. If the integration cannot separate those stores, that is a design constraint to document before rollout, not something to discover during an incident.
What I’d do on Monday
- List the fields in prompts, tool results and responses before enabling content capture.
- Confirm where raw telemetry is stored, who can read it and which retention policy applies.
- Keep prevention in the tool executor: check identity, resource scope and current state before a write.
- Measure sessions with complete telemetry separately from sessions that returned no finding.
- Replay benign, goal-hijack and poisoned-memory cases against the exact model and tools you plan to deploy.
- Alert on monitoring coverage loss, then route high-severity findings to a person who can act.
Limitations
This is design analysis, not a deployment report or an independent test. Google’s benchmark uses one model and simulated apps, and its results are vendor-reported. I haven’t measured how content redaction, sampling or a different tool mix would affect detection.
I could verify the preview setup guide’s telemetry requirements, regions and coverage behaviour, but not feature-specific retention or redaction guarantees. I would confirm those with the service documentation and the organisation’s data owners before sending production conversations to the detector.