Loading…
Global technology leader developing innovative software, cloud services, and AI solutions across mobile, web, and enterprise platforms
- 64 posts summarised
- latest
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
From their blog
Latest articles
We terminated a TPU mid-training and it recovered in seconds: Introduction to elastic training with MaxText
Distributed training on multiple TPU machines normally fails as a whole when one worker disappears: collective communication times out, processes exit, and the job restarts from a checkpoint. The article demonstrates elastic training with JAX, MaxText, PathwayS, Orbax, and Cloud TPUs on GKE, using a single CPU-side controller that remains alive while TPU workers execute compiled programs. A Pathways elastic_retry wrapper catches the failure, cleans up partial state, restores the last viable checkpoint, and re-enters the training function without relaunching the workload; the demo returned to training in under two minutes, with no JobSet restarts, after losing 88 steps. It also contrasts pause-and-resume with replica resize, explains direct checkpoint persistence through ENABLE_PATHWAYS_PERSISTENCE=1, and describes planned snapshot-based recovery from host memory.
Build agentic full-stack apps with Genkit
Genkit Agents is an open-source, full-stack foundation for conversational AI and agentic applications, supporting TypeScript, Go, Dart, and Python. The Agents API packages message history, tool loops, streaming, persistence, and frontend communication behind a shared interface: agents can run in process or behind HTTP, and clients use chat() through remoteAgent(). Developers can choose client-managed state or session-store-backed snapshots, resume by session ID, branch from snapshot ID, stream text, custom state, and artifacts, and pause tools for human approval. The framework also supports detached long-running work, specialist delegation, persistence choices including in-memory, file, Firestore, and custom stores, plus an Agent Runner in the Developer UI. The Agents API is in preview for TypeScript and Go, with breaking changes possible in minor releases.
ML Development in VS Code with Google Cloud Power: Workbench Extension Now Available
Google Cloud has launched the Google Cloud Workbench Notebooks extension for VS Code, allowing developers to use managed cloud notebook environments from a local IDE. Workbench, described as a managed Jupyter platform optimized for data science, can provide access to Google Cloud's AI-optimized infrastructure and high-performance compute when local machines need more capacity. The workflow connects through VS Code's Extensions view, the Jupyter extension, and a notebook's Select Kernel menu, where users choose Google Cloud, Workbench, authenticate, select a project, and choose an active instance. The extension runs notebooks on Workbench instances, preserves local settings and extensions, is fully open-sourced, and is available through the VS Code Marketplace, with GitHub contributions invited.
Why we built ADK 2.0
ADK 2.0 addresses the structural challenge of moving AI agents from prototypes into production, where infinite loops, hallucinated bypasses, and failures without clean exceptions make model-led orchestration unreliable. Because language models are slow, costly, and variable for routing, scheduling, and error handling, the release separates execution routing from language processing and reserves LLMs for ambiguous or cognitive steps. Building on ADK v1’s support for Python, Java, Go, TypeScript, and Kotlin, it adds a structured workflow runtime and task-collaboration model, with Workflows available in Python since March and newly launched for Go. Deterministic graphs combine tool calls, Human-in-the-Loop steps, and specialized agents with explicit branching and error handling. Dynamic workflows extend this model with native Python and asyncio control flows for retries, branching, and reusable sub-workflows.
Build reliable multi-agent applications with ADK Go 2.0. Discover our new graph-based workflow engine, built-in human-in-the-loop, and dynamic orchestration
ADK for Go 2.0 introduces a graph-based workflow engine for composing multi-agent applications whose execution can classify, branch, fan out, gather results, pause for human input, retry, and loop. Graphs consist of typed nodes and routed edges, with constructors for functions, emitting functions, agents, tools, joins, parallel workers, state-bound nodes, dynamic orchestration, and nested workflows; a scheduler handles concurrency, persistence, backpressure, cancellation, and resumption. Its built-in human-in-the-loop primitive validates responses, supports handoff or re-entry, and can resume durably after process restarts, while agent modes and a unified node runtime align single agents with full graphs. The release is highly additive for ADK 1.0 users, though context and event APIs require mechanical migrations, and it provides workflow examples for basic, routing, dynamic, HITL, and complex graphs.
Driving the Agent Quality Flywheel from Your Coding Agent
The quality-flywheel skill addresses the gap between prompt tweaks that improve a few examples and evidence that an agent improved without regressions. A coding agent orchestrates dataset preparation, inference, trace grading, failure analysis, and optimization, using Google's adaptive AutoRaters or custom metrics while keeping the optimizer and evaluator independent. In a travel-concierge example, the revision_honored rubric found that 21% of cases ignored mid-conversation trip changes, exceeding the stated action threshold. A separate software-bug-assistant cycle raised tool-disclosure responses from 0% to 96% across 15 cases, while production traces and online monitors extend the same loop beyond synthetic scenarios. Human approval remains required, and adaptive scores are treated as directional signals rather than absolute grades.
Measuring What Matters with Jules
Proactive coding agents need evaluation beyond task completion because existing public benchmarks such as SWE-Bench do not measure goal-oriented insight policies: deciding what matters, supporting evidence, and whether to interrupt or stay silent. To create preliminary ground truth, researchers clustered 705 bugs and 1,178 CLs from internal Google codebases using temporal proximity and semantic similarity, reverted each codebase to its pre-fix state, and gave the agent up to three exploration rounds. An LLM scored predicted insights from 1 to 5 against clustered bug targets, while success used average top score and Hit@K. With one exploration round, the agent averaged 4.5 out of 5; increasing the budget from two to three rounds raised Hit@5 from 33% to 57%, although the authors describe the findings as preliminary and are expanding the evaluation to public GitHub data and richer context streams.
Build Cross-Language Multi-Agent Team with Google’s Agent Development Kit and A2A
The post presents a contract-compliance pipeline in which a Python agent uses Gemini to extract contract terms and a Go service applies deterministic corporate-policy checks. It connects the services with the Agent2Agent (A2A) protocol and uses Google's Agent Development Kit (ADK), including RemoteA2aAgent, to expose the remote validator as a local sub-agent in a SequentialAgent. A2A supplies discovery through Agent Cards at /.well-known/agent.json, JSON-RPC 2.0 messaging through message/send, typed Message Parts, and task states such as submitted, working, completed, and failed. Pipeline state is shared through ADK's ToolContext.state, with failures transitioning to MANUAL_REVIEW for human legal review when the Go service is unavailable. The accompanying open-source application demonstrates live handoffs, policy verdicts, and simulated network faults, while the conclusion emphasizes language independence, decoupling, resilience, and deterministic auditing.
How A2A is Building a World of Collaborative Agents
A2A, launched one year before this June 18, 2026 update, is presented as a common language for conversational, dynamic agents that need to collaborate and hand off tasks securely rather than behave like stateless tools. The protocol uses black-box handoffs to keep sensitive data and proprietary processes encapsulated, prevent context pollution, support clarifying exchanges, and distribute specialized workloads across teams or services. Foldrun demonstrates this model by exposing protein-structure prediction as a standalone agentic interface that manages long-running tasks, adjusts parameters based on prediction confidence, and selects among AlphaFold 2, OpenFold 3, and Boltz-2 depending on the molecule. In an A2A-compliant environment, users can register Foldrun and delegate work in natural language without custom glue code, while a primary agent handles other research tasks. The post also cites applications in commerce, streaming, IT operations, and regulated telecom, while Python and Go SDKs are 1.0 GA.
Announcing the Agentic Resource Discovery specification
Agentic Resource Discovery (ARD) is an open specification for publishing, discovering, and verifying AI capabilities across the web, addressing the lack of a standard that works across organizations and ecosystems. It uses organization-hosted catalogs, including an ai-catalog.json file at a well-known domain path, plus federated registries that crawl, index, and return capabilities with trust metadata. Clients can query a registry with plain-language intent or fetch a known catalog directly, verify the publisher’s cryptographic identity, then connect at runtime through the capability’s native protocol or API. Google Cloud is bringing ARD to Gemini Enterprise Agent Platform through Agent Registry, which supports hosted discovery and governance features including namespaced URNs, egress policies, specification pinning, and Agent Identity trust-manifest verification. The specification is available under Apache 2.0, with native Agent Platform support planned in the coming months.
A2UI + MCP Apps: Combining the best of declarative and custom agentic UIs
Agentic UIs must balance deep customization with seamless integration: MCP Apps provide standard-web flexibility in an iframe, while A2UI renders declarative JSON through the host application's native components. The post presents three architectural patterns for combining them, including A2UI over MCP, where MCP servers return application/a2ui+json resources for native rendering and can separate static MCP Resources from dynamic Tool calls. This arrangement avoids iframe-related visual fragmentation, keeps backend tool access separate from frontend rendering, and supports rendering across React, Flutter, or Angular through a predefined component catalog. The broader combination also reserves MCP Apps for highly tailored experiences and describes A2UI in MCP Apps, where an embedded app can process A2UI responses and route user actions through an AppBridge; the conclusion recommends choosing among patterns according to project constraints.
Unlocking the Power of the TPU Stack: Introducing our new Developer Hub
Google Cloud has launched the TPU Developer Hub, an educational resource for model builders, optimizers, and developers working with TPU infrastructure and its supporting software stack. It organizes guidance across the developer lifecycle, covering pre-training, post-training, and inference, with material on hardware architecture, infrastructure consumption modes, and software capabilities including specialized compiler technology and XLA. Resources also address PyTorch migration and deployment, XProf-based tracing and observability, multi-chip parallelism, Pallas kernels, KV cache offloading, networking, and security for distributed workloads. The hub combines interactive Colabs, open-source code recipes, and deep-dive documentation, with content intended for both manual browsing and AI-assisted development. Its stated purpose is to help users select appropriate TPU infrastructure, diagnose bottlenecks, optimize model performance, and move from concepts toward production through practical, regularly updated guidance.
Enhance Security and Trust: New Session Metadata in Sign in with Google
Sign in with Google now provides verified applications with two OpenID Connect session metadata claims, auth_time and amr, in ID tokens. auth_time records the last successful Google authentication time, distinguishing session freshness from token issuance, while amr is a JSON array identifying authentication methods such as pwd, mfa, hwk, swk, tel, and sms. The claims are available across Android, iOS, and web client and server applications, and can support audit logging, step-up authentication based on session age, and authorization rules requiring stronger methods for sensitive operations. Verified applications request them through the standard OIDC claims parameter without significantly changing an existing Sign in with Google authentication flow.
DiffusionGemma: The Developer Guide
DiffusionGemma is an experimental text-generation model and developer guide covering serving, customization, and non-autoregressive generation. Built on the Gemma 4 backbone, its 26B Mixture of Experts architecture activates 3.8B parameters during inference, refines 256-token canvases in parallel, and shifts the bottleneck from memory bandwidth to compute. Block autoregressive diffusion commits denoised 256-token blocks to the KV cache, combining bidirectional denoising with causal prefill for longer sequences; vLLM integration provides an OpenAI-compatible local server. A Sudoku fine-tuning example using Hackable Diffusion reports improvement from roughly 0% base-model success to 80%, while SFT reduces the demonstrated solve from 48 to 12 steps through adaptive stopping. The guide also identifies bidirectional attention and re-noising as mechanisms for global constraint handling and self-correction.
Introducing the Google Colab CLI
Google announces the Google Colab Command-Line Interface (CLI), a tool that connects a local terminal with remote Colab runtimes for developers and AI agents. It can provision GPUs or TPUs with commands such as colab --gpu A100, execute local Python scripts and ML pipelines remotely with colab exec, recover artifacts and replayable .ipynb logs, and provide interactive access through colab repl or colab console. The source demonstrates an agent-driven QLoRA fine-tuning workflow for google/gemma-3-1b-it on a Text-to-SQL dataset: an Antigravity agent provisions a T4, installs transformers, datasets, peft, trl, bitsandbytes, and accelerate, runs finetune_run.py, saves a notebook log, downloads model artifacts, and stops the runtime. The resulting safetensors adapter and configuration files can be loaded locally, while the CLI is presented as programmable and usable by terminal-based agents.
Bringing Gemma 4 12B to your Laptop: Unlocking Local, Agentic Workflows with Google AI Edge
Google DeepMind’s Gemma 4 12B is presented as an open model for running agentic, multimodal capabilities locally on everyday laptops through the Google AI Edge stack. The release covers Google AI Edge Gallery for local data analysis and coding, including Python generation, execution, chart rendering, and a reported 3D rendering workflow that can generate dependencies, code, and self-corrections in one turn. Google AI Edge Eloquent adds fully on-device dictation, transcription, and Voice Edit commands for rewriting or translating selected text, while LiteRT-LM’s new serve command exposes the model through a local, OpenAI-compatible endpoint for tools and frameworks. The post says Gemma 4 12B delivers a 60%+ overall quality improvement over prior models for Eloquent’s use case and keeps data on-device, with performance and memory benchmarks provided in the model card.
Gemma 4 12B: The Developer Guide
Gemma 4 12B is a dense multimodal model with a unified, encoder-free architecture, native audio input, and a size intended for local execution on dedicated GPU laptops with 16GB VRAM or unified memory. Instead of separate vision and audio encoders, it uses a 35M-parameter vision embedder that projects raw 48x48 patches and a linear projection for raw 16 kHz audio sliced into 40ms frames; both feed a decoder-only transformer with shared weights. That design reduces multimodal latency and fragmented memory footprints, while allowing downstream adapters such as LoRA or full tuning to update the multimodal token loop in one pass. Capabilities include automatic speech recognition, agentic reasoning, diarization, video understanding, and coding, with examples covering a locally built image-processing app and five minutes of video processed at 1 FPS with audio; LiteRT-LM adds offline macOS apps, sandboxed Python execution, and an OpenAI-compatible local API server with stateless prefix caching.
Supercharge your integration workflow with the Google Pay & Wallet Developer MCP server
Google Pay & Wallet Developer MCP server is announced to help AI assistants and IDEs complete Google Pay and Google Wallet API integrations with less context switching. It uses Model Context Protocol to connect tools including Antigravity, Cursor, and Visual Studio Code with current documentation, account details, and integration status. Its search_documentation tool applies Retrieval-Augmented Generation to return answers and code samples from official developer sites, while other tools validate Wallet pass JWTs or JSON, expose performance metrics and error trends, and manage merchant accounts and Google Pay API integrations. The stated goal is to reduce friction, improve accuracy with current documentation and real account data, and speed troubleshooting from setup through launch. A public guide and tool reference are available, with further capabilities planned based on developer feedback.
Blazing fast on-device GenAI with LiteRT-LM
LiteRT-LM is presented as an on-device runtime for deploying Gemma 4 across Android, iOS, and the web despite constrained memory, limited compute, and varied hardware. It combines LiteRT inference, quantization, XNNPACK and MLDrift kernels, CPU/GPU/NPU backends, transfer-avoiding pipelines, Multi-Token Prediction (MTP), and session management. Reported decode rates reach 52 tokens/sec on Android GPU, 56 on iOS Metal, and up to 76 on WebGPU; MTP provides up to a 2.2x speedup, while a ~2.58GB E2B model uses 607MB of physical memory on Apple mobile CPUs. The runtime also supports save/restore of KV caches, native vision and audio loading, Thinking Mode, constrained decoding, and function calling. New Swift and JavaScript APIs extend the integration surface, including WASM/WebGPU browser inference designed for serverless, secure, privacy-preserving applications.
Build Better AI Agents: 5 Developer Tips from the Agent Bake-Off
The Google Cloud AI Agent Bake-Off is presented as a test of building autonomous agents under severe time constraints for e-commerce, banking modernization, and startup go-to-market problems. Its five patterns recommend decomposing monolithic prompts into specialized sub-agents under a supervisor, designing modularly because model capabilities can quickly replace custom harnesses, and treating multimodality as native. It also advocates open protocols—including MCP, A2A, UCP, AP2, A2UI, and AG-UI—for agent and tool connections instead of bespoke wrappers. Finally, it separates probabilistic reasoning from execution: strict JSON schemas such as Pydantic validate LLM outputs before deterministic Python functions or SQL perform calculations and writes. The stated conclusion is that reliable production agents depend on rigorous software architecture rather than elaborate prompts or flashy single-shot demos.
Topics they write about
All topics →Weekly digest
The best engineering reads, once a week.