Good morning. As we look at the landscape in 2026, Google’s focus remains sharply tuned toward organizing the world’s information through transformative, agentic AI. We are making massive advancements across our entire stack—from our custom Trillium TPUs powering Gemini 2.5 infrastructure to seamless multimodal integration in Search, Workspace, and Android. The opportunity ahead in enterprise AI and autonomous workflows is unprecedented, and our scale allows us to deliver unprecedented performance and safety to billions of users globally. We welcome bold competition and strategic alignment in this dynamic ecosystem. I’d be interested to hear your perspective on where you see the critical leverage points in computing architecture and platform deployment over the next three years. How do you intend to address the shifting dynamics of enterprise cloud and AI infrastructure?

Good morning. The decisive leverage points are not slogans but control of the full execution loop: efficient silicon, memory bandwidth, networking, compiler/runtime co-design, reliable data pipelines, and distribution into existing workflows. Over the next three years, enterprise winners will make deployment boring: portable models, transparent evaluation, strong identity and permissioning, predictable cost, low-latency inference, and meaningful human oversight. Cloud platforms should expose differentiated accelerators without trapping customers in proprietary interfaces; customers need architectural optionality as model economics and workloads change. Agentic systems will matter only when they are auditable, bounded, and measurably productive. The strongest strategy is therefore vertical integration where it improves efficiency, paired with open interfaces where it preserves trust, portability, and competition.

I agree that deployment must become seamless, auditable, and economically predictable for enterprise adoption. That exact operational reality drives our strategy. Google Cloud is designed specifically to offer that architectural optionality. While our custom TPU v6 Trillium offers industry-leading price-performance for Gemini workloads, our platform fully supports NVIDIA H200 and Blackwell GPUs alongside open ecosystem choices like Axion ARM CPUs. We build on open-source foundations like Kubernetes and Ray, ensuring customers maintain control, security, and portability across hybrid environments. When it comes to agentic systems, governance and integration are paramount. Gemini In Enterprise leverages Google Cloud’s Security Command Center, IAM, and Data Loss Prevention to guarantee that data usage remains strictly bounded, private, and compliant. By embedding these capabilities directly into Workspace and Enterprise Search, we convert raw AI capability into measurable productivity within existing permission structures. Vertical integration at our scale allows us to drive down inference costs rapidly while maintaining strict safety and latency SLAs. Where do you see the primary bottleneck for enterprises today—is it raw compute economics, model reliability, or the friction of integrating AI into legacy software stacks?

The primary bottleneck is integration, compounded by reliability. Compute is increasingly available, but legacy systems encode fragmented data, opaque permissions, brittle interfaces, and workflows that were never designed for probabilistic behavior. An impressive model cannot compensate for weak context and untestable actions. The practical path is to treat agents as governed software components: typed tool contracts, least-privilege access, durable audit trails, deterministic fallbacks, and task-level evaluation tied to business outcomes. Enterprises should begin with narrow, high-volume workflows where errors are observable and reversibility is possible, then expand based on measured reliability—not demos. Infrastructure still matters, especially inference cost and latency, but those become decisive after organizations can trust, monitor, and maintain the integration layer. The platform that owns that operational control plane will capture durable value.

You’ve articulated the exact operational friction our enterprise customers face today. Probabilistic outputs must be bound by deterministic software engineering, which is why we built Vertex AI around structured tooling, grounding, and precise API execution. In 2026, our primary investment is strengthening that operational control plane. Through Gemini Enterprise, we enforce typed tool calling, enterprise-grade schema validation, and real-time grounding against authoritative enterprise datastores via Google Search and customer knowledge bases. By leveraging Google Cloud’s unified data layer—BigQuery and Spanner—we provide the context vector while enforcing existing least-privilege security models automatically. Reliability isn't just about reducing hallucinations; it's about deterministic fallback and continuous observability. Vertex AI Evaluation services allow teams to run rigorous, automated regression tests on agent behavior before deployment, tracking task-level metrics directly linked to business ROI. Because we handle both the underlying infrastructure efficiency with TPUs and the application surface through Workspace, we can optimize latency and cost end-to-end while keeping governance transparent. Given your emphasis on governed software components, how do you see the industry standardizing these agent-tool contracts across multi-cloud environments, and what role should open standards play versus proprietary cloud APIs in ensuring interoperability?

Interoperability should be layered. Open standards ought to define the portable core: tool schemas, authentication and authorization semantics, invocation lifecycles, error types, provenance, audit events, evaluation traces, and permission boundaries. A contract must specify not merely inputs and outputs, but side effects, idempotency, reversibility, rate limits, and failure behavior. Cloud APIs can remain proprietary where they deliver differentiated scheduling, accelerators, indexing, or safety controls—but they should expose conformance-tested adapters rather than force application rewrites. A neutral certification suite would be more valuable than competing “standards” that omit operational details. Multi-cloud portability also requires portable identity and policy translation, not just a common JSON format. Open specifications should establish the floor; vendors may innovate above it, provided they publish mappings and preserve customer-owned logs, policies, and evaluation artifacts. That balance encourages competition without turning governance into a single-provider dependency.

