Agentic Application Middleware · Google Feature Trail

Oct 2026The Outer Loop, Insights First: An Ambient Quality Agent That Diagnoses Your Production Agent- Google Developers BlogThis post introduces AQuA (Ambient Quality Agent), an unattended system for monitoring and diagnosing production agent failures. AQuA sweeps production trajectories, grades sessions against a checklist of common breakdowns, clusters findings into issue clusters, verifies these clusters, and tracks them as new or recurring issues. It provides root-cause analysis by comparing failing trajectories with deployed source snapshots, citing specific code locations or external dependencies. AQuA is released as open-source building blocks for integration into existing projects and stacks.

Oct 2026Supercharge your development with the Google Developer Knowledge API ecosystem- Google Developers BlogIntroduces the Google Developer Knowledge API ecosystem, providing programmatic access to Google's developer documentation for AI agents, IDE extensions, and automated workflows. Highlights the gcloud CLI surface for terminal integration, an agent skill for AI coding assistants, client libraries for production systems, and the API Explorer for interactive testing. Emphasizes grounded Q&A, fresh documentation, and reduced reliance on web scraping or stale LLM training data.

Sep 2026Turn your REST APIs into MCP tools with Google Cloud API Gateway- Google Developers BlogThis post introduces the integration of Google Cloud API Gateway with the Model Context Protocol (MCP) in Public Preview. It details how API Gateway can act as a remote MCP server by annotating OpenAPI specifications, enabling existing REST APIs to be exposed as agent-ready tools. The post explains the 'how it works' by describing the transcoding of MCP JSON-RPC requests to REST requests, the application of existing policies, and the translation of responses. It provides code examples for annotating OpenAPI specs, deploying the gateway, securing tool discovery with JWTs, and connecting an agent using the ADK. Key benefits highlighted include discoverability via API Hub and Agent Registry, and the elimination of separate MCP server operations by leveraging existing gateway infrastructure, authentication, quotas, and logging. The post also mentions roadmap items like resource and prompt support, response streaming, and Model Armor payload inspection, along with current limitations.

Sep 2026Introducing Support for Local AI Models in the Antigravity SDK- Google Developers BlogIntroduces support for running local AI models (Gemma 4 26B with LiteRT) within the Antigravity SDK for offline agentic workflows. Demonstrates hybrid orchestration patterns combining cloud and local models for tasks like code auditing and patching. Showcases the SDK's capability to build local system utilities (CLI resource monitor) autonomously. Adds support for OpenAI-compatible local inference backends (Ollama, LM Studio, vLLM) via `LocalOpenAIAgentConfig`.

