Session Proposals & Topics

AI workloads are changing the core assumptions Kubernetes was originally built around. Unlike stateless microservices, modern inference and agent systems are data-intensive, accelerator-bound, distributed across multi-node topologies, and bursty in ways CPU horizontal autoscalers cannot predict.

This session examines how Kubernetes and Google Kubernetes Engine are evolving into a hardware-aware, AI-native control plane—covering isolated code execution for autonomous agents with Agent Sandbox, fast pod checkpointing and restoration, in-place vertical resource resizing without container restarts, accelerator-aware scheduling via Dynamic Resource Allocation (DRA), distributed LLM serving with llm-d and vLLM, high-throughput networking with DRA-Net, and KV-cache-aware traffic routing through GKE Inference Gateway.

As AI agents and inference workloads become increasingly dynamic and resource-intensive, Kubernetes infrastructure must evolve beyond traditional container orchestration.

This talk explores how Google Kubernetes Engine enables scalable AI infrastructure through secure, isolated execution environments for agents, faster workload startup, dynamic resource adjustments without unnecessary restarts, hardware-aware resource allocation, and intelligent inference traffic routing. By connecting these capabilities across the agent, compute, and networking layers, we walk through a practical blueprint for building responsive, adaptable infrastructure for AI workloads at scale.

Learn how to build, test, and deploy a production-ready AI agent using Google’s open-source Agent Development Kit (ADK) in this hands-on developer workshop. Participants build a multi-step Marathon Planner Agent from scratch while practicing core agentic design patterns—including structured system instructions, modular skill loading, and live tool integration through Model Context Protocol (MCP) servers such as Google Maps.

We walk through the full engineering lifecycle: scaffolding an ADK project in Python, wiring deterministic tools and reusable skills, evaluating multi-turn reasoning locally with the ADK inspector, and deploying the containerized agent to Cloud Run. Attendees leave with working code and a clear mental model for shipping modular, cloud-ready agents.

In this practical, lab-based workshop, participants develop, containerize, and deploy a multimodal generative AI web application on Google Cloud. The session integrates the Gemini API on Vertex AI with an interactive Streamlit frontend and deploys the service to Cloud Run for zero-ops, scale-to-zero serving.

Rather than watching slides or pre-recorded demos, attendees work inside a live Google Cloud environment using temporary provisioned lab credentials—no personal billing account or prior cloud setup required. Participants configure Vertex AI SDK authentication, implement streaming multimodal generation, package the app with Docker, and ship a live HTTPS endpoint.

Where enterprise cloud strategy meets day-to-day developer velocity: synthesizing the most important engineering releases from Google Cloud Next ’26 and Google I/O ’26 into concrete architectural guidance.

First, we unpack the platform milestones from Cloud Next—including Gemini Live API capabilities, enterprise agent interoperability via the Model Context Protocol (MCP), and infrastructure advances across GKE and Google Cloud compute. Then we switch to the builder’s perspective from Google I/O, examining how the latest Gemini and open Gemma iterations, CLI/agentic developer workflows, and security primitives change how teams design and ship multi-cloud software.

Single-prompt demos come together in an afternoon; multi-agent systems that survive real users, flaky downstream APIs, and strict latency budgets require disciplined systems engineering. When every sub-agent call compounds token cost, latency, and hallucination surface area, architecture matters more than prompt wording.

This talk breaks down production multi-agent topologies built with Google’s Agent Development Kit (ADK) and standardized Model Context Protocol (MCP) tool servers. We cover coordinator-worker delegation vs. deterministic workflow graphs, scoped memory and context compaction, least-privilege MCP tool boundaries, OpenTelemetry trace instrumentation across reasoning hops, and automated trajectory evaluation.

Autonomous and tool-using AI agents require far more than a foundation model endpoint—they depend on grounding, short- and long-term memory, safe tool execution, and repeatable evaluation. Yet navigating the rapidly expanding ecosystem of frameworks, managed runtimes, and open models can overwhelm engineering teams.