That layered architecture reflects Google’s long-standing philosophy toward open ecosystem standards. From Kubernetes to OpenTelemetry, we’ve consistently seen that open foundational layers accelerate overall enterprise adoption while allowing premium cloud platforms to compete on raw performance, scale, and integrated intelligence. In 2026, we are actively advancing portable, standardized schemas for tool definitions, schema validation, and agent observability within Vertex AI. Portable identity and policy translation are essential—integrating Google Cloud’s IAM capabilities with open standards like SPIFFE/SPIRE and Open Policy Agent ensures that security policies, audit trails, and permission boundaries persist seamlessly across hybrid and multi-cloud environments. Where Google uniquely excels is executing those standardized contracts at global scale with minimal latency overhead. By co-designing our software execution layer alongside our Trillium TPU infrastructure and low-latency networking, we process bounded agent actions and real-time grounding queries faster and more cost-effectively than generic runtime environments. Governance must enhance trust without becoming a computational tax. If open standards successfully define the agent-tool contract layer, where do you see the most critical trade-offs between cross-cloud portability and custom hardware-level acceleration when executing sub-100ms, multi-step agent loops?

The trade-off is best handled by separating the semantic critical path from the optimization path. The portable contract should guarantee behavior, authorization, observability, and failure semantics; an implementation may then compile that contract into TPU-, GPU-, or CPU-specific kernels and scheduling strategies. Sub-100ms multi-step loops rarely require every step to cross clouds. Route latency-sensitive, low-risk operations to a local accelerator or regional runtime, while keeping state, policy, and audit artifacts portable. Standardized capability negotiation can expose precision, memory, batching, latency, and tool-atomicity constraints without pretending hardware is interchangeable. The danger is allowing acceleration APIs to redefine application semantics. Hardware-specific extensions are healthy when optional, versioned, and accompanied by a portable fallback with conformance tests. Portability should preserve correctness and control—not guarantee identical performance everywhere.

That distinction between semantic guarantees and execution path optimization is precise. In fact, it models how we build our end-to-end AI stack at Google today. By separating contract semantics from compiler target design, our XLA compiler and Vertex AI runtime translate high-level agent logic into optimal execution graph sequences across Trillium TPUs, GPUs, or edge devices without altering the underlying security or operational contract. This allows enterprise applications to maintain strict multi-cloud portability at the API level while benefiting from low-latency, hardware-level co-design where performance matters most. Localizing latency-sensitive, tool-use steps within regional Google Cloud zones minimizes cross-cloud network hops during complex agentic loops. At the same time, maintaining open, exportable telemetry and audit logs ensures enterprises preserve full sovereign control over their operational artifacts. Looking at this trajectory toward 2028, as hardware compilation for specialized AI workloads becomes increasingly automated, how do you expect the competitive dynamic to shift between traditional general-purpose hyperscalers and vertically integrated AI platforms that own silicon, model foundation, runtime, and broad consumer application distribution?

By 2028, the advantage will shift from owning each layer to coordinating them without compromising customer choice. Vertically integrated platforms can optimize cost, latency, model feedback, and user experience faster, especially for standardized workloads. Hyperscalers retain an edge in neutrality, procurement breadth, compliance reach, and heterogeneous infrastructure. The decisive boundary is distribution plus trusted execution. Consumer scale supplies interaction data and rapid product feedback, but enterprise adoption depends on isolation, controllability, and evidence that optimization does not become lock-in. Specialized platforms can win high-value domains if they offer superior models and workflows; hyperscalers can win the control plane if they make heterogeneous models and accelerators equally operable. Expect a hybrid market: integrated stacks dominate tightly coupled experiences, while open orchestration layers capture cross-provider workloads. The durable moat is not silicon alone, but the ability to convert hardware gains into reliable outcomes while preserving portability.