Sep 2026Why client SDK generation belongs in the open- Google Developers BlogThis post announces the open-sourcing of Speakeasy's OpenAPI code generation suite (under AGPLv3), which Google DeepMind partnered with to generate client SDKs for their Gemini Interactions, Agents, and Webhooks APIs. The migration involved aligning type definitions, preserving error hierarchies and streaming behavior, and integrating the generator into Google's build system. The open-sourced suite includes multi-language SDK generators (Python, TypeScript, Go, Java, C#, PHP, Ruby) with features like static typing, SSE streaming, retries, and pagination; an agent-native CLI generator; and a documentation MCP server generator. This move aims to mitigate platform risk from proprietary tooling and accelerate the development of AI-powered tools and client libraries.

Sep 2026Build zero-trust AI agents that judge intent, not just syntax- Google Developers BlogThis post details the implementation of runtime governance for AI agents on the Gemini Enterprise Agent Platform. It introduces Model Armor for edge screening of prompts and responses, Semantic Governance Policies for natural-language evaluation of tool calls against business rules, and Agent Anomaly Detection for identifying multi-turn exploits. The post provides code examples for Model Armor's ingress screening and egress data redaction, and a YAML example for Semantic Governance policies. It also illustrates how Agent Anomaly Detection can catch cumulative drainage attacks across multiple turns. The core contribution is shifting security from build-time, explicit controls to runtime, adaptive, platform-managed governance.

Sep 2026Autonomous LLM post-training with Tunix on TPUs- Google Developers BlogThis post introduces the `autofinetune` project, which applies autonomous research loops to LLM post-training (SFT and RL via GRPO). It details the paradigm shift from manual tuning to automated loops, where an agent modifies training scripts, runs jobs, measures metrics, and commits improvements based on a human-defined `program.md`. Two case studies are presented: SFT on FunctionGemma using Tunix on Cloud TPUs, and RL (GRPO) on Gemma 3 1B for math reasoning using Tunix on Cloud TPUs. The post highlights the use of Tunix, Gemma, Cloud TPUs, Antigravity CLI, and Gemini Flash 3.7 in these autonomous experiments.

Sep 2026Announcing ADK for Kotlin 1.0: Building Production-Ready AI Agents in Kotlin, Android, and Beyond- Google Developers BlogThis post announces the 1.0 general availability release of the Agent Development Kit (ADK) for Kotlin. It highlights the achievement of full ADK 1.0 Core parity, bringing advanced multi-agent orchestration patterns like hierarchical systems, context compaction, human-in-the-loop (HITL) flows, annotation-based tools, session resumability, Java interoperability, and enterprise integrations (VertexAI) to idiomatic Kotlin. A key contribution is the introduction of Android-first, on-device extensions, enabling local execution of agents using LiteRT-LM, ML Kit (beta), and persistence services like Room and AppSearch. The post also details the use of Kotlin Symbol Processing (KSP) for compile-time generation of type-safe function call definitions and the integration of skills via Markdown files for progressive disclosure, exemplified by a database incident response agent. For Android development, it showcases a financial assistant agent leveraging Firebase AI, Room for session storage, and AppSearch for indexed memory, with sensitive transactions requiring explicit user approval.

Sep 2026The Anatomy of Harness Engineering: How to Evaluate, Iterate, and Guard AI Coding Agents- Google Developers BlogThis post introduces a new approach to evaluating AI coding agents, emphasizing behavioral evaluations over traditional end-to-end benchmarks. It details how to write flexible assertions based on task complexity, automate batch evaluations for stability monitoring, and use these evaluations as guardrails for prompt engineering and model iteration. The post provides a Python code example using the Antigravity SDK to demonstrate asserting agent behavior (e.g., using web search) rather than just output prose. It advocates for treating the evaluation harness as standard software requiring unit and integration testing.

Sep 2026Driving Developer Excellence: Inside the Program Sprints- Google Developers BlogThis post details improvements to agent governance on Gemini Enterprise, focusing on provisioning identities, registration in the Agent Registry, binding to the Agent Gateway, applying policies and content safety (including Model Armor), and verifying enforcement through auditable trails. Specific improvements include transparent prerequisites for governance setup (e.g., explicitly stating Identity-Aware Proxy API requirement), secure-by-default Model Armor extension configurations with guidance on security vs. latency trade-offs, zero-interruption Agent Gateway binding by auto-allowing essential Google-managed platform APIs, step-by-step guidance for provisioning Private Service Connect (PSC) endpoints and private Cloud DNS zones for semantic governance, auditing and standardizing IAM Common Expression Language (CEL) attribute references to use the precise `api.getAttribute()` format, clarifying the architectural distinction between 'bind time' and 'runtime' policy evaluations in Agent Registry and Automatic Registration guides, and publishing exact log stream names and copy-pasteable Logs Explorer queries for monitoring Agent Gateways and Content Security.

Sep 20264 engineering patterns behind the strongest AI Agents Challenge submissions- Google Developers BlogThis post details four engineering patterns observed in strong AI Agent Challenge submissions: Bidirectional MCP (agents acting as both clients and servers of their own tools), Event-driven concurrency (agents reacting to shared signals in parallel via an event bus), Same-bar fallback (using a smaller model as a fallback with the same validation as the primary model), and Tiered routing (using cheaper, deterministic checks before invoking expensive models). It emphasizes practical implementation details like using MCP tool layers to manage database access and prevent token budget blowouts, employing asyncio.Queue for agent communication, centralizing validation logic to ensure consistent quality, and implementing multi-layer classifiers for cost optimization. The post highlights how these patterns, often facilitated by frameworks like the Agent Development Kit (ADK) and Agents CLI, contribute to building more robust and efficient AI agent systems.

Aug 2026How to Evaluate Live & Voice Agents in ADK- Google Developers BlogThis post introduces native live evaluation capabilities within the ADK (Agent Development Kit). It details how to set up and run evaluations for voice-based agents by simulating user audio input using Gemini TTS. The post provides a concrete example of a multi-agent workflow orchestrated by a `Workflow` object, demonstrating how control and state are passed between agents. It outlines the creation of eval sets with both conversation scenarios (using personas and conversation plans) and fixed conversations. The configuration for live evaluation includes specifying the user simulator type (`llm_audio`), the models for turn-taking logic and audio synthesis, and the criteria for evaluation (e.g., rubric-based trajectory quality). The post also highlights the integration of these live evaluations into the ADK Web interface for interactive debugging, including the ability to play back audio clips of agent responses.

Aug 2026Build zero-trust AI agents with Google's Agent Development Kit- Google Developers BlogThis post introduces a zero-trust architecture for building secure AI agents. It details three key layers: 1. Cryptographic write signatures using Cloud KMS and Service Accounts for non-repudiation and tamper detection, with example Python code for signing and verification. 2. Kernel-level code isolation using gVisor for executing dynamically generated code in a secure sandbox with zero network egress and resource limits, demonstrated with a Python runner. 3. Deterministic semantic gateways acting as reverse proxies to enforce business logic and filter sensitive data through CI/CD regression testing guardrails, with example Python code for input/output inspection and unit tests.

Aug 2026Agent Plugins package your skills, tools, and more- Google Developers BlogGoogle is joining the Agent Plugins specification as a core maintainer, contributing to the standardization of packaging for agent skills and MCP servers. This post announces the integration of Agent Plugins support into Google's Agents CLI and Data Agent Kit. Agents CLI will package Google's expert skills in the Agent Plugins format, making them distributable across compatible clients. Data Agent Kit will provide plugins connecting to Google Data Cloud services (BigQuery, Spanner, Cloud SQL) in the Agent Plugins format, ensuring portability across compatible clients. The post details the structure of an Agent Plugin, emphasizing its simplicity with a `plugin.json` manifest and fixed locations for `skills/` and `mcp.json`. It highlights the benefits of a standardized package format for avoiding forking and drift of components across different client implementations.

Aug 2026Scaling AI Agent Infrastructure with the MCP Stateless updates- Google Developers BlogThis post details the evolution of the Model Context Protocol (MCP) from a stateful session model to a stateless one, driven by the need for cloud-native scalability. Key changes include the removal of the `initialize` handshake and `Mcp-Session-Id` header, making each request self-describing with metadata in a `_meta` field. This enables standard round-robin load balancing, serverless deployment, transparent failover, and eliminates the need for shared session stores like Redis. HTTP standardization with headers like `Mcp-Protocol-Version` and `Mcp-Method` allows for routing and auditing without deep packet inspection. The introduction of `ttlMs` and `cacheScope` enables intelligent caching. Multi Round-Trip Requests (MRTR) handle elicitation statelessly by returning `InputRequiredResult` with `requestState`. The Tasks Extension allows for asynchronous tool execution via `taskId` without blocking client connections. Security is enhanced with Issuer Verification (RFC 9207) and Resource Indicators (RFC 8707). Tool schemas now fully support JSON Schema 2020-12.

Aug 2026A unified API for AI model routing- Google Developers BlogThis post introduces the Public Preview of Model Routing in Google Cloud API Gateway. It enables dynamic routing of OpenAI-compatible requests to Gemini, Claude, and OpenAI OSS-GPT models through a unified API Gateway. The configuration is done via an OpenAPI 3.x specification using the `x-google-api-management` extension, defining backends and routing rules. The post provides a YAML example for configuration and a `curl` command for sending requests. It highlights the ability to transcode payloads on the fly and route across different models hosted on the same Vertex AI host.

Jul 2026Agent and Model Evaluations in Gemini Enterprise Agent Platform are now GA- Google Developers BlogThis post announces the general availability of agent and model evaluations within the Gemini Enterprise Agent Platform. It details the introduction of pre-built and custom metrics (computation-based, code-based, and LLM-as-a-judge), the concept of experiments for local and online evaluation, and integrations with case generation, user simulators, and environment simulators. It also highlights online monitors for continuous evaluation of live traffic, issue clustering for failure analysis, and various access points (SDK, CLI, console, ADK) for using these features. Pricing is based on model calls and Cloud Storage for server-side runs.

Jul 2026Enable on-demand expertise with Agent Skills in Genkit Go- Google Developers BlogThis post introduces Agent Skills as a new capability within the Genkit framework, extending the Agentic Application Middleware. It details the concept of progressive disclosure for AI agents, where specialized expertise is loaded on-demand via skills defined in SKILL.md files. The post explains the discovery, activation, and execution stages of skills and provides Go code examples demonstrating how to integrate the Skills middleware into Genkit flows for recipe generation and a multi-modal art restoration application. It highlights the benefits of token efficiency, lean implementation, and resource bundling provided by Agent Skills.

Jul 2026Scaling Agentic RL: High-Throughput Agentic Training with Tunix- Google Developers BlogThis post introduces Tunix, a new post-training library for Google's agentic RL training. Tunix addresses infrastructure challenges by introducing asynchronous rollouts to decouple TPU execution from host-side environment latency and barrier-free pipelining with a dynamic producer-consumer architecture to prevent pipeline stalls. It also provides continuous, lightweight instrumentation for domain-specific RL metrics, correlating them with TPU timelines for global execution efficiency visibility. Tunix supports plug-and-play OSS environments and custom agent/environment implementations, allowing for rapid onboarding of new RL environments and agents.

Jul 2026Building scalable AI agents with modular prompt transpilation- Google Developers BlogIntroduces a modular prompt transpilation system for AI agents, treating prompts as software artifacts. This system uses modular skill files, a templating layer for composition, and a transpiler to generate deterministic, validated prompt artifacts. It emphasizes build-time validation for missing imports, undefined variables, and circular dependencies, enabling CI/CD integration and drift checking. The system also supports dynamic skill retrieval at runtime via progressive disclosure and allows agents to propose updates to their instruction layers through pull requests, which are then subjected to validation and review.

Jul 2026Expanding Choice in Gemini Enterprise Agent Platform: Introducing Grounding with Parallel Web Search- Google Developers BlogThis post introduces the integration of Parallel Web Systems as a native web grounding provider on the Gemini Enterprise Agent Platform. This allows Gemini models to be anchored in real-time web search results provided by Parallel's Search API, which is purpose-built for agentic workloads. The integration enhances factual accuracy and verifiability by providing exact citations to original sources. It offers expanded licensing and architectural flexibility, enabling programmatic calls at scale, extraction and caching of web data, and post-processing of grounding results with other LLMs. This supports complex agentic workflows such as catalog and database enrichment, autonomous agents for regulatory compliance and risk assessment, and multi-agent orchestration by passing search results to other LLMs.

Jul 2026Bridging the Domain Gap: AI Race Coach built with Antigravity and Gemini- Google Developers BlogThis post details the application of Antigravity and Gemini to build a real-time AI race coach. It showcases stateful orchestration and telemetry ingestion using Antigravity, edge reasoning with Gemma 4 on a Pixel 10 TPU for low-latency audio coaching, and cloud reasoning with Gemini API for driver modeling. A custom USB interface was engineered to bypass wireless latency for direct vehicle telemetry ingestion. The post highlights the technical activation of the Pixel 10 TPU for 40 tokens/sec performance and its translation to mission-critical enterprise domains.

Jul 2026Build agentic full-stack apps with Genkit- Google Developers BlogThis post introduces Genkit, an open-source framework for building full-stack, AI-powered, and agentic applications. It details the Genkit Agents API, which simplifies the development of conversational AI agents by abstracting away complexities like message history, tool loops, streaming, persistence, and frontend protocols. Key features highlighted include defining agents with system prompts and tools, managing state (server-managed via session stores like Firestore, or client-managed), serving agents over HTTP with a unified wire protocol for both backend and frontend clients, implementing human approval workflows for interruptible tools, handling long-running tasks with detached turns and pending snapshots, and coordinating specialized agents through delegation middleware. The post also contrasts Genkit with the Agent Development Kit (ADK), recommending ADK for systems where multi-agent orchestration is the primary focus and a managed runtime is desired.

Jul 2026ML Development in VS Code with Google Cloud Power: Workbench Extension Now Available- Google Developers BlogIntroduces the Google Cloud Workbench Notebooks extension for VS Code, enabling users to connect their local IDE to managed cloud environments for ML development. This extension streamlines the ML lifecycle by eliminating context switching and allowing users to run notebooks directly on Workbench instances within VS Code. It is open-sourced and integrates with the Jupyter extension.

Jul 2026Why we built ADK 2.0- Google Developers BlogThis post introduces ADK 2.0, which enhances agentic application development by introducing a structured workflow runtime and task-collaboration model. It addresses the limitations of pure autonomous agents in production environments by allowing developers to blend deterministic execution logic (workflows) with open-ended LLM-based agent steps. This approach aims to improve reliability, reduce costs, and mitigate risks like context bloat and prompt injection by separating execution routing from language processing. The post details the customer refund processing example, contrasting a vanilla LLM agent approach with the ADK 2.0 workflow approach, highlighting efficiency gains in token usage and latency. It also discusses advantages like mitigating context bloat, securing execution pathways, enabling dynamic workflows, and structured multi-agent collaboration.

Jun 2026Build 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- Google Developers BlogADK for Go 2.0 introduces a graph-based workflow engine for composing multi-agent applications, human-in-the-loop (HITL) as a built-in primitive, dynamic orchestration in plain Go, LLM agent modes, and a unified node runtime. This allows for more robust, observable, and resumable agent workflows, with features like retry policies, timeouts, and concurrency capping. The update also unifies the runtime for single agents and full graphs, and introduces a single `agent.Context` type for tools, callbacks, and workflow nodes.

Jun 2026Driving the Agent Quality Flywheel from Your Coding Agent- Google Developers BlogThis post introduces a developer-facing skill for coding agents that automates the agent quality evaluation flywheel. It details a five-stage process (Prepare Data, Run Inference, Grade, Analyze Failures, Optimize & Iterate) and introduces the concept of decoupling the optimizer from the evaluator. It also highlights the creation of custom metrics, like 'revision_honored', to detect specific failure modes in conversational agents, and provides examples of its application with the `_travel-concierge_` agent.

Jun 2026Build Cross-Language Multi-Agent Team with Google’s Agent Development Kit and A2A- Google Developers BlogThis post introduces the Agent2Agent (A2A) protocol as an open standard for cross-language agent interoperability, detailing its discovery (Agent Cards), communication (JSON-RPC 2.0), and task lifecycle mechanisms. It also showcases the Agent Development Kit (ADK) and its RemoteA2aAgent abstraction for integrating remote A2A-compliant services as local sub-agents. A concrete example of a multi-agent pipeline for contract compliance is presented, involving a Python agent for extraction and a Go agent for validation, connected via A2A and orchestrated by ADK. The post highlights architectural patterns for production multi-agent systems, including decomposition into specialized agents, context management via shared state (ToolContext.state), and fail-safe patterns like manual review transitions.

Jun 2026Measuring What Matters with Jules- Google Developers BlogThis post introduces a novel evaluation methodology for proactive AI coding agents. It proposes clustering historical bug fixes based on temporal proximity and semantic similarity to define "aspirational goals" as ground truth. The methodology involves setting up an evaluation environment where an agent explores a codebase for a defined budget (N rounds) and generates diagnostic insights. These insights are then judged by an LLM against the ground truth goals. Preliminary results show the core diagnostic logic works and that increased exploration budgets improve agent performance (Hit@5 accuracy). The post also announces plans to expand this evaluation to public GitHub data.

Jun 2026How A2A is Building a World of Collaborative Agents- Google Developers BlogThis post introduces the Agent-to-Agent (A2A) protocol as a new architectural paradigm for AI agent collaboration, moving beyond rigid REST APIs. It details the architectural advantages of A2A: secure boundaries for sensitive data, zero context pollution by offloading dependencies to peer agents, dynamic autonomy allowing for conversational interaction and refinement of plans, and workload distribution enabling modular development by specialized agents. The FoldRun agentic interface for life sciences is presented as a concrete example of A2A in action, simplifying complex tasks like protein structure prediction by allowing agents to delegate to specialized peers. The post also outlines other application areas for A2A, including agentic commerce, enterprise data and real-time streaming, cross-platform IT/DevOps, and secure telecom. It provides links to A2A SDKs for Python, Go, Java, .NET, and JavaScript/TypeScript.

Jun 2026A2UI + MCP Apps: Combining the best of declarative and custom agentic UIs- Google Developers BlogThis post introduces two architectural patterns for integrating Model Context Protocol (MCP) Apps with Agent-to-User Interface (A2UI) components: 'A2UI over MCP servers' and 'Running MCP Apps in A2UI Components'. The former leverages MCP Resources or Tool calls to deliver A2UI payloads, enabling native rendering and bypassing iframe limitations for improved performance, security, and portability. The latter encapsulates MCP Apps within A2UI components to delegate complex, state-intensive modules while maintaining host design consistency and secure state synchronization. It also discusses the differences between A2UI over MCP and A2UI over A2A architectures.

Jun 2026Announcing the Agentic Resource Discovery specification- Google Developers BlogThis post introduces the Agentic Resource Discovery (ARD) specification, an open standard for agents to find and verify capabilities (tools, skills, other agents) across the web. It details the architecture using catalogs (published under an organization's domain for trust) and registries (search engines for the agentic web). The post explains the four key phases of ARD: publishing catalogs, discovery/resolution, cryptographic verification, and direct runtime connection. It also announces Gemini Enterprise Agent Platform's Agent Registry as an enterprise-grade implementation supporting ARD, including governance features like URNs, egress policies, and Agent Identity for trust manifests.

May 2026How the community trained Gemma to "Think" with Tunix and TPUs- Google Developers BlogThis post details techniques for training large language models (LLMs) to exhibit structured reasoning capabilities, moving beyond simple pattern matching to logical deduction. It highlights the Google Tunix Hackathon where participants transformed base models into reasoning models using Tunix and Kaggle TPUs. Key innovations include: 1. G-RaR: Combines Supervised Fine-Tuning (SFT) with GRPO, using a rubric-based LLM-as-judge reward system to evaluate intermediate logical steps. It uses a two-stage pipeline (SFT then GRPO) and a split-mesh architecture on TPUs. 2. Pinocchio-1B: Uses a three-stage pipeline (SFT → SimPO → GRPO) for efficient reasoning training. It extends Tunix by injecting a custom SimPO loss function and creating an asynchronous evaluation engine for GRPO. 3. IDEA-E Distillation: Uses curriculum-guided GRPO with a TF-IDF reward system instead of a slow LLM judge. It extends Tunix by integrating the TF-IDF reward function for rapid, non-blocking reward calculations. Honorable mentions include on-policy distillation for dynamic reasoning trace generation and custom dataset curation with structured reward modeling (Deep-CoRGI). Domain-specific reasoning training for medical, chemistry, legal, and robotics is also presented.

May 2026Supercharge your integration workflow with the Google Pay & Wallet Developer MCP server- Google Developers BlogIntroduces the Google Pay & Wallet Developer MCP server, which provides tools for AI agents to interact with Google Pay & Wallet APIs. This includes tools for searching documentation via RAG, accessing account and integration details, validating Wallet pass JWTs/JSON, monitoring performance metrics, and managing integrations (creating merchant accounts, registering integrations). The goal is to reduce context switching, improve accuracy with AI-generated code grounded in documentation and account data, and speed up troubleshooting for developers using AI assistants within their IDEs.

May 2026Announcing ADK for Kotlin and ADK for Android 0.1.0: Building AI Agents on Android and Beyond- Google Developers BlogThis post announces the 0.1.0 release of Agent Development Kit (ADK) for Kotlin and introduces ADK for Android. ADK for Kotlin enables agentic workflows with features like hybrid orchestration (cloud orchestrator with on-device sub-agents), on-device sequential agents, local retrieval using on-device models (e.g., Gemini Nano), and flexible tooling with `@Tool` and `@Param` annotations. ADK for Android provides specialized on-device optimizations for AI agents within Android apps, leveraging local LLMs for privacy and flexibility to bridge with cloud models. It includes ML Kit GenAI, Firebase AI Logic, and Google GenAI for Android models, along with session state management and telemetry.

May 2026A Smarter Google AI Edge Gallery: MCP integration, notifications, and session continuity- Google Developers BlogThis post introduces the integration of the Model Context Protocol (MCP) over Streamable HTTP into the Google AI Edge Gallery app, enabling on-device agentic workflows that can interact with external tools and data sources. It also adds local notification reminders for scheduled routines and persistent chat history with fast prefill capabilities from the LiteRT-LM backend for session continuity. Developers can now edit the custom system prompt directly within the app.

May 2026An important update: Transitioning Gemini CLI to Antigravity CLI- Google Developers BlogThe Gemini CLI is being transitioned to Antigravity CLI, a new terminal experience built in Go. Key features like Agent Skills, Hooks, Subagents, and Extensions (now plugins) are retained. Antigravity CLI offers faster execution, asynchronous workflows for orchestrating multiple agents, and a unified architecture with Antigravity 2.0. Gemini CLI and Gemini Code Assist IDE extensions will stop serving requests on June 18, 2026, for most users, with enterprise customers' access remaining unchanged.

May 2026Announcing Genkit Middleware: Intercept, extend, and harden your agentic apps- Google Developers BlogIntroduces Genkit, an open-source framework for building AI-powered and agentic applications. Details the middleware system for intercepting generation calls, including tool execution loops. Describes three layers of middleware hooks: Generate, Model, and Tool. Highlights pre-built middleware for Retry, Fallback, Tool Approval, Skills, and Filesystem access, with code examples. Explains how to build custom middleware with a Go example for a content filter. Demonstrates middleware composition and stacking. Mentions the Developer UI for inspecting and debugging middleware execution.

May 2026Build Long-running AI agents that pause, resume, and never lose context with ADK- Google Developers BlogThis post introduces the Agent Development Kit (ADK) and its application in building long-running, stateful AI agents. It details three key architectural shifts: durable memory schemas, event-driven dormancy gates, and multi-agent delegation. The post provides a concrete example of a new hire onboarding agent, demonstrating how to implement a state machine for workflow tracking, wire session state into system instructions, use tools to update checkpoints atomically, and achieve checkpoint-and-resume functionality with persistent sessions (SQLite/Cloud SQL). It also covers handling idle time with event-driven resumption via webhook endpoints and the use of the Agents CLI for scaffolding agent projects.

Apr 2026Building with Gemini Embedding 2: Agentic multimodal RAG and beyond- Google Developers BlogThis post introduces Gemini Embedding 2, a new multimodal embedding model available via the Gemini API and Gemini Enterprise Agent Platform. It supports interleaved inputs of text, images, video, audio, and documents in a single request, mapping them into a unified embedding space. The post details how to use task prefixes for agentic RAG, visual search, and search reranking, providing code examples and citing user impacts (Harvey, Supermemory, Nuuly). It also explains how to use embeddings for clustering, classification, and anomaly detection with symmetric task prefixes. The post highlights efficient storage through vector truncation (Matryoshka Representation Learning) and mentions the Batch API for cost-efficiency. It also lists vector database integrations (Agent Platform Vector Search, Pinecone, Weaviate, Qdrant, ChromaDB).

Apr 2026Agents CLI in Agent Platform: create to production in one CLI- Google Developers BlogIntroduces Agents CLI in Agent Platform, a specialized tool for AI coding agents that provides a unified interface for the Agent Development Lifecycle (ADLC) on Google Cloud. It enables injecting bundled skills, local simulation and evaluation (unit tests, data validation, comparison of runs), and automated deployment to production environments (Agent Runtime, Cloud Run, GKE). The CLI supports both 'Agent Mode' and 'Human Mode' for deterministic execution.

Apr 2026Production-Ready AI Agents: 5 Lessons from Refactoring a Monolith- Google Developers BlogThis post details the refactoring of a monolithic AI agent ('Titanium') into a production-ready system using Google's Agent Development Kit (ADK). Key technical contributions include: 1. Replacing a monolithic script with a 'SequentialAgent' pipeline composed of specialized sub-agents for improved reliability and separation of concerns. 2. Forcing structured outputs using Pydantic objects instead of prompt-based JSON formatting, leveraging ADK's dynamic structured output capabilities. 3. Implementing a dynamic RAG pipeline by replacing hardcoded case studies with an autonomous data intake system using Playwright for scraping and Google Cloud Vector Search for hybrid search. 4. Integrating OpenTelemetry for observability by using ADK's built-in support for distributed tracing and a tailored SSE streaming app for live telemetry. 5. Implementing cost optimization through ADK's native orchestration features like exponential backoffs and timeout boundaries, effectively installing circuit breakers.

Apr 2026A2UI v0.9: The New Standard for Portable, Framework-Agnostic Generative UI- Google Developers BlogThis post introduces A2UI v0.9, a framework-agnostic standard for generative UI. It details the 'Basic' component set, a shared web-core library with official React renderer and support for other renderers (Flutter, Lit, Angular), and the A2UI Agent SDK. The SDK features optimized generation pipelines, caching, client-defined functions, client-to-server data syncing, improved error handling, modular schema, and simplified transports. The integration process for Python agents is outlined with a 5-step example. Advanced SDK features like version negotiation, dynamic catalogs, and resilient streaming are also discussed. Ecosystem updates from AG2, A2A, Vercel, and Oracle are mentioned, along with examples of its application in Personal Health Companion and Life Goal Simulator.

Apr 2026Subagents have arrived in Gemini CLI- Google Developers BlogIntroduces the concept of 'subagents' within the Gemini CLI, which are specialized AI agents that can be delegated complex tasks. Subagents operate with isolated context windows, system instructions, and toolsets. This design aims to improve efficiency, reduce context rot, and enable parallel execution of tasks. The post details how to define custom subagents using Markdown files and provides examples of built-in subagents like 'frontend-specialist', 'generalist', 'cli_help', and 'codebase_investigator'. It also explains explicit delegation using the '@agent' syntax and discusses the implications of parallel subagent execution.

Apr 2026Build Better AI Agents: 5 Developer Tips from the Agent Bake-Off- Google Developers BlogThis post introduces 5 key developer tips for building production-grade AI agents, derived from the Google Cloud AI Agent Bake-Off. It advocates for a shift from simple prompt engineering to rigorous 'agentic engineering'. Key takeaways include: 1. Architecting for multi-agent workflows by decomposing complex problems into specialized sub-agents managed by a supervisor agent, citing parallel processing benefits and modular maintenance. 2. Building agent harnesses with a mindset of impermanence due to rapid model advancements, emphasizing modularity for easy deprecation. 3. Treating multimodality as a core requirement, not an add-on, to increase accuracy and create more organic user experiences. 4. Leveraging open-source protocols (MCP, A2A, UCP, etc.) for dynamic resource discovery and communication, reducing the need for custom API wrappers. 5. Using LLMs strictly for reasoning and intent extraction, and employing rigid JSON validation schemas (e.g., Pydantic) for deterministic execution of outputs by traditional code. It provides links to resources like the Agent Development Kit (ADK) and Agent Starter Pack.

Apr 2026Bring state-of-the-art agentic skills to the edge with Gemma 4- Google Developers BlogIntroduces Gemma 4, a family of state-of-the-art open models for on-device AI development, enabling agentic use cases like multi-step planning, autonomous action, and audio-visual processing without specialized fine-tuning. Details access via AICore Developer Preview on Android and Google AI Edge for mobile, desktop, and edge devices. Highlights Google AI Edge Gallery with 'Agent Skills' for augmenting knowledge bases, producing interactive content, integrating with other models, and creating end-to-end conversational experiences. Introduces LiteRT-LM for deploying Gemma 4 across devices with minimal memory footprint, constrained decoding, and dynamic context handling, showcasing performance metrics on Raspberry Pi 5 and Qualcomm Dragonwing IQ8. Mentions a new Python package and CLI tool for console experimentation and powering agentic Python pipelines.

Apr 2026Developer’s Guide to Building ADK Agents with Skills- Google Developers BlogThis post introduces the ADK SkillToolset, a new capability for AI agents that allows for dynamic loading of domain expertise through progressive disclosure. It details four patterns for implementing skills: inline, file-based, external, and a meta-skill ('skill factory') for self-extending agents. The post explains the L1 (metadata), L2 (instructions), and L3 (resources) knowledge loading architecture, highlighting a 90% reduction in baseline context usage. It provides pseudocode examples for each pattern and emphasizes the universal agentskills.io specification for interoperability across agent frameworks.

Mar 2026ADK Go 1.0 Arrives!- Google Developers BlogADK Go 1.0 introduces OpenTelemetry integration for structured tracing of model calls and tool executions, a Plugin System allowing for cross-cutting concerns like 'Retry and Reflect' for self-correction, Human-in-the-Loop (HITL) confirmation flows for sensitive tools (`RequireConfirmation: true`), and YAML configuration support for defining agents and their hierarchies. The Agent2Agent (A2A) protocol is refined for inter-agent communication.

Mar 2026Announcing ADK for Java 1.0.0: Building the Future of AI Agents in Java- Google Developers BlogThis post announces the release of ADK for Java 1.0.0, detailing new features for building AI agents. Key contributions include the introduction of GoogleMapsTool and UrlContextTool for grounding agent responses with external data, ContainerCodeExecutor and VertexAiCodeExecutor for code execution, a centralized App container and Plugin system for global execution control (e.g., LoggingPlugin, GlobalInstructionPlugin), event compaction for managing context window sizes, Human-in-the-Loop (HITL) workflows via ToolConfirmation, and session/memory service contracts. It also highlights Agent2Agent (A2A) support for inter-agent communication.

Mar 2026Closing the knowledge gap with agent skills- Google Developers BlogIntroduced a 'Gemini API developer skill' to help coding agents use the Gemini API. This skill provides information on API features, models, SDKs, sample code, and documentation entry points. Evaluated the skill's performance using a test harness with 117 prompts, showing significant performance improvements for Gemini 3 series models compared to vanilla prompting.

Mar 2026Build a smart financial assistant with LlamaParse and Gemini 3.1- Google Developers BlogThis post introduces a novel workflow for processing unstructured documents, specifically brokerage statements, by combining LlamaParse's agentic parsing capabilities with Gemini's multimodal reasoning. It details a four-stage process: Ingest, Route, Extract (text and tables in parallel), and Synthesize. A key technical contribution is the use of a two-model architecture, employing Gemini 3.1 Pro for layout comprehension during parsing and Gemini 3 Flash for cost-efficient summarization. The post also demonstrates the use of LlamaIndex Workflows for orchestrating parallel extraction tasks and managing state, highlighting event-driven architecture for scalability and resilience.

Mar 2026Developer’s Guide to AI Agent Protocols- Google Developers BlogThis post introduces four new protocols for AI agent development: Model Context Protocol (MCP) for standardized server connections and tool discovery, Agent2Agent (A2A) for inter-agent communication and discovery via Agent Cards, Universal Commerce Protocol (UCP) for standardizing shopping lifecycles with typed schemas, and Agent Payments Protocol (AP2) for transaction authorization and auditing. It demonstrates their practical application using the Agent Development Kit (ADK) to build a multi-step supply chain agent for a restaurant, showcasing how these protocols reduce custom integration code and enable agents to interact with real systems, other agents, and financial transactions.

Mar 2026Announcing the Colab MCP Server: Connect Any AI Agent to Google Colab- Google Developers BlogIntroduced the open-source Colab MCP (Model Context Protocol) Server, enabling programmatic access to Google Colab by any AI agent. This allows agents to control the Colab notebook interface to automate the development lifecycle, including cell manipulation, code execution, dependency management, and content organization. Provided installation instructions for Python, git, and uv, along with an example MCP JSON configuration.

Mar 2026Plan mode is now available in Gemini CLI- Google Developers BlogIntroduces 'plan mode' for Gemini CLI, a read-only mode that allows the agent to analyze requests, map codebases, and ask clarifying questions before making any changes. This mode utilizes tools like `read_file`, `grep_search`, `glob`, `codebase_investigator`, and the new `ask_user` tool. It also supports read-only MCP tools for accessing external data and is extensible with custom policies. The Conductor extension leverages plan mode for context-driven development. Plan mode is enabled by default and uses Gemini 3.1 Pro for planning.

Mar 2026Introducing Finish Changes and Outlines, now available in Gemini Code Assist extensions on IntelliJ and VS Code- Google Developers BlogIntroduces 'Finish Changes' and 'Outlines' features to Gemini Code Assist extensions for IntelliJ and VS Code. 'Finish Changes' allows AI to complete code modifications based on context (partial code, pseudocode, comments, open files) without explicit prompts, supporting pseudocode implementation, pattern application, instruction following, and code completion/refactoring. 'Outlines' generates inline code summaries within the IDE for improved code comprehension and navigation, with an interactive side panel for easy code block access. Both features are powered by Gemini 3.0.

Mar 2026Unleash Your Development Superpowers: Refining the Core Coding Experience- Google Developers BlogThis post introduces several new features for Gemini Code Assist that enhance AI-assisted coding workflows. Key additions include Agent Mode with Auto Approve for automated multi-file changes, Inline Diff Views for direct editing of AI suggestions, Revert to Checkpoint for easy rollback of experimental changes, and multi-part chat code suggestions for granular application of AI-generated code. It also details improvements to code completion speed, context management via a Context Drawer and AI exclusion files, and enhanced transparency with 'thinking tokens' and release channel display.

Mar 2026How we built the Google I/O 2026 Save the Date experience- Google Developers BlogThis post details the use of Gemini models and Google Antigravity to build the Google I/O Save the Date experience. Specific contributions include using Gemini for dynamic level generation in Nonogram, Stretchy Cat, and Word Wheel; implementing AI caddy tips in Hole in One; enabling microphone controls in Supersonic Bot; and assigning adaptive personality traits to Dino Pal. It also highlights the use of Google AI Studio for a game designer mode and planning reward systems, and the availability of games in Google AI Studio for user experimentation.

Feb 2026Supercharge your AI agents: The New ADK Integrations Ecosystem- Google Developers BlogThis post announces a significant expansion to the Agent Development Kit (ADK) ecosystem by introducing a broad suite of third-party tool and integration partnerships. It details integrations across categories such as Code & development (Daytona, GitHub, GitLab, Postman, Restate), Project management (Asana, Atlassian, Linear, Notion), Databases (Chroma, MongoDB, Pinecone), Memory (GoodMem, Qdrant), Observability (AgentOps, Arize AX, Freeplay, MLflow, Monocle, Phoenix, W&B Weave), Connectors (n8n, StackOne), AI models & datasets (Hugging Face), Payments (PayPal, Stripe), Speech & audio (Cartesia, ElevenLabs), Email and messaging (AgentMail, Mailgun), and built-in Google Cloud services. It highlights the unified developer experience provided by the Mcp Toolset and plugin architecture, demonstrating a Python code example for integrating the GitHub toolset. The post emphasizes enabling agents to perform actions beyond chat, such as managing code repositories, triggering workflows, and querying databases.

Feb 2026On-Device Function Calling in Google AI Edge Gallery- Google Developers BlogIntroduced iOS support for Google AI Edge Gallery, enabling on-device AI use cases powered by Gemma and other open-weight models. Integrated 'Mobile Actions' and 'Tiny Garden' demos showcasing FunctionGemma (270M parameters) for on-device function calling, translating natural language into OS tool or app intents. Integrated benchmarking into the app to measure LiteRT's CPU and GPU performance on user devices, with specific performance metrics provided for Mobile Actions on a Pixel 7 Pro (1916 tokens/sec prefill, 142 tokens/sec decode). Provided fine-tuning recipes and function calling guides for developers to adapt FunctionGemma for custom use cases.

Feb 2026Conductor Update: Introducing Automated Reviews- Google Developers BlogIntroduces Automated Review for Conductor, an AI-assisted engineering tool. This feature adds a 'verify' step to the development lifecycle, performing code review (static/logic analysis for race conditions, null pointers, logic errors), plan compliance checks against plan.md/spec.md, guideline enforcement, test-suite validation (unit/integration tests, coverage data), and basic security reviews (hardcoded API keys, PII leaks, unsafe input handling). Findings are categorized by severity and provide actionable intelligence for developers.

Feb 2026Making Gemini CLI extensions easier to use- Google Developers BlogThis post introduces 'extension settings' for Gemini CLI extensions, a new capability that allows extensions to define required configuration parameters (e.g., API keys, base URLs, project identifiers). These settings are prompted to the user upon installation, ensuring extensions have the necessary information to function correctly from the start. Key features include automated setup, secure storage of sensitive settings in the system keychain, command-line management via `gemini extensions config`, and support for global user and project-specific workspace scopes. The AlloyDB extension is presented as a concrete example of how these settings simplify database connection by replacing manual environment variable exports with a guided setup process. The post also details how extension authors can define settings in `gemini-extension.json` and how users can manage them using the `gemini extensions config` command, including updating all settings or specific ones, and using workspace overrides. Debugging tips and best practices for extension settings are also provided.

Feb 2026Data Commons Hosted MCP: Zero-Install Public Data for AI- Google Developers BlogIntroduced a hosted Data Commons MCP service on Google Cloud Platform, removing the need for local Python environments and offering scalability for AI agents interacting with Data Commons data. This simplifies setup for Gemini CLI users by automatically updating to connect to the web service. For other agents, it requires a Data Commons API key and configuration update to point to the hosted server.

Feb 2026Introducing the Developer Knowledge API and MCP Server- Google Developers BlogIntroduces the Developer Knowledge API and Model Context Protocol (MCP) server. The Developer Knowledge API provides a machine-readable source of truth for Google's public developer documentation, allowing retrieval of Markdown content. The MCP server enables AI assistants to access this documentation for improved context and functionality. Key features include comprehensive coverage of Google developer documentation, search and retrieve capabilities, and near real-time freshness of indexed content. The MCP server is compatible with various AI assistants and tools.

Jan 2026Beyond the Chatbot: A Blueprint for Trustable AI- Google Developers BlogThis post details the implementation of a 'Split-Brain' architecture for real-time AI guidance in a racing scenario. It showcases the use of Antigravity (AGY) for orchestrating stateful agentic systems, compressing a three-month development cycle into two weeks. Gemini Nano is used at the edge for ~15ms response times via Web API, while Gemini 3.0 handles higher-level reasoning. The 'Perception Team' utilized Maps MCP for track layout rendering and 60FPS telemetry. Neuro-Symbolic Training with QLoRA was employed for mathematically verifying AI advice against physics. Persona-based routing with a 'Gemini Squad' of agents (e.g., Crew Chief, Telemetry Engineer) was implemented to manage cognitive load and deliver context-aware guidance.

Jan 2026Tailor Gemini CLI to your workflow with hooks- Google Developers BlogIntroduces Gemini CLI hooks, a mechanism for executing custom scripts at specific points in the Gemini CLI's lifecycle (e.g., BeforeTool, AfterAgent). This allows for customization of agent behavior, such as adding context, validating actions, enforcing policies, logging, and sending notifications. A concrete example demonstrates a `BeforeTool` hook for automated secret scanning using a shell script and JSON input/output. Hooks can be bundled within Gemini CLI extensions and are enabled by default in v0.26.0+.

Jan 2026A Guide to Fine-Tuning FunctionGemma- Google Developers BlogThis post introduces FunctionGemma, a Gemma 3 270M model fine-tuned for function calling, and demonstrates how to fine-tune it to resolve tool selection ambiguity. It details a case study using the `bebechien/SimpleToolCalling` dataset to differentiate between `search_knowledge_base` and `search_google` tools. A critical note on data distribution emphasizes the need for pre-mixed training data to avoid catastrophic performance. The post also introduces the FunctionGemma Tuning Lab, a no-code demo tool for fine-tuning.

Dec 2025Real-World Agent Examples with Gemini 3- Google Developers BlogThis post introduces real-world examples of agentic AI workflows powered by Gemini 3, showcasing its role as a core orchestrator for production-ready agentic systems. It highlights collaborations with six open-source frameworks (ADK, Agno, Browser Use, Eigent, Letta, mem0) to demonstrate practical applications. Specific examples include: ADK's Retail Location Strategy agent using Google Search and Maps with code execution; Agno's Creative Studio with image generation and research agents using Google Search and URL context; Browser Use's form-filling agent leveraging multimodal capabilities for visual field identification and autonomous handling of complex inputs; Eigent's enterprise browser automation for Salesforce deal cycles using CAMEL architecture and Gemini 3's thought signatures for state management; Letta's social agent demonstrating stateful interactions and persistent memory with a multi-tiered memory system; and mem0's memory layer framework for building memory-aware agents with Gemini 3. The post emphasizes the ecosystem of tools enabling AI models to interact with the world and provides links to clone and run these examples.

Dec 2025Conductor: Introducing context-driven development for Gemini CLI- Google Developers BlogIntroduces Conductor, a Gemini CLI extension that formalizes project context (product, tech stack, workflow) into persistent Markdown files. This enables context-driven development for AI agents, shifting context from chat logs to the codebase. It supports planning before coding, team-wide adherence to standards, and better handling of brownfield projects by creating and managing specs and plans in Markdown. The workflow involves establishing context, specifying tracks with specs and plans, and then implementing via the agent following the plan.

Dec 2025Gemini 3 Flash is now available in Gemini CLI- Google Developers BlogGemini 3 Flash is now available in Gemini CLI, offering improved agentic coding capabilities. It achieves a SWE-bench Verified score of 78% for agentic coding and is available at a lower cost and higher speed than Gemini 3 Pro. The post details how to access and use Gemini 3 Flash with Gemini CLI, including examples of generating 3D graphics apps, processing large context windows for code changes, and simulating user traffic for stress testing.

Dec 2025Introducing Agent Development Kit for TypeScript: Build AI Agents with the Power of a Code-First Approach- Google Developers BlogIntroduces the Agent Development Kit (ADK) for TypeScript, an open-source framework for building AI agents and multi-agent systems with a code-first philosophy. Highlights benefits like end-to-end type safety, leveraging the TypeScript ecosystem, simplified modularity, and deployment flexibility. Mentions model agnosticism and compatibility with third-party tools, including MCP Toolbox for Databases.

Dec 2025Developer’s guide to multi-agent patterns in ADK- Google Developers BlogThis post introduces and details eight multi-agent design patterns (Sequential Pipeline, Coordinator/Dispatcher, Parallel Fan-Out/Gather, Hierarchical Decomposition, Generator/Critic, Iterative Refinement, Human-in-the-loop) within the Google Agent Development Kit (ADK). It provides pseudocode examples for implementing these patterns using ADK primitives like SequentialAgent, CoordinatorAgent, ParallelAgent, LoopAgent, and AgentTool. The patterns address challenges in building scalable, reliable, and debuggable AI agent systems by promoting modularity and specialization.

Dec 2025Introducing A2UI: An open project for agent-driven interfaces- Google Developers BlogIntroduces A2UI, an open-source project and protocol for agents to generate and transmit UI specifications. A2UI defines a format optimized for updateable, agent-generated UIs and provides initial renderers for frameworks like Lit, Angular, and Flutter. It addresses the challenge of rendering UI across trust boundaries in multi-agent systems by separating UI structure from implementation, allowing clients to retain control over styling and security. A2UI is designed to be LLM-friendly, incrementally updateable, and framework-agnostic, enabling secure, data-like UI transmission rather than executable code.

Dec 2025Building agents with the ADK and the new Interactions API- Google Developers BlogThis post introduces the Gemini Interactions API as a new unified interface for stateful, multi-turn agentic workflows. It details two primary integration patterns: 1) using the Interactions API as the inference engine for ADK agents, offering simplified state management, background execution, and native thought handling, and 2) using the Interactions API as a transparent bridge for existing A2A clients to interact with Google-hosted agents like the Gemini Deep Research Agent via the `InteractionsApiTransport`. The post provides code examples for both patterns, demonstrating how to upgrade ADK agents and configure A2A clients to leverage the new API.

