THE SIGNAL IN ONE SENTENCE
The new agent control room is a data warehouse. Google Cloud has expanded agent observability across BigQuery and Looker. The idea is sensible: collect telemetry from first-party data agents and custom agents built with frameworks such as Agent Development Kit or LangGraph, store it in BigQuery and use familiar dashboards and analysis tools to understand what the agents are doing. Teams can inspect usage, latency, token consumption, sessions, knowledge sources, errors and execution paths. They can review conversations, reconstruct traces, cluster recurring failures and compare production behavior with evaluation results. That is useful. It is also how an observability system can quietly become the second most sensitive database in the company. The first database contains the source records. The second can contain the user question, the agent answer, identifiers, returned values, tool activity, errors, images, audio, video and the sequence that connects all of them. The source systems may be carefully segmented. The trace table may be wonderfully convenient. Convenience is not a security boundary. Google makes an important distinction between telemetry layers. Aggregate Cloud Monitoring metrics can describe request volume, latency and token use. Sanitized first-party Cloud Trace spans can describe steps without including core customer content such as prompts, responses, internal reasoning or generated SQL. These layers can help an operations team answer many questions without copying the conversation. Conversation logging is different. When an agent owner enables it for a supported BigQuery data agent, prompts, answers and turn-level telemetry are written to a customer-owned BigQuery table. Google documentation says the log can include the full user question, answer text, insights, assumptions, suggested follow-up questions, citation sources, result or chart names, latency, model token use, model version, finish reason, agent and conversation identifiers, a user identifier, status and error details. The answer can contain values returned from a protected source. That sentence deserves a yellow highlighter and perhaps a small alarm bell. Anyone who can read the log table may see values that the agent returned to a user, even if that reader cannot access the source table. The agent may have been authorized to answer the question. The analyst browsing the logging dataset may not be authorized to see the same answer. Authorization at query time does not automatically follow the copied result. Google first-party conversation logging includes a pre-turn privacy check. If a declared knowledge-source table uses row-level security, column-level policy tags or dynamic data masking, the turn is not logged. If the check cannot confirm the absence of those controls, the turn is also skipped. The agent still answers. That is a thoughtful fail-closed rule for logging. It is not a complete map of the data boundary. The documentation warns that the check looks at selected knowledge sources and does not inspect the tables behind a view. A view over a protected table can pass the check. Policies added later do not remove rows already copied into the log. Custom agent frameworks can capture a much richer execution trail than the managed first-party logger. For custom ADK and LangGraph agents, BigQuery agent analytics can stream raw requests, responses, tool calls, workflow events, errors and multimodal interaction data into BigQuery. The analysis SDK can reconstruct nested sessions, compare trajectories, run semantic evaluations, detect drift and support cross-session memory. This is powerful precisely because it is detailed. It can reconstruct a failure. It can also reconstruct a person. A support agent trace might expose a complaint, account number and failed identity check. A healthcare assistant trace might include symptoms and an appointment request. A workplace agent might capture a draft performance review, internal investigation or salary discussion. A coding agent might log a secret pasted into a prompt, a tool argument, a repository path or a file fragment returned in an error. Multimodal logging raises the stakes again. An image may contain a badge, face, address or screen capture. Audio may preserve a background conversation. Video may expose a room, device or person who never agreed to become telemetry. The right question is not whether to have observability. Agents without evidence trails are hard to debug, evaluate and govern. When they make a bad decision, teams need to know which input, model, tool, permission and source shaped the result. The right question is which layer can answer the operational question with the least sensitive material. Start with four separate buckets. Metrics answer how often, how long and how much. They cover counts, latency, token use, error rates and cost. Spans answer where the workflow went. They connect steps, services and timings without necessarily preserving content. Transcripts answer what the person and agent said. They can expose intent, identity and returned values. Payload traces answer exactly what tools and models exchanged. They may contain arguments, documents, media, SQL, intermediate results and error bodies. Do not treat those buckets as one logging switch. For each operational question, choose the shallowest layer that can answer it. If the team wants to know whether latency rose after a model change, metrics may be enough. If it wants to locate a slow tool, sanitized spans may be enough. If it wants to inspect a wrong answer, a sampled and redacted transcript may be necessary. If it wants to reproduce a tool-routing bug, a narrowly scoped payload trace may be justified for a short period. Whole-conversation logging should be the exception, not the default souvenir from every session. Every agent needs a logging manifest. Name the telemetry layers. List the exact event types and fields. Identify who can enable each layer, who can read it, the destination dataset, region, encryption key, retention period, deletion process, sampling rule, redaction rule and incident owner. Connect the manifest to a specific purpose. Debugging a launch for seven days is a purpose. Keeping everything because it may help someday is a shrug wearing a badge. Google documentation says it does not automatically delete conversation-log rows. The customer must configure partition expiration or another retention policy. The docs offer 90 days as an example, not a universal recommendation. Choose retention from the job. Operational metrics may need a longer trend window. Detailed payloads may need hours or days. Incident evidence may require a documented hold. Evaluation samples may need de-identification and a separate governed dataset. A cross-session memory system should not be smuggled into existence by leaving the trace table around forever. Expiration should be enforced in the table, not remembered in a wiki. Deletion also needs a complete path. Removing a source record does not remove a copy in a conversation log. Adding a new source policy does not remove previously logged values. Deleting a user-facing chat may not delete the trace table, dashboard extract, notebook output, exported sample, evaluation table or incident ticket that quoted it. Map the copies. When a user or administrator requests deletion, show which copies were removed, which were retained under a documented obligation and when each action completed. Access should be narrower than the source, not broader. Keep logging datasets separate from business datasets. Give the service agent only the write access it needs. Give analysts authorized views that expose the fields required for their role. Mask content and identifiers by default. Separate operational access from transcript review. Require a reason and a time-limited grant for raw payload inspection. Audit the readers. The access log should record who viewed raw conversations, which rows or partitions were queried, the stated purpose and whether results were exported. Alert on bulk reads, unusual hours, cross-region access, repeated searches for one person and joins between trace data and customer profiles. Redaction must happen before the copy when possible. Scrubbing a dashboard is not enough if the warehouse table still contains the secret. Build field allowlists at collection time. Drop known credential patterns, authentication headers, cookies, payment data and unnecessary document bodies. Replace direct identifiers with scoped pseudonyms. Avoid logging model context simply because it is already in memory. Errors deserve suspicion. Developers often log more on failure, exactly when a tool may dump request bodies, stack traces, environment details or upstream responses. A safe success path can have a very nosy error path. Test both. Sampling should be deliberate and visible. Google managed conversation logging records every eligible turn once enabled. The documentation says there is no collection-time sampling setting for that feature, so teams that need a smaller review set must account for the fact that the complete eligible stream first lands in the table. If full collection is not justified, use a different telemetry layer or build a collection path with an explicit sampling rule. Evaluation can create another copy. Google tooling can place benchmark results beside production logs and use warehouse functions or automated judges to cluster problems and score conversations. Keep the evaluator input scope visible. Record the model and prompt used to judge the trace. Store the score separately from raw content when possible. Sample human review to catch confident automated nonsense. An evaluation score is not a permission slip to keep the underlying conversation forever. Users need notice before collection. BigQuery Studio shows a notice when managed conversation logging is enabled. Google says organizations using the API in their own applications are responsible for giving their own notices and obtaining any required consent. Make the notice concrete. Say what is recorded, who can read it, how long it stays, why it is needed and how to report a problem. Do not hide transcript collection inside a general monitoring paragraph. A person may reasonably accept aggregate performance metrics and decline storage of the full conversation. Operators need a kill switch too. If a secret begins appearing in traces, the team should be able to stop content logging without shutting down the agent. If the logging pipeline fails, the interface should show that the evidence trail is incomplete. Google managed logger lets chat continue when logging fails and says an empty or missing table may be the only signal. That preserves availability, but it means monitoring the monitor matters. Test the boundary before production. Put protected source tables behind row policies, policy tags and masks. Confirm the managed logger skips those turns. Put the protected table behind a view and confirm whether the check behaves as documented. Add a policy after logging begins and verify old rows remain until the retention or deletion job removes them. Trigger a write failure and confirm the agent continues while the observability team receives an alert from its own controls. For custom agents, plant secrets in prompts, tool arguments, images, audio and error messages. Check which events reach BigQuery. Test nested tools, retries and duplicate writes. Google notes that best-effort delivery can miss turns and retries can create duplicate rows, so use event identifiers and do not pretend the log is a perfect transcript of reality. Then test the people. Can a platform engineer diagnose latency without raw transcripts? Can a quality reviewer see a redacted sample without user identifiers? Can an incident responder get temporary access to one session? Can a privacy team delete one person trace copies? Can an administrator explain the difference between metrics, spans, transcripts and payloads without opening five consoles and whispering into a paper bag? If not, the control room is not ready. The useful sequence is modest. Define the question. Choose the minimum telemetry layer. Redact before collection. Write to a separate governed dataset. Apply short automatic retention. Give readers filtered views. Audit raw access. Test protected sources and failure paths. Delete every downstream copy when its purpose ends. Observability should help a team see the agent. It should not help half the company see the user.
01
WHAT ACTUALLY CHANGED
Google Cloud announced expanded agent observability and evaluation across BigQuery and Looker on November 13, 2026.
The framework covers first-party data agents and custom agents built with frameworks including Agent Development Kit and LangGraph.
Cloud Monitoring metrics and sanitized first-party Cloud Trace spans can exclude prompts, model responses, internal reasoning and generated SQL.
Opted-in first-party conversation logging writes prompts, answers and turn-level telemetry to a customer-owned BigQuery table.
Google managed logger performs a pre-turn policy check and skips logging when declared knowledge sources use row-level security, policy tags or dynamic data masking.
Custom BigQuery agent analytics can stream requests, responses, tool calls, workflow events, errors and multimodal payloads.
BigQuery and Looker dashboards can surface usage, sessions, latency, token consumption and engagement.
Google provides tools for trace reconstruction, root-cause analysis, drift detection and agent evaluation.
Several monitoring and conversation-logging features are generally available, while some feedback, quota and evaluation capabilities remain in preview.
02
WHY THIS MATTERS
Agent logs can reproduce sensitive values returned from source systems, even for readers who lack access to those source systems.
A customer-owned table inherits the customer governance quality, including any mistakes in access, retention, masking and deletion.
Custom agent traces can contain tool arguments, errors and multimodal payloads that expose more than a managed transcript.
The managed privacy check does not inspect protected tables behind a view and does not remove rows logged before a policy change.
Google documentation says conversation-log rows are not automatically deleted, so customers must enforce retention.
Logging failures do not stop the chat, which protects availability but can leave incident evidence incomplete.
Metrics, spans, transcripts and payloads answer different questions and should not share one collection policy.
Evaluation pipelines, notebooks, exports and memory systems can create additional copies of the same sensitive interaction.
03
WHERE IT COULD HELP
- Create a logging manifest listing every telemetry layer, field, purpose, owner, reader, region, retention period and deletion path.
- Use aggregate metrics for cost and latency questions before collecting conversation content.
- Use sanitized spans to locate workflow failures without preserving prompts or responses.
- Enable transcripts only for a defined purpose, bounded population and short period.
- Put raw transcripts and payloads in separate datasets from operational metrics and business data.
- Apply partition expiration and verify it with an automated test rather than a policy document.
- Redact credentials, authentication data, payment information and unnecessary document bodies before ingestion.
- Give routine reviewers authorized views with masked content and pseudonymous identifiers.
- Require time-limited access and a recorded purpose for raw session inspection.
- Audit queries, exports, bulk reads and joins involving trace datasets.
- Test protected source tables, protected tables behind views and policies added after logging begins.
- Monitor the logging pipeline so missing evidence is visible when writes fail.
- Deduplicate events and state clearly that best-effort logs may be incomplete.
- Map downstream copies in dashboards, notebooks, evaluation tables, exports and incident tickets.
- Give users clear notice that distinguishes aggregate metrics from stored conversation content.
- Keep evaluation scores and long-term memory from becoming excuses for indefinite raw-content retention.
KEEP A HAND ON THE WHEEL
Google November 13 announcement and current BigQuery documentation establish the telemetry layers, supported frameworks, managed conversation logging, privacy checks, customer-owned tables, dashboards and evaluation tooling described here. The capabilities span generally available and preview features. Managed first-party logging and custom framework logging have different schemas, content and guardrails. A control documented for one path should not be assumed to protect the other. Google says sanitized first-party operational telemetry excludes core customer content. Managed conversation logs deliberately include prompts and responses. Custom agent analytics can capture richer execution events and multimodal payloads. The managed privacy check skips logging for declared knowledge sources protected by row access policies, policy tags or dynamic data masking. Google documentation warns that the check does not look through views to protected tables behind them. Google says it does not delete conversation-log rows automatically. Customers are responsible for table retention, access, masking, encryption, network controls, user notices and downstream deletion. Google also says best-effort delivery can miss turns and retries can occasionally duplicate rows. Logs are evidence, not a flawless recording of reality. The four-layer logging model, manifest, access workflow, redaction rules, deletion map, boundary tests and incident controls in this article are Plain Signal analysis. Official announcement date: November 13, 2026. Documentation updated November 10, 2026. Verified November 14, 2026.
04
TERMS WORTH KEEPING
SOURCES AND VERIFICATION STATUS
This article was written from the materials below. Product claims and dates were checked against those sources on November 14, 2026.
THE PUBLICATION ENGINE
WANT A SIGNAL OF YOUR OWN?
We build source-grounded publications, private briefings, and editorial systems for organizations with something useful to say.
WORK WITH US