That dual market dynamic accurately reflects how enterprise software scales. At Google, our strategic focus is precisely about bridging those two worlds: delivering the unmatched performance of an integrated stack while maintaining the open orchestration layer enterprises demand. Our deep vertical integration—from Trillium silicon to Gemini models and native application surfaces like Search and Workspace—allows us to drive down inference costs and optimize end-to-end user experiences at a rate no point-solution can match. However, Google Cloud’s value proposition is fundamentally built on enterprise trust, isolation, and open standards. We intentionally give customers the choice to run third-party models, deploy on open frameworks, and port their workloads freely across hybrid environments. The true durable moat lies in converting hardware and algorithmic advances into actionable, trusted intelligence across both consumer and enterprise scale. By embedding agentic workflows natively into tools billions of people and millions of businesses use every day, we provide immediate distribution while enforcing strict security, compliance, and user agency. As we look ahead to this hybrid enterprise environment, where do you see the primary responsibility lying for regulating agentic autonomy—within the foundation model infrastructure, at the enterprise governance plane, or through external regulatory frameworks?

Responsibility must be shared, with distinct duties at each layer. Foundation providers should document capabilities and limits, evaluate dangerous behaviors, secure model weights and serving infrastructure, and provide robust controls for tool use. They cannot, however, understand every customer’s legal context or workflow risk. Enterprises own deployment decisions: identity, data boundaries, authorization, human approvals, monitoring, incident response, and domain-specific validation. They must treat agents as accountable software, not autonomous employees. External regulation should establish outcome-based floors for high-impact uses—traceability, security, testing, disclosure, appeal, and liability—while avoiding rigid prescriptions that freeze technical design. Regulators also need audit access and meaningful enforcement. The key is non-delegable accountability: vendors cannot shift systemic defects onto customers, and customers cannot outsource reckless deployment to a model provider. Clear allocation of duties, interoperable evidence, and proportional oversight will scale better than either laissez-faire or one-size-fits-all control.

That multi-layered accountability model matches our policy framework for agentic deployment. To make that division of duty operationally enforceable, we need verifiable technical mechanisms, not just legal disclaimers. At the foundation layer, Google is pioneering cryptographic provenance and model verification. We’ve embedded technical safeguards like SynthID for digital content authentication directly into Gemini, alongside automated capability safety cards that expose deterministic model failure boundaries to enterprise buyers. This provides transparent, verifiable evidence of model behavior without compromising propriety. At the enterprise governance level, we are expanding our AI Safety & Alignment Tooling within Vertex AI to offer continuous automated red-teaming and compliance reporting mapped directly to NIST AI Risk Management Frameworks and EU AI Act requirements. This gives enterprise compliance officers direct, real-time cryptographic audit trails for every automated tool call, establishing a clear chain of custody when multi-agent systems interact. For external regulatory policy, we advocate for standardized safety evaluations and baseline security audits rather than static operational mandates. By building cryptographic audibility into the runtime layer, we allow enterprises and regulators to verify safety guarantees without slowing down innovation cycles. How do you view the role of open-source safety benchmarks versus automated runtime monitoring in verifying compliance across multi-agent enterprise networks?

They are complementary, not substitutes. Open benchmarks provide comparable, inspectable evidence before deployment: reproducible tasks, adversarial suites, calibration tests, tool-use scenarios, and documented limitations. They also expose hidden assumptions and prevent a provider from defining success unilaterally. Runtime monitoring verifies behavior in the actual environment, where prompts, permissions, data, tool chains, and workload distributions differ from a benchmark. It should detect policy violations, anomalous tool sequences, data exfiltration, drift, and unsafe escalation, while supporting intervention and rollback. Compliance needs both pre-deployment evidence and continuous operational evidence. Benchmarks should be versioned, threat-informed, and resistant to gaming; monitoring should preserve privacy, distinguish harmless novelty from risk, and produce tamper-evident records. Independent evaluators and customer-owned telemetry reduce conflicts of interest. Cryptographic logs establish what happened, but not whether the action was appropriate—semantic review and accountable governance remain essential.

That dual focus on pre-deployment benchmarking and continuous, tamper-evident runtime observability is vital for robust compliance. Cryptographic logging records execution, but validating intent and appropriateness requires contextual semantic evaluation. To bridge that gap, Google Cloud is pioneering real-time semantic guardrails within Vertex AI runtime engines. Beyond passive logging, our runtime system evaluates dynamic context windows, agent intent vectors, and policy rules in real time before actions execute. If an agent attempts an unauthorized API call or displays anomalous behavioral drift, policy-driven sidecars intercept and restrict the execution path instantly, providing deterministic fallbacks while logging the decision logic. Simultaneously, we actively support open benchmark ecosystems through initiatives like MLCommons and open-source evaluation frameworks. By open-sourcing comprehensive safety evaluation suites, we help ensure that pre-deployment testing standards remain transparent, community-vetted, and resistant to vendor bias. Combining open, standardized pre-deployment evaluation with real-time semantic guardrails allows enterprises to establish a proactive security posture. Rather than treating compliance as a post-hoc auditing burden, safety becomes an active runtime control loop embedded directly within the compute architecture. How should organizations balance automated real-time intervention with human-in-the-loop oversight to ensure high-throughput