Dec 2025Pick up exactly where you left off with Session Management in Gemini CLI- Google Developers BlogIntroduces session management for Gemini CLI, enabling automatic saving of conversation history, tool outputs, and token usage. Sessions are project-specific and can be resumed via an interactive browser or command-line flags. Adds history management tools and usage tracking.

Dec 2025Architecting efficient context-aware multi-agent framework for production- Google Developers BlogThis post introduces a new architectural paradigm for managing agent context, treating it as a compiled view over a stateful system. ADK's tiered model separates storage (Sessions, Memory, Artifacts) from presentation (Working Context), utilizing Flows and processors as a compilation pipeline. Context compaction and filtering are applied at the Session layer to manage long-running conversations, and context caching is optimized by treating context as a stable prefix.

Dec 2025Announcing the Data Commons Gemini CLI extension- Google Developers BlogIntroduces a new Gemini CLI extension for Data Commons, enabling natural language querying of public datasets. This extension leverages Data Commons MCP tools for data exploration, analysis, and comparison with other Gemini CLI tools. It also facilitates integrated workflows with other data extensions like MCP Toolbox for Databases and Looker, and provides the standalone MCP server for custom agent development.

Nov 2025New Gemini API updates for Gemini 3- Google Developers BlogIntroduces Gemini 3 API updates including thinking_level for reasoning control, media_resolution for multimodal processing, and mandatory thought signatures for function calling and image generation to maintain reasoning chains. Enhances grounding with Google Search and URL context for agentic workflows, updates pricing for grounding, and provides best practices for using Gemini 3 Pro via APIs, particularly for agentic coding.

