A team on Google Cloud has Gemini, Vertex AI, and the Agent Development Kit, and an agent that demos beautifully. Same fork in the road as everywhere else: the model choice is not what decides production survival — the trace is. When the multi-agent flow returns a confident wrong answer, can someone open the trace and see the coordination that produced it? On the Google stack the tooling to say yes is there and unusually well-integrated, and the discipline that keeps it portable is the same one that keeps it honest. Here is the layout.
This is the Google-specific companion to the general case that OpenTelemetry is the tracing contract, and the deliberate mirror of the Microsoft write-up — leaning on OTel is precisely what keeps the two stacks comparable instead of two islands.
The shape of the stack
- Platform — Vertex AI, with Agent Engine (the managed runtime for deploying and running agents) as where production agents actually live.
- Framework — the Agent Development Kit (ADK), Google's open-source agent framework, with built-in tracing and a clean path to export it. ADK is the layer that decides what becomes a span.
- Models — Gemini. One component in the system; the trace is what tells you how it behaved, not the marketing.
- Telemetry backend — Cloud Trace, inside the broader Google Cloud Observability suite (Cloud Trace, Cloud Logging, Cloud Monitoring), where the spans land and get queried.
The Google stack's particular strength is integration: ADK traces flow into Cloud Trace with very little ceremony, and Agent Engine surfaces agent execution without a lot of bespoke plumbing. That convenience is real, and — exactly as on Azure — it is also the thing to stay slightly suspicious of.
Keep it OpenTelemetry, not Google-only
ADK emits tracing and Cloud Trace ingests OTel, so the healthy default is to instrument in OpenTelemetry with the GenAI semantic conventions and let Cloud Trace be the backend rather than the format. You get the native experience — ADK's built-in traces, Cloud Trace's waterfall, the Observability suite's dashboards — while the spans stay standard.
The reason is the same as everywhere: a span written as a portable OTel trace can also go to your own store for a regulated workload, or to an eval platform for LLM-as-judge scoring on production traces, with no code change. A span written as a Cloud-Trace-only artifact cannot. Use Google's backend fully; do not let it become the only reader your telemetry has.
What to capture on the span
Cloud Trace will show you the call waterfall. The spans that earn their keep carry the agent-specific context on top:
- Agent boundaries and reasoning — which agent ran, why it selected the tool it did, its confidence. ADK gives you structured spans; you make sure the why is on them, not just the what.
- Versions — prompt, tool, and policy revision on every span, so when an agent adapts and diverges the change is attributable instead of a regression with no commit.
- Token and cost attributes —
gen_ai.usage.*per generation; Gemini calls in a multi-step agent compound the same way every other model does.
Governance: the Collector and DLP
For regulated workloads, route through an OTel Collector and redact PII there, before telemetry leaves your perimeter, and lean on Sensitive Data Protection (Cloud DLP) for classification and de-identification. Same shape as the Azure guidance, different product names: redact once at the Collector, govern at the platform, and the prompts and tool arguments that reach Cloud Trace are already clean.
The honest assessment
Google's stack is an excellent place to run traced agents — ADK plus Agent Engine plus Cloud Trace is one of the more frictionless paths from "agent works in a notebook" to "agent is observable in production." The risk is the mirror image of Azure's: the integration is so smooth that you stop noticing your traces have quietly become Google-shaped. Take the frictionless path; keep the spans in OpenTelemetry. Then ADK's tracing, Cloud Trace's waterfalls, and the Observability dashboards are leverage you chose, not a dependency you got trapped in.
Closing
On Google Cloud the model is the easy call and the trace is the one that determines whether you can run the system at all. Vertex AI, ADK, and Cloud Trace hand you a strong, well-integrated observability story — take it, and keep the spans OpenTelemetry so the story travels. The agents that survive production on any cloud are the ones you can see inside; on Google the seeing is easy, so the only real discipline left is making sure what you see could leave.