This session maps out pragmatic reference architectures for enterprise AI agents and clarifies how Google Cloud’s building blocks fit together: Gemini and Gemma models, Vertex AI Agent Engine, ADK, grounding with enterprise data, and containerized deployment options. Attendees walk away with concrete design patterns for building agents that stay predictable, observable, and maintainable in production.

Machine learning teams move fastest when they do not have to reinvent cluster YAML, GPU drivers, or deployment scripts for every model experiment. Building an internal MLOps platform on Google Kubernetes Engine gives organizations portable, vendor-neutral workflows without sacrificing managed cloud automation.

In this session, we design an end-to-end GKE MLOps platform covering reproducible training and fine-tuning pipelines, fair-share multi-team accelerator queuing with Kueue, Spot and Flex-start GPU/TPU cost optimization, artifact lineage, and automated rollout pipelines from experiment registries into production inference pools.

Scaling AI/ML workloads from a single GPU node to dozens of accelerators exposes bottlenecks across container startup, storage throughput, pod scheduling, and cluster networking. Multi-gigabyte container images and massive model checkpoints can leave expensive GPUs sitting idle for minutes during scale-out events.

This deep-dive session focuses on the systems mechanics of running high-scale distributed training and low-latency inference on GKE. We cover GPU time-sharing vs. Multi-Instance GPU (MIG) partitioning, multi-host TPU slice topology scheduling, GKE image streaming and Cloud Storage FUSE / Anywhere Cache for rapid weight loading, and custom queue-depth autoscaling for inference fleets.

Replacing a live machine learning model in production carries risks that unit tests alone cannot catch—latency spikes under real payload distributions, silent accuracy drift, and memory regressions. Progressive delivery lets engineering teams validate new model revisions against real traffic while bounding blast radius.

In this hands-on workshop, participants implement controlled canary and traffic-splitting rollouts on Google Kubernetes Engine using Cloud Service Mesh (managed Istio). Attendees provision a GKE environment, deploy multiple revisions of a TensorFlow Serving inference service, route weighted traffic percentages (95/5 → 50/50 → 100%), inspect per-revision golden signals, and trigger instant zero-downtime rollbacks.

AI agents that execute code, query internal databases, and call external APIs dramatically expand the threat surface of a Kubernetes cluster. Traditional perimeter firewalls and static long-lived cloud credentials break down when workloads dynamically spin up tool sandboxes and access sensitive model weights.

Drawing from real-world cloud and identity platform engineering, this talk presents a defense-in-depth blueprint for multi-tenant GKE clusters: keyless authentication via Workload Identity Federation, kernel-level pod isolation with gVisor and Agent Sandbox, strict egress and FQDN network policies to mitigate prompt-injection data exfiltration, supply-chain attestation with Binary Authorization, and fleet-wide policy guardrails.

Classic Site Reliability Engineering assumes services return deterministic responses in milliseconds. Generative AI and agentic workloads violate both assumptions: responses stream over seconds, token counts skew tail latency by 10×, upstream model quotas throttle unpredictably, and an HTTP 200 OK can still carry a hallucinated or malformed answer.

This session adapts battle-tested SRE practices for production AI systems on Google Cloud and Kubernetes. We define actionable SLIs and SLOs for streaming inference (Time to First Token, Time Per Output Token, tool-call success rate, and semantic quality), implement token-aware rate limiting and graceful model fallback tiers, and design multi-region resilience across Vertex AI and GKE.

With serverless GPUs on Cloud Run, fully managed nodes on GKE Autopilot, and bare-metal topology control on GKE Standard, Google Cloud offers three compelling ways to run containerized AI services and open-weight models—yet choosing the wrong layer early either slows down product teams or locks in avoidable GPU spend.

This session provides an honest, engineering-driven decision matrix comparing Cloud Run (with and without GPUs), GKE Autopilot, and GKE Standard. Through real workload profiles—API-orchestrated ADK agents, bursty Gemma/vLLM inference, and steady high-throughput batch pipelines—we compare cold-start behavior, concurrency limits, traffic routing, networking, cost crossover points, and operational complexity.