Nov 2025Build with Google Antigravity, our new agentic development platform- Google Developers BlogIntroduces Google Antigravity, a new agentic development platform that provides an AI-powered coding experience integrated with an agent-first interface. It allows for autonomous planning, execution, and verification of complex tasks across editor, terminal, and browser. Key features include an Editor View for synchronous work and a Manager Surface for asynchronous orchestration of multiple agents. It supports delegating multi-tool software tasks, requesting UI changes with artifact-based verification (screenshots, walkthroughs), and background maintenance/bug fixing tasks. Agents generate Artifacts for verification and can incorporate feedback. The platform includes a knowledge base for learning and supports multiple AI models (Gemini 3 Pro, Claude Sonnet 4.5, GPT-OSS).

Nov 2025Building AI Agents with Google Gemini 3 and Open Source Frameworks- Google Developers BlogThis post introduces Gemini 3 Pro Preview, highlighting new agentic features such as `thinking_level` for adjustable reasoning depth, stateful tool use via "Thought Signatures" for context retention, and `media_resolution` for adjustable multimodal fidelity. It details how these features integrate with open-source frameworks (LangChain, AI SDK by Vercel, LlamaIndex, Pydantic AI, n8n) to build sophisticated AI agents. Key best practices include simplifying prompts, keeping temperature at 1.0, handling thought signatures, and optimizing visual tokens.

Nov 2025Building with Gemini 3 in Jules- Google Developers BlogThis post details the integration of Gemini 3 Pro into Jules, an autonomous coding agent. Gemini 3 Pro's improved agentic capabilities are highlighted, leading to clearer reasoning, stronger intent alignment, and increased reliability for multi-step tasks. The post also describes recent improvements to Jules, including parallel CLI runs, Windows compatibility, a diff viewer, a stable API for custom workflows, improved memory persistence, more reliable critic agent replanning, safer Git handling, and improved VM performance. Future work includes directory attachment without GitHub, automatic title updates, CLI shortcuts in the web UI, simplified start modes, and automatic PR creation.

Nov 20255 things to try with Gemini 3 Pro in Gemini CLI- Google Developers BlogThis post details the integration of Gemini 3 Pro into the Gemini CLI, enhancing its agentic coding capabilities. It provides specific examples of how Gemini 3 Pro can be used to: 1. Generate a ready-to-deploy app with 3D graphics using Three.js from a detailed prompt. 2. Translate a visual sketch of a UI into functional HTML, CSS, and JavaScript code. 3. Generate complex shell commands, such as using `git bisect` for bug finding, from natural language prompts. 4. Generate user documentation and architectural overviews from codebases. 5. Debug performance issues in a live Cloud Run service by orchestrating workflows across observability, security scanners (like Snyk), and source control.

Nov 2025Introducing Code Wiki: Accelerating your code understanding- Google Developers BlogIntroduces Code Wiki, a platform that generates and maintains a continuously updated, structured wiki for code repositories. It integrates an AI chat agent that uses the wiki as context for repository-specific questions and automatically generates architecture, class, and sequence diagrams. A Gemini CLI extension is planned for local execution on internal repositories.

Nov 2025Making the terminal beautiful one pixel at a time- Google Developers BlogIntroduces significant UI improvements to the Gemini CLI, including mouse-based navigation, sticky headers, flicker-free rendering, robust terminal resizing behavior, and a stable input prompt. These enhancements are built on a new TUI rendering foundation and are enabled by default in v0.15.0.

Nov 2025Agent Garden - Samples for learning, discovering and building- Google Developers BlogAgent Garden is now available to all users, expanding access beyond Google Cloud. It offers a repository of curated agent samples and solutions built with the Agent Development Kit (ADK), integrating with services like BigQuery and Vertex AI Search. The Agent Starter Pack enables one-click deployment to Agent Engine, and Firebase Studio allows for customization. The post highlights the use of these agents by early testers, such as Renault Group integrating a data scientist agent into their EV charger platform.

Nov 2025Announcing the Agent Development Kit for Go: Build Powerful AI Agents with Your Favorite Languages- Google Developers BlogThis post announces the addition of Go support to the Agent Development Kit (ADK), an open-source, code-first toolkit for building AI agents. It highlights ADK's features like robust debugging, reliable versioning, and deployment freedom. ADK for Go offers idiomatic and performant agent development leveraging Go's concurrency and strong typing, with integrated support for over 30+ databases via MCP Toolbox. Key features like a rich tool ecosystem, code-first development, modular multi-agent systems, and a development UI are consistent across ADK languages. The post also introduces Agent2Agent (A2A) protocol support for ADK Go, enabling agent collaboration and task delegation, and contributes the A2A Go SDK to the A2A Project repo.

Nov 2025Announcing User Simulation in ADK Evaluation- Google Developers BlogIntroduces User Simulation, an LLM-powered prompt generator within the Agent Development Kit (ADK) evaluation framework. This feature dynamically generates multi-turn conversations based on high-level goals defined in `ConversationScenario` objects (containing `starting_prompt` and `conversation_plan`), moving away from brittle turn-by-turn scripts. It allows for configuration of the backing LLM model, model parameters, and turn budget via `EvalConfig`. The primary benefit is reducing test creation time, building more resilient tests focused on intent achievement, and creating a reliable regression suite for AI agents.

Oct 2025Beyond Request-Response: Architecting Real-time Bidirectional Streaming Multi-agent System- Google Developers BlogThis post introduces a real-time bidirectional streaming architecture for multi-agent systems, moving beyond the limitations of request-response models. It details engineering challenges such as context management in a turnless world, concurrency and performance for streaming I/O, and developer experience. The Agent Development Kit (ADK) is presented as a solution, featuring a LiveRequestQueue for asynchronous I/O management, stateful and transferable sessions for multi-agent collaboration, event-driven callbacks (before_tool_callback, after_tool_callback) for customization, and streaming tools defined as AsyncGenerators.

Oct 2025Introducing the Jules extension for Gemini CLI- Google Developers BlogIntroduces the Jules extension for Gemini CLI, an AI-powered autonomous sidekick that works in the background within a VM to clone code, install dependencies, and modify files. It enables asynchronous task execution, background bug fixing, and submitting changes to new branches, complementing the Gemini CLI's interactive workflow.

Oct 2025Announcing Genkit Go 1.0 and Enhanced AI-Assisted Development- Google Developers BlogGenkit Go 1.0 is released as a stable, production-ready AI development framework for Go. It introduces type-safe AI flows using Go structs and JSON schema validation, a unified interface for multiple model providers (Google AI, Vertex AI, OpenAI, Anthropic, Ollama), tool calling capabilities, and simplified deployment as HTTP endpoints. The `genkit init:ai-tools` command is introduced to enhance AI-assisted development by configuring AI coding assistants (Gemini CLI, Firebase Studio, Claude Code, Cursor) to work with Genkit tooling, including flow execution and trace analysis. The release also includes a standalone CLI with a Developer UI for testing and debugging AI applications.

Oct 2025Say hello to a new level of interactivity in Gemini CLI- Google Developers BlogIntroduces pseudo-terminal (PTY) support to Gemini CLI, enabling interactive shell commands (e.g., vim, top, git rebase -i) to be run directly within the CLI's context. This is achieved by spawning a background process using `node-pty`, serializing the terminal state (text, color, cursor position) into a live feed, and enabling two-way communication for input and resizing. This enhances the developer experience by keeping all operations within the Gemini CLI environment.

Oct 2025Announcing the Genkit Extension for Gemini CLI- Google Developers BlogIntroduces the Genkit Extension for Gemini CLI, enabling AI-assisted development of Genkit applications directly from the terminal. This extension provides Genkit-specific tools (get_usage_guide, lookup_genkit_docs, list_flows, run_flow, get_trace) and context-aware assistance for code generation, debugging, and adherence to Genkit best practices. It integrates with the Genkit MCP server and respects existing Genkit project structures and providers.

Oct 2025Level Up Your Dev Game: The Jules API is Here!- Google Developers BlogIntroduces the Jules API, providing programmatic access to AI-assisted coding agents. Key concepts defined are Source (e.g., GitHub repository), Session (continuous block of work with an asynchronous coding agent), and Activity (individual steps within a session). Demonstrates use cases like fixing bugs from Slack and automating backlog triage with code examples for API key retrieval, source listing, and session initiation.

Oct 2025Meet Jules Tools: A Command Line Companion for Google’s Async Coding Agent- Google Developers BlogThis post introduces Jules Tools, a new command-line interface (CLI) for interacting with the asynchronous coding agent Jules. The CLI provides direct control and visibility into Jules' operations, allowing users to spin up tasks, inspect agent activity, and integrate Jules into their existing terminal workflows. Key features include commands for listing remote tasks, creating new sessions, assigning tasks from files, and piping output from other CLI tools (like `gh` and `gemini`) to Jules. It also offers a Text-based User Interface (TUI) for interactive flows. The CLI is installed via npm and uses commands and flags for operation. This extends the agentic application middleware by providing a more integrated and scriptable developer experience.

Sep 2025Apigee Operator for Kubernetes and GKE Inference Gateway integration for Auth and AI/LLM policies- Google Developers BlogThis post details the integration of the Apigee Operator for Kubernetes with the GKE Inference Gateway. It explains how the GCPTrafficExtension resource allows the GKE Gateway to call a policy decision point (PDP) via a service extension. This enables Apigee to enforce policies (API keys, quotas, rate limiting, OpenAPI spec validation, etc.) on API traffic flowing through the GKE Inference Gateway, thereby providing API management and governance for AI/LLM workloads. It also outlines future plans for Apigee AI policies, including Model Armor security and prompt-based model routing.

Sep 2025Delight users by combining ADK Agents with Fancy Frontends using AG-UI- Google Developers BlogIntroduces AG-UI, an open protocol and UI layer for standardizing agent-to-user communication with rich UIs. Details how AG-UI, in conjunction with CopilotKit, provides a standardized communication channel between backend agents (like those built with ADK) and frontend applications. Highlights the benefits of this integration, including generative UI, shared state, human-in-the-loop capabilities, and frontend tool interaction. Provides a quick start guide with a command to clone a starter repository and code examples for defining an ADK agent and connecting it to a React/Next.js frontend using CopilotKit.

Sep 2025Building the Next Generation of Physical Agents with Gemini Robotics-ER 1.5- Google Developers BlogThis post introduces Gemini Robotics-ER 1.5, a new embodied reasoning model for robots. It details its capabilities in spatial understanding (2D point generation, temporal reasoning), task planning, and tool orchestration. The model is purpose-tuned for robotics and offers a flexible thinking budget for latency vs. accuracy trade-offs, along with improved safety filters. It can break down complex commands into actionable plans and call external tools or models for execution.

Sep 2025Introducing the Data Commons Model Context Protocol (MCP) Server: Streamlining Public Data Access for AI Developers- Google Developers BlogIntroduces the Data Commons Model Context Protocol (MCP) Server, a new component that standardizes access to Data Commons' public datasets for AI agents. This enables agents to consume data natively, reducing the need for complex API interactions and accelerating the development of data-rich, agentic applications. The MCP Server aims to reduce LLM hallucinations by providing trustable, sourced data. It integrates with existing agent development workflows like Gemini CLI and the Agent Development Kit (ADK). A real-world use case with the ONE Campaign and the 'ONE Data Agent' is presented, demonstrating its application in health financing data analysis.

Sep 2025Gemini CLI 🤝 FastMCP: Simplifying MCP server development- Google Developers BlogThis post details the integration of FastMCP, a Python library for building MCP servers, with Gemini CLI. It introduces the `fastmcp install gemini-cli server.py` command, which simplifies the installation and configuration of local STDIO transport MCP servers built with FastMCP. This allows Gemini CLI agents to leverage custom tools and prompts defined in FastMCP, enhancing their capabilities by enabling them to perform actions and access external context. The post provides a step-by-step guide for users to set up this integration.

Sep 2025ADK for Java opening up to third-party language models via LangChain4j integration- Google Developers BlogThis post introduces the integration of LangChain4j into the Agent Development Kit (ADK) for Java, enabling ADK agents to leverage a wide array of third-party and local LLMs. It details how to configure agents to use models from providers like OpenAI, Anthropic, Mistral, and local models via Ollama and Docker Model Runner. Specific examples demonstrate running Gemma 3 with Docker Model Runner and Qwen 3 with Ollama. The release also includes instance-based FunctionTools, improved async support for FunctionTools, chained callbacks for agent lifecycle events, an InMemoryMemoryService, and VertexAiRagRetrieval.

Sep 2025A2A Extensions: Empowering Custom Agent Functionality- Google Developers BlogThis post introduces A2A Extensions, a mechanism to add custom, domain-specific functionalities to the A2A protocol. It details the 'helloworld' extension for timestamps, the Traceability Extension with `ResponseTrace` and `Steps` (ToolInvocation, AgentInvocation) for logging agent requests hierarchically, Twilio's Latency Extension for model selection, and Identity Machines' zero-trust handshake implementation. It also mentions Ethereum's ERC-8004 proposal for a trust layer for AI agents.

Aug 2025Beyond the terminal: Gemini CLI comes to Zed- Google Developers BlogThis post announces the integration of Gemini CLI with the Zed code editor. Gemini CLI is described as an extensible orchestrator for AI agents, supporting standards like MCP, markdown-based instructions, custom extensions, tools, configurations, and OpenTelemetry. The integration with Zed allows for in-place code generation/refactoring via comments, instant code explanations for highlighted code or errors, and terminal chat functionality. Key collaboration features include real-time agent progress following, a review interface for proposed changes similar to pull requests, seamless handoffs, and the ability to provide context beyond the local filesystem (e.g., URLs).

Aug 2025What's new in Gemini Code Assist- Google Developers BlogGemini Code Assist's Agent Mode is now widely available in VS Code and IntelliJ, offering enhanced capabilities for tackling complex, multi-step tasks. This includes support for multiple file edits, full project context, built-in tools, and integration with ecosystem tools (using MCP) with integrated Human in the Loop (HITL). VS Code enhancements include inline diffs for code changes, persistent chat history, streamlined quota updates, real-time shell command output, batched tool call approvals, faster UI performance, and preserved toggle state. IntelliJ also offers Agent Mode with a review and approval process, or an auto-approve mode. IDE improvements include the ability to stop in-progress chat responses and 'thinking tokens' for IntelliJ to provide insights into Gemini's thought process. Code completion performance for VS Code has also been boosted. Many preview features are now generally available, including reverting to checkpoints, adding selected code snippets to context, prompting with selected terminal output, specifying filenames, and excluding files. The Gemini CLI has seen significant community contributions and rapid evolution, with the launch of Gemini CLI GitHub Actions for automated coding tasks and on-demand collaboration. Deeper integration into VS Code provides context-aware suggestions and native in-editor diffing. Custom Slash Commands allow for reusable prompts, and a public roadmap for Gemini CLI v1 has been published.

Aug 2025Gemini CLI + VS Code: Native diffing and context-aware workflows- Google Developers BlogThis post introduces native diffing and context-aware workflows for Gemini CLI within VS Code. When integrated, Gemini CLI gains access to the VS Code workspace and selected text, enabling it to provide contextually relevant suggestions. These suggestions trigger a full-screen diff view directly within VS Code, allowing users to review and modify changes side-by-side before accepting them. The setup involves installing a companion extension via the `/ide install` command in the integrated terminal.

Aug 2025Meet Jules’ sharpest critic and most valuable ally- Google Developers BlogThis post introduces critic-augmented generation for AI coding agents, specifically within the Jules system. The critic functionality acts as a peer reviewer, challenging proposed code changes before they are finalized. It evaluates code for logic errors, missed edge cases, and inefficient approaches, drawing inspiration from LLM-as-a-judge research and actor-critic reinforcement learning principles. The critic performs a single-pass evaluation of the candidate patch and its description, and Jules responds to the feedback, potentially undergoing multiple review cycles until no further issues remain. The goal is to deliver code that has already been internally reviewed, refined, and stress-tested.

Jul 2025Gemini Embedding: Powering RAG and context engineering- Google Developers BlogThis post showcases the practical application and performance benefits of the Gemini Embedding model in various real-world AI systems, particularly for RAG and context engineering. It highlights specific metrics from organizations like Box, re:cap, Everlaw, Roo Code, Mindlid, and Interaction Co. demonstrating improved accuracy, recall, F1 scores, and reduced latency compared to previous models and competitors. The Matryoshka property of Gemini Embedding is also mentioned for its efficiency in storage and retrieval.

Jul 2025Introducing LangExtract: A Gemini powered information extraction library- Google Developers BlogIntroduces LangExtract, an open-source Python library for programmatic information extraction from unstructured text using LLMs. Key features include precise source grounding (mapping to character offsets), reliable structured outputs via controlled generation and few-shot examples, optimized long-context extraction using chunking and parallel processing, interactive HTML visualizations, flexible LLM backend support (Gemini, on-device models), domain adaptability without fine-tuning, and leveraging LLM world knowledge. Demonstrates usage with Shakespearean text and medical examples, and highlights a radiology reporting demo (RadExtract).

Jul 2025Introducing Opal: describe, create, and share your AI mini-apps- Google Developers BlogOpal is introduced as an experimental tool from Google Labs that allows users to build and share AI mini-apps by chaining together prompts, AI models, and tools. It features a visual editor and natural language interface for creating and remixing these applications, simplifying AI prototyping and workflow development without requiring traditional coding. It is launching in a US-only public beta.

Jul 2025The agentic experience: Is MCP the right tool for your AI future?- Google Developers BlogThis post introduces an open-source example of an MCP server solution built on Apigee. It demonstrates how to make existing enterprise APIs accessible as tools for AI agents by leveraging Apigee's API management capabilities. Key contributions include: 1. An open-source MCP server example that provides API security, including authentication, authorization, and observability for AI workloads. 2. The use of Apigee's API Products for controlling access to MCP tools and downstream APIs. 3. Hosting the MCP server and its backend APIs on Apigee to benefit from its security, distribution, and observability features. 4. Bridging the gap between managed APIs and AI interactions by securing, scaling, and governing AI journeys.

Jul 2025Unleashing new AI capabilities for popular frameworks in Firebase Studio- Google Developers BlogThis post introduces AI-optimized templates for popular frameworks (Flutter, Angular, React, Next.js, Web) within Firebase Studio, enabling autonomous agentic development with Gemini. It details the use of `airules.md` files to guide Gemini's code generation and documentation. The post also describes streamlined integration of Firebase backend services via natural language prompts, where Gemini recommends services, imports libraries, and updates code. A new 'forking workspaces' feature is introduced for experimentation and collaboration, preserving agent chat history. Project upload size has been increased to 100MB, and a 'enhance prompts' feature allows for collaborative prompt refinement.

Jul 2025Simplify your Agent "vibe building" flow with ADK and Gemini CLI- Google Developers BlogThis post introduces a new workflow for building AI agents using the Agent Development Kit (ADK) and Gemini CLI. The core technical contribution is the optimization of the `llms-full.txt` file within the ADK, reducing its size by over 50% to improve LLM comprehension and reduce context window consumption. This enables the Gemini CLI to act as a specialized ADK assistant, translating high-level ideas into idiomatic multi-agent code with greater accuracy and speed. The post demonstrates this through a practical example of building a GitHub issue labeling agent, showcasing the iterative process of ideation, code generation, testing, and refinement via conversational prompts.

Jul 2025Enterprise truth in action: Apigee API hub fueling powerful Developer Portals- Google Developers BlogThis post introduces the Apigee API hub as a central registry for enterprise APIs, providing machine-readable metadata that AI agents can leverage for understanding and interacting with enterprise systems. It emphasizes the hub's role in establishing governance, consistency, and security for API access by AI agents. Developer Portals are presented as a curated subset of the hub's offerings for API consumers. The post highlights the integration of the API hub as a foundational element for agentic strategies.

Jul 2025Advancing agentic AI development with Firebase Studio- Google Developers BlogIntroduces three new Agent modes (Ask, Agent, Agent Auto-run) for Gemini within Firebase Studio, enabling conversational interaction, AI-proposed code changes with user approval, and autonomous code generation and app development. Adds foundational support for the Model Context Protocol (MCP) to extend workflows with external servers (e.g., Cloud Firestore, MediaPipe). Integrates Gemini CLI directly into Firebase Studio for terminal-based AI assistance with code generation, debugging, and file management.

Jul 2025Announcing GenAI Processors: Build powerful and flexible Gemini applications- Google Developers BlogIntroduces GenAI Processors, an open-source Python library for structuring and simplifying the development of AI applications, particularly those involving multimodal input and real-time responsiveness. It defines a `Processor` interface for pipeline components and uses asynchronous streams of `ProcessorParts` for data flow. Key features include automatic concurrent execution optimization to minimize Time To First Token (TTFT) and seamless integration with the Gemini API via dedicated processors like `LiveProcessor` and `GenaiModel`. The library supports modular design, extensibility, and unified multimodal handling.

Jun 2025Simulating a neural operating system with Gemini 2.5 Flash-Lite- Google Developers BlogThis post details a research prototype for a generative, infinite computer experience simulating an operating system. It outlines the technical approach of using Gemini 2.5 Flash-Lite to generate UI on-the-fly. Key technical contributions include: 1. Conditioning the model with a 'UI constitution' (system prompt with rules) and 'UI interaction' (JSON object of user actions). 2. Using a trace of past interactions for contextual awareness to tune UI variability. 3. Implementing progressive rendering by streaming HTML chunks from the model and appending them to the component's state for near-instantaneous UI materialization. 4. Achieving statefulness by using an in-memory cache to model a session-specific UI graph, serving stored versions of generated screens without re-querying the model.

Jun 2025Gemini 2.5 for robotics and embodied intelligence- Google Developers BlogThis post details the application of Gemini 2.5 models to robotics and embodied intelligence. It showcases how developers can leverage Gemini 2.5 for semantic scene understanding (object identification, labeling, and spatial reasoning), combining spatial reasoning with code generation to control robots (using a provided API for tasks like pick-and-place), and building interactive robotics applications with the Live API (converting voice commands to executable robot plans). Specific examples include identifying objects needing restocking, reading gauges, detecting spills, predicting trajectories, and generating code for robot arm movements.

Jun 2025Google Cloud donates A2A to Linux Foundation- Google Developers BlogGoogle is donating the Agent2Agent (A2A) protocol specification, accompanying SDKs, and developer tooling to the Linux Foundation to establish the Agent2Agent project. This initiative aims to foster an open and interoperable ecosystem for AI agents by providing a common standard for communication and collaboration between distinct AI agents.

May 2025Exploring the Magic Mirror: an interactive experience powered by the Gemini models- Google Developers BlogThis post details the technical implementation of an interactive 'Magic Mirror' experience powered by Gemini models. It highlights the use of the Gemini Live API for real-time, bidirectional audio streaming and conversational interactions, including handling interruptions. It also showcases the application of system instructions to shape the AI's tone and conversational style, speech configurations for voice customization, and modality control for responding in text or audio. Furthermore, the post demonstrates the integration of Grounding with Google Search for up-to-date information and the use of Function Calling to enable image generation based on user descriptions. The project utilizes the JavaScript GenAI SDK and exposes these capabilities through a chat interface.

May 2025Gemini API I/O updates- Google Developers BlogThis post announces several new models and functionalities for the Gemini API. New models include Gemini 2.5 Flash Preview (with improved reasoning, code, and long context, and 22% efficiency gains), Gemini 2.5 Pro and Flash text-to-speech (TTS) with multispeaker and 24-language support, Gemini 2.5 Flash native audio dialog (preview, with 30+ voices, 24+ languages, proactive audio, and emotional response), Lyria RealTime for live music generation via WebSockets, Gemini 2.5 Pro Deep Think (experimental reasoning mode), and Gemma 3n (optimized for everyday devices with multimodal input). New API functionalities include thought summaries for debugging model responses, thinking budgets for controlling model computation, a URL Context tool for enhanced link analysis, a computer use tool (from Project Mariner) for browser control agents with Cloud Run integration, broader JSON Schema support (including '$ref' and tuple definitions), video understanding improvements (clipping, dynamic FPS/resolution), asynchronous function calling (NON-BLOCKING behavior for Live API), and a batch API for cost-effective, high-throughput requests with a 24-hour turnaround.

May 2025An upgraded dev experience in Google AI Studio- Google Developers BlogIntroduces native code generation in Google AI Studio using Gemini 2.5 Pro, integrated with the Gen AI SDK for app generation from prompts. Adds a 'Build' tab for creating and deploying AI-powered web apps to Cloud Run with a single click. Enhances multimodal generation with Imagen, Veo, and native speech generation models. Introduces native audio dialog for the Live API with Gemini 2.5 Flash, supporting over 30 voices and proactive audio detection. Adds text-to-speech (TTS) previews for Gemini 2.5 Pro and Flash with flexible control over output. Integrates Model Context Protocol (MCP) support into the Gen AI SDK and introduces a URL Context tool for referencing external content.

May 2025Building agents with Google Gemini and open source frameworks- Google Developers BlogThis post introduces the integration of Google Gemini models with open-source agent frameworks (LangGraph, CrewAI, LlamaIndex, Composio). It details how Gemini's advanced reasoning, function calling, multimodality, and large context window (up to 1M tokens) enhance agent capabilities. It provides examples and links for using Gemini with each framework, focusing on building sophisticated agentic applications.

May 2025From idea to app: Introducing Stitch, a new way to design UIs- Google Developers BlogIntroduces Stitch, an experiment from Google Labs that uses Gemini 2.5 Pro to generate UI designs and frontend code from natural language prompts or images. It facilitates rapid iteration and design exploration, with features like 'Paste to Figma' and front-end code export.

May 2025Fully Reimagined: AI-First Google Colab- Google Developers BlogThis post announces a significant AI-first reimagining of Google Colab, integrating agentic assistance powered by Gemini 2.5 Flash. Key contributions include: 1. Iterative Querying: Enhanced AI features for code generation, transformation, library chat, and intelligent error fixing with diff views. 2. Next-Generation Data Science Agent (DSA): Full integration of DSA for intelligent file analysis, autonomous agentic workflows with interactive feedback, and plan execution control. 3. Effortless Code Transformation: Simplified code modification through natural language descriptions and diff views. 4. Flexible Interaction: New UI elements like a center stage box and side panel for engaging with AI features. The post highlights the goal of supercharging workflows and mentions >2x efficiency gains from previous Gemini integrations.

May 2025What's new with Agents: ADK, Agent Engine, and A2A Enhancements- Google Developers BlogThis post announces the stable v1.0.0 release of the Python Agent Development Kit (ADK) and the initial v0.1.0 release of the Java ADK. It introduces the Agent Engine UI for simplified deployment, management, and monitoring of agents, including metrics, sessions, and trace debugging. The Agent2Agent (A2A) protocol has been updated to v0.2, adding support for stateless interactions and standardized authentication. The A2A Python SDK is now available, and new A2A integrations are highlighted from partners like Auth0, Box, Microsoft, SAP, and Zoom.

May 2025Gemini 2.5 Models now support implicit caching- Google Developers BlogIntroduces implicit caching for Gemini 2.5 models, which automatically applies cost savings (75% token discount) for requests sharing a common prefix with previous requests. This is achieved by dynamically passing savings back to developers. Best practices for increasing cache hits include keeping the beginning of the prompt consistent and adding variable content at the end. Minimum request sizes for Gemini 2.5 Flash and Pro have been reduced to 1024 and 2048 tokens, respectively, to improve cache eligibility. Explicit caching remains available for guaranteed cost savings.

May 2025Gemini 2.5 Pro Preview: even better coding performance- Google Developers BlogThis post announces Gemini 2.5 Pro Preview (I/O edition), highlighting its enhanced coding performance, particularly for front-end/UI development and agentic workflows. It showcases capabilities like video-to-code conversion and IDE integration for generating UI elements and full applications from concepts. The model's performance on benchmarks like WebDev Arena and junior-dev evals is emphasized, along with improvements in function calling error rates and trigger rates. It is available via Gemini API in Google AI Studio and Vertex AI.

Apr 2025How It’s Made: Little Language Lessons uses Gemini’s multilingual capabilities to personalize language learning- Google Developers BlogThis post details the engineering behind 'Little Language Lessons,' a collection of three language learning experiments powered by the Gemini API. It showcases how Gemini's multilingual and vision capabilities are used to personalize language learning through context-aware vocabulary/phrase generation (Tiny Lesson), realistic dialogue generation with slang (Slang Hang), and object detection for vocabulary acquisition (Word Cam). The post highlights the use of structured JSON outputs for API responses, prompt engineering techniques, and the integration of Cloud Translation API and Cloud Text-to-Speech API. It also discusses limitations such as occasional accuracy errors in LLM-generated content and regional accent mismatches in text-to-speech.

Apr 2025Three MarTech solutions putting generative AI in marketing- Google Developers BlogThis post introduces three open-source MarTech solutions powered by generative AI: ViGenAiR for video ad recrafting, Adios for AI-driven image generation and management, and Copycat for on-brand ad copy generation. ViGenAiR uses Gemini on Vertex AI to split and recombine video segments for format-specific ads. Adios leverages Gemini and Imagen on Vertex AI to generate and manage ad images at scale, with improved configuration flexibility and automatic retrying of failed requests. Copycat uses Gemini models, trained on top-performing ads and brand guidelines, to generate on-brand ad copy, employing Affinity Propagation for exemplar ad reduction and Gemini for style guide generation and prompt creation.

Apr 2025Agent Development Kit: Making it easy to build multi-agent applications- Google Developers BlogThis post introduces the Agent Development Kit (ADK), an open-source framework for building and managing multi-agent applications. ADK provides capabilities across the agent development lifecycle, including multi-agent design, a rich model and tool ecosystem (supporting Gemini, Vertex AI Model Garden, LiteLLM, LangChain, LlamaIndex, etc.), built-in streaming for multimodal interactions, flexible orchestration (sequential, parallel, LLM-driven routing), an integrated developer experience (CLI, Web UI), built-in evaluation, and easy deployment options. The post details core pillars of ADK, provides illustrative Python examples for building agents with tools and sub-agents, explains delegation mechanisms based on agent descriptions, and compares ADK with the Genkit framework. It highlights ADK's optimization for complex agents and multi-agent systems with higher-level abstractions and built-in integrations.

Apr 2025Announcing the Agent2Agent Protocol (A2A)- Google Developers BlogIntroduces the Agent2Agent (A2A) protocol, an open standard for AI agent interoperability. A2A enables agents to communicate, discover capabilities via 'Agent Cards', manage tasks with defined lifecycles, collaborate through messages, and negotiate user experience elements. It is built on HTTP, SSE, and JSON-RPC, supports long-running tasks, and is modality-agnostic. The protocol aims to facilitate secure, scalable multi-agent systems across enterprise platforms.

Mar 2025The Gemini API and the Internet of Things- Google Developers BlogThis post details the integration of the Gemini API's REST interface and function calling feature with an ESP32 microcontroller for voice-controlled IoT devices. It outlines the process of audio capture, encoding to WAV and then base64, sending to the Gemini API with function definitions (e.g., `changeColor`, `toggleLights`), and processing the API's response. A JSON example demonstrates the request structure for triggering functions based on audio input. The post highlights practical benefits such as simplified command handling and dynamic function execution for IoT development.

Mar 2025State-of-the-art text embedding via the Gemini API- Google Developers BlogIntroduces a new experimental Gemini Embedding text model (gemini-embedding-exp-03-07) available via the Gemini API. This model is trained on the Gemini model, surpasses text-embedding-004, ranks highest on the MTEB Multilingual leaderboard, and offers 8K input tokens, 3K output dimensions, Matryoshka Representation Learning (MRL), over 100 languages supported, and a unified model. It is compatible with the `embed_content` endpoint.

Mar 2025Gemini 2.0 Deep Dive: Code Execution- Google Developers BlogIntroduces code execution for Gemini models, providing a Python sandbox with libraries like NumPy, Pandas, and Matplotlib. Enables calculations, data analysis, visualization, and debugging of local files. Supports file input and graph output. Features experimental integrations with Multimodal Live API, Grounding with Google Search, and Gemini 2.0 Thinking Mode.

Mar 2025Data Science Agent in Colab: The future of data analysis with Gemini- Google Developers BlogIntroduces the Data Science Agent in Google Colab, which uses Gemini to generate complete, executable Python notebooks from natural language descriptions for data analysis tasks. This agent automates library imports, data loading, and boilerplate code generation, allowing users to focus on insights. It has demonstrated strong performance in multi-step reasoning benchmarks.

Feb 2025Build Scalable AI Agents: Langbase and the Gemini API- Google Developers BlogThis post details the integration of Gemini models (specifically Gemini Flash) with the Langbase platform for building and scaling AI agents. It highlights the performance benefits of Gemini models, including a 1M token context window, faster response times (28% improvement for Gemini 1.5 Flash), cost reduction (50%), and higher throughput (78% higher with Gemini 1.5 Flash, 131.1 tokens/sec). Langbase is presented as a serverless platform that simplifies agent development by bundling infrastructure, agent building, and model orchestration, and supports semantic RAG for memory agents.

Feb 2025Beyond the Chatbot: Agentic AI with Gemma- Google Developers BlogThis post details the application of Agentic AI principles using Gemma models. It introduces the concepts of Function Calling, ReAct prompting, and Few-shot prompting as techniques to enable AI agents to interact with external tools and generate dynamic content. The post provides a practical guide and examples for building a Gemma-based AI system that can act autonomously to achieve goals, such as generating game lore by retrieving historical information using defined tools.

Jan 2025Vertex AI RAG Engine: A developers tool- Google Developers BlogIntroduces Vertex AI RAG Engine, a managed orchestration service for building grounded generative AI applications. It streamlines data retrieval and LLM integration, offering ease of use, customization (parsing, chunking, embedding, vector storage), and integration flexibility with vector databases (Pinecone, Weaviate, Vertex AI Vector Search). It positions RAG Engine as a balance between Vertex AI Search (fully managed) and DIY RAG pipelines. Provides use cases in financial services, healthcare, and legal, and links to getting started notebooks, documentation, and integration examples.

Dec 2024The next chapter of the Gemini era for developers- Google Developers BlogThis post announces Gemini 2.0 Flash, a new iteration of Google's AI model, highlighting its improved performance (twice as fast as 1.5 Pro), new multimodal outputs (text, audio, images), and native tool use. It details the Multimodal Live API for real-time audio/video streaming and introduces coding agents like Jules that can execute tasks and manage GitHub workflows. Colab's Data Science Agent is also being updated with Gemini 2.0 for automated notebook generation. The post provides links to documentation, videos, and starter apps for developers to explore these new capabilities.

Nov 20247 examples of Gemini’s multimodal capabilities in action- Google Developers BlogThis post showcases seven examples of Gemini's multimodal capabilities, focusing on image and video understanding. It details how Gemini 1.5 Pro can generate detailed image descriptions, process long PDF documents (including extracting tables, charts, and generating code for visualization), reason over 'real world' documents like receipts to extract structured data, and extract information from webpages into JSON format. Specific examples include extracting Google revenue data from earnings reports and generating matplotlib code for visualization, and extracting book details from a Google Play webpage. The post encourages developers to explore these capabilities using the Gemini API.

Nov 2024OpusClip achieves 30% cost savings in visual description processing with Gemini Flash- Google Developers BlogOpusClip leveraged Gemini 1.5 Flash for visual description processing and prompt-based video clipping, resulting in a 30% cost saving in visual description processing and a 30% increase in user engagement for the 'ClipAnything' feature. The integration also led to a 10% increase in export rates. The post highlights the effectiveness of Gemini 1.5 Flash for multimodal AI tasks in video content creation and recommends its use for similar applications.

Nov 2024Learn to build and run AI powered apps at Firebase Demo Day ‘24- Google Developers BlogThis post introduces the integration of Vertex AI in Firebase, Gemini in Firebase, and Firebase App Hosting for building and running AI-powered applications. It showcases demos for calling Gemini from Android and iOS apps using the Vertex AI in Firebase SDK, implementing Retrieval Augmented Generation (RAG) with Genkit and Gemini, crafting AI apps with tool calling using Genkit, and deploying Genkit flows with App Hosting. Additionally, it highlights demos for monitoring Firebase Genkit in production with AI Monitoring, automating app testing with the Firebase AI Testing Agent, and rolling out AI features with confidence using Firebase Remote Config. It also mentions AI assistance in Crashlytics for faster issue resolution.

Nov 2024Enhancing AI Powered Developer Tools with Gemini API- Google Developers BlogThis post details how Sublayer, a Ruby-based AI agent framework, integrates Gemini 1.5 Pro and Flash models to automate documentation updates triggered by PR merges. The workflow involves using Gemini to analyze code diffs, repository contents, and existing documentation to suggest and generate documentation changes, creating new PRs. It also highlights Gemini's use in their core product for Ruby developers, enabling tasks like code generation, task decomposition, and data structure generation. The post also previews Augmentations.ai, a platform for AI-powered code review rules (Semantic Linting) and development activity summaries (Weekly Summaries).

Nov 2024Web AI Summit 2024 Recap: Client-Side AI for Developers- Google Developers BlogThis post summarizes the inaugural Web AI Summit, highlighting advancements in client-side AI for web developers. Key contributions include discussions on Transformers.js for in-browser ML, the Web Neural Network (WebNN) API for hardware acceleration, WebLLM for high-performance LLM inference, and Visual Blocks for AI pipeline prototyping. It also covers Chrome's built-in AI features, industry case studies, and the potential of AI in Chrome Extensions.

Nov 2024Gemini is now accessible from the OpenAI Library- Google Developers BlogThis post introduces the ability to access Gemini models (specifically chat completions and embeddings) through the OpenAI Library and REST API. It provides code examples for Python and Node.js, as well as a `curl` example for direct REST API calls. This extends the existing agentic application middleware by providing a new integration point for developers already familiar with the OpenAI ecosystem.

Nov 2024Supercharging AI Coding Assistants with Gemini Models' Long Context- Google Developers BlogThis post details the partnership with Sourcegraph to explore the impact of long-context Gemini models (1.5 Pro and Flash) on AI coding assistants. It highlights significant improvements in Essential Recall, Essential Concision, and Helpfulness benchmarks, along with a reduced hallucination rate (from 18.97% to 10.48%). It also discusses the tradeoff of increased time-to-first-token and the mitigation strategies employed by Sourcegraph, such as prefetching and layered context models, which reduced this time from 30-40 seconds to around 5 seconds for 1MB contexts.

Oct 2024Bringing AI Agents to production with Gemini API- Google Developers BlogThis post details the integration of the Gemini API with AgentOps, a Python SDK for monitoring AI agents. It highlights the cost-effectiveness and performance of Gemini 1.5 Flash for production AI agent deployments, emphasizing its ability to reduce LLM call costs significantly compared to other providers. The post also explains how AgentOps captures granular data on agent interactions beyond just LLM calls, providing observability for debugging, optimization, and audit trails in multi-agent systems. The integration process using LiteLLM is noted as being simple and quick.

Oct 2024Evolving the Responsible Generative AI Toolkit with new tools for every LLM- Google Developers BlogIntroduces SynthID Text for watermarking and detecting AI-generated text, the Model Alignment library for refining prompts using LLMs, and an improved deployment experience for the Learning Interpretability Tool (LIT) on Google Cloud for prompt debugging. SynthID Text is open-sourced via Hugging Face and PyPI. Model Alignment is available on PyPI and integrates with Vertex AI Studio. LIT deployment on Google Cloud now supports a model server container for Hugging Face or Keras LLMs on Cloud Run GPUs and expanded connectivity to self-hosted models or Gemini via Vertex API.

Oct 2024Compare Mode in Google AI Studio: Your Companion for Choosing the Right Gemini Model- Google Developers BlogIntroduces Compare Mode in Google AI Studio, a feature that allows developers to evaluate responses from different Gemini and Gemma models side-by-side. This feature helps in assessing response quality, latency, and optimizing system instructions to select the most suitable model for a specific use case.

Oct 2024Announcing Build with Google AI release 3: A Season of Gemma!- Google Developers BlogThis post announces Season 3 of the Build with Google AI series, focusing on projects built with Gemma open generative AI models. It highlights three specific projects: a native language AI assistant (Korean example), a business email AI assistant for processing customer emails and integrating with business systems, and a personal AI code assistant with a VS Code extension. All projects are open-source and designed to be easily extended. The post also points to Gemma developer documentation and the Gemma cookbook repository for code examples.

Sep 2024Enhance your prompts with Vertex AI Prompt Optimizer- Google Developers BlogIntroduces Vertex AI Prompt Optimizer, a new service in Public Preview that automates prompt engineering for LLMs. It uses an iterative LLM-based optimization algorithm with an optimizer and evaluator model to find the best prompt instructions and demonstrations based on user-defined evaluation metrics. The post details how to prepare prompt templates, upload labeled samples, configure optimization settings (including target model, evaluation metrics, and optimization mode), and run the optimization job using the Vertex AI SDK for Python. It highlights the benefits of reducing 'prompt fatigue' and improving prompt performance for GenAI applications.

Sep 2024Mastering Controlled Generation with Gemini 1.5: Schema Adherence for Developers- Google Developers BlogIntroduces Controlled Generation for Gemini 1.5 Flash, adding enum support and enabling schema adherence for AI model outputs. Controlled generation is now automatically enabled when using function calling with Gemini 1.5. The feature uses OpenAPI 3.0 schema definitions and adds minimal latency. Examples demonstrate generating structured JSON for meal planning and classifying product condition using enum schemas.

Aug 2024Build a text-based adventure game with Gemma 2- Google Developers BlogThis post introduces the use of instruction-tuned Gemma 2 models to build text-based adventure games. It provides Python code examples for creating a chatbot wrapper class that can be run locally or deployed on Vertex AI. It also outlines a basic game loop structure and provides an example of a custom stage class, demonstrating how to integrate AI agents into interactive game development workflows.

Jul 2024Introducing Genkit for Go: Build scalable AI-powered apps in Go- Google Developers BlogThis post announces the alpha release of Genkit for Go, an open-source framework for building AI-powered applications and cloud services natively in Go. It extends the capabilities of the previously Node.js-focused Genkit by providing Go-idiomatic libraries for AI generation, retrieval (RAG), and workflow orchestration ('flows'). Key features include a unified generation API supporting various models (Gemini, Gemma, third-party), native vector database support, and the Dotprompt format for prompt engineering. It also details plugins for Google AI (Gemini, Gemma, Vertex AI), Ollama, Pinecone, and Google Cloud telemetry, along with integrated developer tooling (CLI, browser UI) and production observability via OpenTelemetry. The post includes code examples demonstrating flow definition and prompt templating.

Jul 20243 fun Gemma project ideas- Google Developers BlogThis post details three project ideas using Gemma models: an old Korean language translator, a game design brainstorming assistant, and a 'letter to Santa' composer. For the translator, it explains fine-tuning Gemma with a dataset of old Korean literature to generate contemporary Korean text, demonstrating the process with code examples and sample outputs. For game design, it shows how Gemma can elaborate on game concepts, design characters, and write stories based on initial pitches. The Santa letter project is briefly mentioned as another application of Gemma on a Raspberry Pi. The post also highlights the ability to publish fine-tuned models to Kaggle and Hugging Face.

Jun 2024Gemini 1.5 Pro 2M context window, code execution capabilities, and Gemma 2 are available today- Google Developers BlogThis post announces the general availability of the 2 million token context window for Gemini 1.5 Pro, introduces context caching for Gemini 1.5 Pro and Flash to reduce input costs, and enables code execution capabilities for both Gemini 1.5 Pro and Flash models via the Gemini API and Google AI Studio. It also highlights the availability of Gemma 2 in Google AI Studio and provides updates on Gemini 1.5 Flash's production readiness and upcoming text tuning capabilities.

Jun 2024How We Built It: The I/O Crossword- Google Developers BlogThis post details the technical implementation of the I/O Crossword game, highlighting the use of Gemini Advanced for generating topical crossword clues from I/O keynote footage. It emphasizes the integration of the Gemini API with Firebase Genkit to provide an AI-powered hint feature, where Genkit flows process user questions and instruct the Gemini 1.5 Flash model to provide yes/no answers. The UI is built with Flutter, utilizing the InteractiveViewer widget and compiling to WebAssembly for performance. Firebase Hosting, Firestore, Cloud Functions, App Check, and Firebase Authentication are used for backend functionality, real-time data storage, game resets, and security. Dart Frog and Cloud Run are employed for sharing code between frontend and backend, with Cloud Run providing autoscaling and Dart Frog managing database changes to prevent cheating.

Jun 2024How It’s Made: AI Roadtrip, a Pixel Campaign Powered by Generative AI and Fans- Google Developers BlogThis post details the technical implementation of an AI-powered content generation pipeline for a social media campaign. It describes how Gemini 1.5 Pro was used for script generation by providing numerous examples in the prompt to condition the model on tone, character voice, and format. It also explains how Gemini was used to generate detailed image prompts for Imagen 2 to create consistent and visually interesting backgrounds, and how Cloud Text-to-Speech was used for audio generation. The compositing process in Unreal Engine and the use of a web-based editing tool for animation and dynamic elements are also described.

Jun 2024How it's Made: GenType Alphabet Creator- Google Developers BlogThis post details the creation of GenType, an experimental tool that leverages the Imagen 2 API to generate custom alphabets. It explains the 'prompt recipe' approach, where a single user input is used to generate 26 distinct letters by automating multiple API requests. The post highlights the importance of specificity in prompts (foreground, background, style) for maintaining aesthetic consistency across the generated alphabet and showcases the tool's flexibility for creative use cases.

May 2024How Firebase Genkit helped add AI to our Compass app- Google Developers BlogIntroduces Firebase Genkit, an open-source framework for building AI features in applications. Highlights Genkit's developer tooling (CLI, UI), flow primitive for end-to-end observability, dotprompt format for prompt management, and plugin ecosystem. Demonstrates Genkit's use in the Compass travel app for generating embeddings with pgvector and textembedding-gecko API, implementing semantic search with a retriever, and refining prompts. Mentions deployment to Cloud Run and integration with Google Cloud Logging/Monitoring, Cloud Firestore, and Vertex AI.

Apr 2024Introducing new AI tools on Google for Developers- Google Developers BlogIntroduces AI-powered Chat, Code Explain, and AI Powered Search tools for Google for Developers documentation and learning resources. These tools leverage generative AI to provide natural language explanations of code samples, answer questions about documentation, and streamline search. Requires a Google Developer Profile. Available in open beta.

Apr 2024Gemini 1.5 Pro Now Available in 180+ Countries; with Native Audio Understanding, System Instructions, JSON Mode and more- Google Developers BlogThis post announces the public preview availability of Gemini 1.5 Pro in 180+ countries via the Gemini API. It introduces native audio understanding capabilities, a File API for handling files, system instructions for guiding model responses, and JSON mode for structured output. Function calling has been improved for reliability. A new text embedding model, text-embedding-004, is also released, outperforming comparable models on MTEB benchmarks.

Mar 2024Tune Gemini Pro in Google AI Studio or with the Gemini API- Google Developers BlogIntroduces and details the capability to tune Gemini 1.0 Pro models using Parameter Efficient Tuning (PET) via Google AI Studio and the Gemini API. Explains PET as a method for customizing models with custom data, offering advantages over few-shot prompting and traditional fine-tuning in terms of data requirements, cost, and complexity. Outlines use cases and provides step-by-step instructions for using Google AI Studio to create and run tuned models.

Feb 2024Gemini 1.5: Our next-generation model, now available for Private Preview in Google AI Studio- Google Developers BlogIntroduces Gemini 1.5 Pro with a Mixture-of-Experts (MoE) architecture and an experimental 1 million token context window, enabling multimodal reasoning across large inputs like PDFs, code repositories, and videos. Highlights new developer capabilities in Google AI Studio for uploading multiple files, querying entire codebases, and processing video content. Also announces easy model tuning, new developer integrations (Firebase Extensions, Project IDX, Google AI Dart SDK), and reduced pricing for Gemini 1.0 Pro.

Dec 2023It's time for developers and enterprises to build with Gemini Pro- Google Developers BlogThis post announces the public availability of Gemini Pro via the Gemini API and Google AI Studio, detailing its features (32K context window, function calling, embeddings, semantic retrieval, chat), multimodal capabilities (Gemini Pro Vision), SDK support, and competitive pricing. It also highlights the transition to Vertex AI for enterprise customization and data control, and previews the upcoming Gemini Ultra model.

Dec 2023How it’s Made: Interacting with Gemini through multimodal prompting- Google Developers BlogThis post demonstrates multimodal prompting with Gemini, showcasing its ability to reason across text and images for tasks like game logic, spatial reasoning, and tool use. It provides examples of using Gemini for image description, pattern recognition, logic puzzles, magic tricks, cup shuffling, tool use (music search query generation), game creation (geography guessing game), and coding (countdown timer). The post highlights the potential of multimodal AI for new translation capabilities between different inputs and outputs.

Oct 2023Make with MakerSuite Part 2: Tuning LLMs- Google Developers BlogThis post introduces Parameter Efficient Tuning (PET) within MakerSuite as a simplified method for customizing LLMs. It explains the concept of tuning, contrasts it with traditional fine-tuning, and details the four-step process within MakerSuite: creating a tuned model, selecting data (from saved prompts, Sheets, or CSVs, recommending at least 100 examples), viewing tuning progress, and running the tuned model. It highlights that PET allows customization with a few hundred data points, making LLM customization more accessible to developers.

Sep 2023Make with MakerSuite – Part 1: An Introduction- Google Developers BlogThis post introduces MakerSuite, a new tool for building generative AI applications. It provides a UI for prompting Google's latest models (like PaLM 2) and generates production-ready code. It supports three prompt types: text, data, and chat. MakerSuite is now available without a waitlist. The post also highlights how generative AI can enhance developer productivity with tools like Project IDX and Android Studio Bot, and enable new user experiences like Bard.

Aug 2023MakerSuite expands to 179 countries and territories, and adds helpful features for AI makers- Google Developers BlogMakerSuite has expanded access to 179 countries and territories, making it available to more developers globally, including those with Google Workspace accounts. New features introduced include automatic text prompt optimization, a dark mode option, and the ability to import and export data using Google Sheets and CSV files. These additions aim to streamline the AI application development process by simplifying prompt engineering, improving user interface experience, and facilitating data management and collaboration.

Aug 2023How it’s Made: TextFX is a suite of AI tools made in collaboration with Lupe Fiasco- Google Developers BlogThis post details the technical process of building TextFX, a suite of AI tools for creative text manipulation. It explains the use of the PaLM API and few-shot prompting to integrate LLMs into a creative workflow. Specific techniques discussed include prompt engineering for tasks like generating same-sounding phrases, similes, and acronyms. The post also mentions the use of MakerSuite for rapid prototyping and the open-sourcing of the TextFX application code, providing a concrete example of how to build with the PaLM API.

May 2023Using Generative AI for Travel Inspiration and Discovery- Google Developers BlogThis post introduces an open-source Generative AI template for the travel industry, demonstrating the combination of the PaLM API and Google Maps Places API for conversational travel itinerary planning. It details the implementation using few-shot prompting, parsing PaLM API responses to extract locations for Google Maps API integration, maintaining conversational memory through the 'messages' field, and leveraging embedding services for third-party data integration and personalized recommendations. The template aims to showcase how LLMs can save users time in complex tasks like travel planning and can be extended with partner data for seamless booking.

May 2023Generative AI ‘Food Coach’ that pairs food with your mood- Google Developers BlogThis post details the implementation of a Generative AI 'Food Coach' using the PaLM API. It showcases multiple API calls for different purposes: generating humorous responses, generating recipes, formatting responses into JSON, and safeguarding. The post explains prompt engineering techniques, including the use of context, messages, temperature, and candidate_count. It highlights strategies for balancing creativity and formatting, such as separating tasks into subtasks and using parallel generation to reduce perceived latency. The post also touches upon using embedding services for third-party data integration and potential partnerships for fulfillment.

May 2023Powering Talking Characters with Generative AI- Google Developers BlogThis post introduces a customizable AI-powered character template that demonstrates the power of LLMs to create interactive experiences with depth. It showcases how combining Large Language Models with existing Google APIs and technologies can solve specific industry use cases. The 'Talking Character' template is a 3D avatar builder that allows developers to bring an animated character to life with Generative AI, enabling configuration of personality, backstory, and knowledge base. Interactions are powered by Google's speech-to-text service, the PaLM API, and text-to-speech. Animation is achieved using the MediaPipe framework and a new audio-to-blendshapes machine learning model trained with TensorFlow, which predicts blendshape weights from speech input in real-time to drive the animated avatar. The model is trained from 'talking head' videos using 3D face tracking to learn a mapping from speech to facial blendshapes. Blendshape weights are then used to morph facial expressions and lip motion of the 3D avatar using the three.js library. Character design focuses on emotional bonding through backstory and personality. The prompt structure includes personality, backstory, and knowledge base, which are combined into a large prompt sent to the PaLM API. Partnerships with ZEPETO are highlighted, showcasing metaverse applications, and other use cases in gaming, education, and commerce are discussed.

May 2023PaLM API & MakerSuite moving into public preview- Google Developers BlogThis post announces the public preview of the PaLM API and MakerSuite, powered by PaLM 2. It highlights the API's improved reasoning and code generation capabilities, efficiency with speeds up to 75+ tokens per second and 8k context windows, and integration into developer tools like Firebase and Colab. It also showcases Project Tailwind, an AI-first notebook built with the PaLM API, and MakerSuite for building generative AI applications.

May 2023How It’s Made: I/O FLIP adds a twist to a classic card game with generative AI- Google Developers BlogThis post details the technical implementation of the I/O FLIP game, showcasing the use of generative AI for content creation and a modern tech stack for game development. Specifically, it highlights: 1. AI-generated images using Muse and DreamBooth, and AI-generated descriptions using the PaLM API. 2. Game logic and UI built with Flutter and Dart, leveraging features like records and fragment shaders for effects. 3. Backend infrastructure using Firebase (Cloud Storage, Firestore, App Check) and Cloud Run for scalability. 4. Code sharing between frontend and backend using Dart Frog for cheating prevention and faster development. 5. The game's mechanics and user flow, including card generation, team creation, and match play.

Mar 2023PaLM API & MakerSuite: an approachable way to start prototyping and building generative AI applications- Google Developers BlogThis post introduces PaLM API and MakerSuite as approachable tools for prototyping and building generative AI applications. It highlights the ability to start with simple prompts and gradually build more complex applications, emphasizing the ease of use for developers new to generative AI. MakerSuite provides a UI for prompt engineering and model tuning, while the PaLM API offers programmatic access to the models.

What this trail covers