Agentic Application Middleware

8/6/2026

Introduces Agent Plugins 1.0.0, an open, vendor-neutral specification for packaging Agent Skills and MCP servers into portable plugins. This specification defines a standardized directory structure (e.g., `skills/`, `mcp.json`) and a simple `plugin.json` manifest to ensure portability across different agent clients. Google is joining as a Core Maintainer and integrating support into its products, including Agents CLI and Data Agent Kit.

8/5/2026

This post details the evolution of the Model Context Protocol (MCP) from a stateful to a stateless protocol. Key changes include the removal of the `initialize/initialized` handshake and the `Mcp-Session-Id` header, making every request self-describing and independent. Protocol version, client info, and capabilities are now included in a `_meta` field within each request. HTTP Standardization (SEP-2243) introduces headers like `Mcp-Protocol-Version`, `Mcp-Method`, and `Mcp-Name` for routing and auditing without deep packet inspection. Intelligent Caching with `ttlMs` (SEP-2549) is introduced for caching tool and resource results. Multi Round-Trip Requests (MRTR) (SEP-2322) enable stateless handling of server-to-client requests by returning `InputRequiredResult` with a `requestState` payload. The Tasks Extension (SEP-2663) allows for asynchronous, non-blocking execution of long-running tools by returning a `taskId` immediately. Security enhancements include Issuer Verification (RFC 9207) and Resource Indicators (RFC 8707).

6/17/2026

Introduces architectural patterns for integrating Agent-to-User Interface (A2UI) and Model Context Protocol (MCP) Apps to address the trade-offs between declarative and custom agentic UIs. Pattern 1: Serving A2UI over MCP servers, detailing advantages like bypassing iframe limitations, separation of concerns, enhanced environment portability, simplified security, and accelerated development cycles. It explains static vs. dynamic delivery via MCP Resources and MCP Tool Calls, and contrasts A2UI over MCP with A2UI over A2A architectures. Pattern 2: Running MCP Apps within A2UI components, highlighting benefits such as brand consistency, controlled delegation, specialized capabilities, and secure state alignment.

6/17/2026

Introduces Agentic Resource Discovery (ARD), an open specification for publishing, discovering, and verifying AI capabilities across the web. ARD standardizes how tools, skills, and agents are shared and connected, regardless of their underlying framework or provider. It utilizes catalogs hosted under an organization's domain for identity and trust, and registries that index these catalogs for discovery. The post details the architecture of ARD, including catalogs and registries, and demonstrates its functionality through a video showcasing runtime discovery and connection. It also announces Google Cloud's Agent Registry in Gemini Enterprise Agent Platform as an enterprise-grade implementation of this vision, focusing on trust, governance, and operationalization.

5/19/2026

The Google AI Edge Gallery now supports the Model Context Protocol (MCP) over Streamable HTTP as an experimental feature on Android (iOS coming soon). This allows for dynamic import of tool definitions and resource schemas into the on-device model's system prompt, enabling on-device reasoning and decision-making for tasks like querying Google Workspace, Google Maps, or fetching web content. A new 'Schedule Notification' skill enables proactive routines via local notifications. Persistent chat history is now supported using the LiteRT-LM backend's fast prefill capability, allowing for session resumption with preserved text, image, and audio inputs. The ability to edit the custom system prompt directly within chat settings has also been introduced.

5/19/2026

This post announces the transition of Gemini CLI to Antigravity CLI. Antigravity CLI is a new terminal experience built in Go, offering faster execution and asynchronous workflows for multi-agent communication. It retains key features like Agent Skills, Hooks, Subagents, and Extensions (now plugins), and shares a unified architecture with Antigravity 2.0. The post also details the timeline for Gemini CLI's deprecation and provides migration resources.

5/14/2026

Introduces Genkit middleware for agentic applications, enabling interception of generation calls at the generate, model, and tool layers. Provides pre-built middleware for retries, fallbacks, tool approval, filesystem access, and skills injection. Demonstrates building custom middleware for content filtering and composing middleware stacks. Highlights the Developer UI for debugging and testing middleware.

4/30/2026

Introduces Gemini Embedding 2, a multimodal embedding model that maps text, images, video, audio, and documents into a single embedding space. Details its use in agentic multimodal RAG with task prefixes for optimized embeddings, multimodal search with prefixes like 'task: search result', and search reranking using distance metrics. Also covers clustering, classification, and anomaly detection using symmetric task prefixes. Discusses efficient storage using vector databases and the Matryoshka Representation Learning (MRL) feature for truncating embeddings. Provides code examples for interleaved input processing, task prefix preparation, and similarity calculation.

4/22/2026

Introduced Agents CLI in Agent Platform, a unified programmatic backbone for the Agent Development Lifecycle (ADLC) on Google Cloud. This CLI is designed for AI coding agents and provides a machine-readable interface to the Google Cloud agent stack (Agent Platform, Cloud Run, A2A Integration). Key features include injecting bundled skills into coding environments, enabling local simulation and evaluation (unit tests, data validation, comparison of runs), and automating deployment to production infrastructure (Agent Runtime, Cloud Run, GKE) via Infrastructure as Code (IaC) and CI/CD pipelines. It also supports publishing agents to Gemini Enterprise. The CLI operates in 'Agent Mode' for AI consumption and 'Human Mode' for direct developer execution.

4/21/2026

This post details the refactoring of a monolithic sales research AI agent ('Titanium') into a production-ready system using Google's Agent Development Kit (ADK). Key technical contributions include: 1. Replacing the monolithic script with an orchestrated pipeline of specialized sub-agents (Company Researcher, Search Planner, Case Study Researcher, Selector, Email Drafter) using ADK's `SequentialAgent`. 2. Enforcing structured outputs by replacing prompt-based JSON formatting with Pydantic objects, leveraging ADK's dynamic Structured Outputs feature. 3. Implementing a dynamic Retrieval Augmented Generation (RAG) pipeline by using Playwright for web scraping and Google Cloud Vector Search for indexing and hybrid search of customer success stories, replacing hardcoded case studies. 4. Integrating OpenTelemetry via ADK for observability, capturing distributed traces of model requests, tokens, and tool executions, and pairing it with Server-Sent Events (SSE) for live telemetry. 5. Leveraging ADK's built-in cost optimization features like exponential backoffs, timeout boundaries, and configurable retry loops to manage token burn.

4/17/2026

A2UI v0.9 introduces a framework-agnostic standard for declaring UI intent, allowing agents to communicate with client applications using a common language. Key contributions include a shared web-core library for browser UI renderers, an official React renderer, version-bumped renderers for Flutter, Lit, and Angular, a dedicated spot for community renderers, and the A2UI Agent SDK for easier agent-side development with optimized generation pipelines and caching layers. New language features include client-defined functions, client-to-server data syncing, improved error handling, and a simplified schema. Transport interfaces have been refined for smoother agent-client connections (MCP, Websockets, REST, AG UI, A2A). The SDK supports version negotiation, dynamic catalogs, and resilient streaming for incremental parsing and healing of LLM output.

4/15/2026

Introduced subagents to Gemini CLI, allowing for delegation of complex tasks to specialized agents with isolated context windows, system instructions, and tools. Enabled custom subagent creation via Markdown files and bundling as extensions. Introduced parallel execution of subagents. Added built-in subagents: generalist, cli_help, and codebase_investigator. Introduced explicit task delegation using the @agent syntax.

3/31/2026

This post announces the release of Agent Development Kit (ADK) for Go 1.0. New features include OpenTelemetry integration for tracing, a Plugin System with a Retry and Reflect plugin for self-healing, Human-in-the-Loop (HITL) confirmations for sensitive operations, YAML configuration for agents, and stabilized Agent2Agent (A2A) protocol for polyglot agent communication.

3/30/2026

This post announces the release of version 1.0.0 of ADK for Java, introducing significant enhancements to the Agent Development Kit framework. Key features include new grounding tools like GoogleMapsTool and UrlContextTool for interacting with external data, a centralized plugin architecture managed by the App class for global execution control (logging, guardrails), enhanced context engineering with event compaction to manage context window sizes, Human-in-the-Loop (HITL) support through ToolConfirmation workflows for agent pausing and human approval, and defined contracts for session and memory services with persistence options. It also introduces Agent2Agent (A2A) support for seamless collaboration between remote agents.

3/25/2026

Introduced 'agent skills' as a mechanism for SDK maintainers to provide up-to-date information to coding agents, addressing the knowledge gap of LLMs. Developed a 'Gemini API developer skill' that explains API features, models, SDKs, sample code, and documentation entry points. Evaluated the skill's performance using an evaluation harness with 117 prompts, demonstrating significant performance improvements for newer Gemini models, especially in SDK usage and across various domains. Discussed challenges with skills, such as update mechanisms and potential for outdated information.

3/17/2026

Introduced 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.

3/11/2026

Introduced 'plan mode' for Gemini CLI, a read-only mode that enables agents to analyze requests, map complex changes, understand codebases, and ask clarifying questions before execution. This mode utilizes read-only tools like `read_file`, `grep_search`, and `glob` for safe exploration, specialized sub-agents like `codebase_investigator` for architectural mapping, and supports iterative design through conversation. The `ask_user` tool was introduced to allow agents to pause and ask targeted questions for clarification. Plan mode also supports read-only MCP tools for accessing external context from GitHub, Postgres, and Google Docs. The Conductor extension is highlighted as an example of leveraging plan mode and `ask_user` for context-driven development and complex workflow orchestration. Plan mode is enabled by default and can be toggled off in settings. Higher reasoning Pro models like Gemini 3.1 Pro are used during planning.

2/27/2026

This post announces a significant expansion to the Agent Development Kit (ADK) ecosystem by integrating a broad suite of third-party tools and platforms. These integrations allow AI agents to interact with code repositories (GitHub, GitLab, Daytona), project management tools (Asana, Atlassian, Linear, Notion), databases (Chroma, MongoDB, Pinecone), memory stores (GoodMem, Qdrant), observability platforms (AgentOps, Arize AX, Freeplay, MLflow, Monocle, Phoenix, W&B Weave), connectors (n8n, StackOne), AI models/datasets (Hugging Face), payment systems (PayPal, Stripe), speech/audio services (Cartesia, ElevenLabs), and email/messaging platforms (AgentMail, Mailgun). It also highlights built-in integrations with Google Cloud services. The post provides code examples demonstrating how to add these integrations using the Mcp Toolset primitive or plugin architecture.

2/26/2026

Introduced on-device function calling capabilities to the Google AI Edge Gallery using the FunctionGemma model (270M parameters), enabling agentic experiences like Mobile Actions and Tiny Garden. Expanded Google AI Edge Gallery to iOS in addition to Android. Integrated benchmarking features into the Gallery app to measure LiteRT's CPU and GPU performance. Provided fine-tuning recipes and guides for implementing function calling.

2/13/2026

Introduced Automated Reviews for Conductor, an extension for the Gemini CLI. This feature adds a 'verify' step to the development lifecycle, performing code review (static and logic analysis, flagging race conditions, null pointer risks, logic errors), plan compliance checks against plan.md and spec.md, guideline enforcement (style guides and custom guidelines), test-suite validation (unit and integration tests, coverage data), and basic security review (hardcoded API keys, PII leaks, unsafe input handling). The output provides actionable intelligence categorized by severity, with clear instructions and file paths for iteration.

2/11/2026

Introduces 'extension settings' for Gemini CLI extensions, enabling authors to define configuration parameters (API keys, URLs, project IDs) that users are prompted for upon installation. This automates setup, integrates security by storing sensitive settings in the system keychain, and provides command-line management via `gemini extensions config`. It also supports global user and project-specific workspace scopes. The AlloyDB extension is used as a practical example. The post details how authors define settings in `gemini-extension.json` and how users manage them with `gemini extensions config` and `gemini extensions list`.

1/29/2026

Introduced Antigravity (AGY), a new framework for orchestrating stateful agentic systems, enabling natural-language-driven orchestration to compress development cycles. Implemented a "Split-Brain" architecture separating "reflexes" (Gemini Nano at the edge via Web API for ~15ms response times) from "strategy" (Gemini 3.0 for higher-level reasoning). Utilized Maps MCP for track perception and rendered real-time 3D telemetry at 60FPS. Implemented Neuro-Symbolic Training with QLoRA for mathematically verifiable coaching grounded in physics. Developed a Draft -> Verify -> Refine agentic loop for real-time triage and automated code fixes. Introduced persona-based routing with a "Gemini Squad" of agents for context-aware guidance and managing driver cognitive load.

1/28/2026

Introduces Gemini CLI hooks, a new feature allowing users to execute custom scripts at predefined points in the Gemini CLI's agent loop. This enables customization of agent behavior for tasks like adding context, validating actions, enforcing policies, logging, and sending notifications. Provides a concrete example of a `BeforeTool` hook for automated secret scanning using a shell script and `jq`. Discusses best practices for hooks, including performance, specificity, and security. Highlights the integration of hooks into Gemini CLI extensions, enabling bundled hooks for features like the 'Ralph loop' technique for iterative task completion.

12/19/2025

This post introduces Gemini 3 as a core orchestrator for agentic AI workflows, highlighting its precise controls over reasoning depth and state management for improved reliability. It showcases six open-source frameworks (ADK, Agno, Browser Use, Eigent, Letta, mem0) that leverage Gemini 3 to build production-ready agentic examples, including browser automation, social media interactions, data synthesis, and enterprise task automation. Specific examples demonstrate Gemini 3's multimodal capabilities for visual field identification, reasoning speed for fluid automation, thought signatures for maintaining reasoning state, and dynamic memory blocks for personalized interactions.

12/17/2025

Introduces Conductor, a Gemini CLI extension that enables context-driven development by formalizing project context (product, tech stack, workflow) into persistent Markdown files. This allows for planning before coding, maintaining AI context with style guides and goals, safe iteration through plan reviews, team collaboration with shared context, and building on existing codebases by informing design decisions. Conductor supports 'brownfield' projects by creating foundational documents and updating context as projects evolve. It works by establishing context via `/conductor:setup`, specifying and planning new work with `/conductor:newTrack` to generate specs and plans, and implementing code via `/conductor:implement` which iterates through the plan.md file.

12/17/2025

Introduces Gemini 3 Flash, a new model for the Gemini CLI, optimized for high-frequency workflows and agentic coding. Highlights its performance improvements over previous versions (Gemini 2.5 Pro, Gemini 3 Pro) in terms of speed, cost, and SWE-bench scores for agentic coding. Demonstrates its capabilities in generating complex code (3D Voxel simulation), processing large context windows for code changes, and generating load-testing scripts for stress testing applications.

12/17/2025

Introduced the Agent Development Kit (ADK) for TypeScript, an open-source framework for building AI agents and multi-agent systems with a code-first philosophy. Key features include end-to-end type safety, modular components (Agents, Instructions, Tools), model-agnostic compatibility, and seamless deployment options. It integrates with existing TypeScript tools and ecosystems, and offers native integration with MCP Toolbox for Databases.

12/15/2025

Introduces A2UI (Agent-to-UI), an open-source project and format for agents to generate and update user interfaces. A2UI is a declarative data format, not executable code, designed for security, incremental updates, and framework-agnostic rendering. It allows agents to compose UIs from a catalog of components, enabling richer and more efficient user interactions compared to text-only interfaces. A2UI aims to solve the challenge of rendering UI from remote, untrusted agents by providing a safe, data-like transmission of UI specifications that clients can render natively, retaining control over styling and security.

12/11/2025

Introduces the Gemini Interactions API as a new interface for stateful, multi-turn agentic workflows, offering unified access to raw models and managed agents. Details two integration patterns: 1) Powering ADK agents by using the Interactions API as their inference engine, enabling simplified state management, background execution, and native thought handling. 2) Using the Interactions API as a transparent bridge for existing A2A agents via the `InteractionsApiTransport`, which maps the A2A protocol to the Interactions API surface, allowing A2A clients to interact with Interactions API endpoints as remote agents without code changes. Provides code examples for both patterns in Python.

12/10/2025

Introduced Session Management to Gemini CLI, enabling automatic saving of conversation history, tool executions, token usage, and assistant reasoning. Users can resume sessions via an interactive browser or command-line flags, and manage history with cleanup policies. This feature enhances the ability to maintain context and resume work across sessions.

12/4/2025

This post introduces the concept of 'context engineering' as a discipline for building production-grade AI agents, moving beyond simply increasing context window sizes. It details how the Google Agent Development Kit (ADK) implements this by treating context as a 'compiled view' over a richer stateful system. Key architectural principles include separating storage from presentation, using explicit transformations via processors in an LLM Flow, and enforcing scope by default. The post elaborates on the tiered model of context (Working context, Session, Memory, Artifacts), the role of Session Events for structured history, context compaction using LLMs to summarize older events, and context caching optimizations by treating context as stable prefixes and variable suffixes. The `contents` processor is highlighted for transforming Session Events into the working context for LLM calls.

11/20/2025

Introduces Google Antigravity, a new agentic development platform that combines an AI-powered coding experience with a dedicated 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 agent orchestration. Use cases demonstrate delegating multi-tool software tasks, requesting UI changes with artifact-based verification (screenshots, recordings), and dispatching agents for background maintenance or bug fixes. Artifacts are used for verification, with direct feedback integration. The platform supports learning primitives and model optionality with Gemini 3 Pro, Claude Sonnet 4.5, and GPT-OSS.

11/19/2025

Introduces Gemini 3 Pro Preview, highlighting new agentic features: `thinking_level` for adjustable reasoning depth, stateful tool use via "Thought Signatures" for retaining internal reasoning, and adjustable `media_resolution` for multimodal fidelity. Details Day 0 support from open-source frameworks (LangChain, AI SDK by Vercel, LlamaIndex, Pydantic AI, n8n) for building agents with Gemini 3. Provides best practices for migrating to Gemini 3, including prompt simplification, keeping temperature at 1.0, handling thought signatures, and optimizing visual tokens.

11/19/2025

This post details the integration of Gemini 3 Pro into Jules, an autonomous coding agent. Key technical advancements include improved agentic capabilities for clearer reasoning, stronger intent alignment, and enhanced reliability in multi-step tasks and context maintenance. Jules is being extended to multiple surfaces (terminal, Gemini CLI, API) with a unified project view. The CLI has been updated with parallel runs, Windows support, a simpler flow, and a diff viewer. The Jules API is now stable for custom workflows. Memory handling and environment variable support have been improved. The critic agent's replanning and re-engagement logic has been enhanced. Git handling has been made safer. VM performance has been improved.

11/18/2025

This post introduces the integration of Gemini 3 Pro into the Gemini CLI, enhancing its capabilities for agentic coding. It details five practical use cases: generating a ready-to-deploy app with 3D graphics from a detailed prompt, transforming a visual sketch into a working app via drag-and-drop, generating complex shell commands with natural language (e.g., Git Bisect), creating accurate documentation from code, and debugging performance issues in a live Cloud Run service by orchestrating multi-tool workflows (e.g., Cloud Run and Snyk).

11/13/2025

Introduced a new rendering foundation for the Gemini CLI, enabling a robust, intuitive, and visually stable user experience. Key enhancements include mouse-based navigation within the input prompt, sticky headers for persistent context, a flicker-free experience, robust rendering that handles terminal resizing gracefully, a stable input prompt anchored at the bottom, and preserved chat history upon exit. These UI improvements are enabled by default in Gemini CLI v0.15.0.

11/7/2025

Agent Garden is now available to all users, not just Google Cloud users. It offers a repository of curated agent samples, solutions, and tools that integrate with cloud services like BigQuery and Vertex AI Search. The Agent Starter Pack facilitates one-click deployment of sample agents to Agent Engine, and customization is available through Firebase Studio. Renault Group's integration of a data scientist agent into their EV charger platform is highlighted as a success story.

11/7/2025

Introduction of the Agent Development Kit (ADK) for Go, providing a code-first toolkit for building AI agents with Go's concurrency and strong typing. Highlights include robust debugging, reliable versioning, deployment freedom, integration with 30+ databases via MCP Toolbox, and support for the Agent2Agent (A2A) protocol with a contributed A2A Go SDK.

11/7/2025

Introduced User Simulation as a new feature within the Agent Development Kit (ADK) evaluation framework. This feature utilizes an LLM to dynamically generate multi-turn conversations based on high-level goals and conversation plans, moving away from brittle, scripted tests. It allows for configuration of the simulation model, its behavior, and turn limits, and provides detailed invocation and metric breakdowns for evaluation. The goal is to significantly reduce test creation time, improve test resilience, and establish a reliable regression suite for AI agents.

10/30/2025

This post introduces a real-time bidirectional streaming architecture as a successor to the request-response model for multi-agent systems. It details the engineering challenges of this 'turnless' model, including state and session management, and performant I/O. The Agent Development Kit (ADK) is presented as a solution, featuring a streaming-native-first approach with: 1. Asynchronous real-time I/O management via LiveRequestQueue. 2. Stateful, transferable sessions for multi-agent collaboration, including signal-based event division and efficient media storage. 3. Event-driven callbacks (before_tool_callback, after_tool_callback) for real-time customization. 4. Streaming-native tools implemented as AsyncGenerators that can yield multiple results over time and process user input streams directly.

10/29/2025

Introduces the Jules extension for Gemini CLI, enabling asynchronous coding tasks. Jules operates in a background VM, cloning code, installing dependencies, and modifying files. It supports offloading tasks like bug fixes and submitting changes to new branches. The extension requires Gemini CLI v0.4.0+ and a Jules account connected to a GitHub repository. Installation is via `gemini extensions install <URL> --auto-update`. Usage is through the `/jules` command followed by a prompt.

10/15/2025

This post announces the stable release of Genkit Go 1.0, an open-source AI development framework for Go. It introduces production-ready features including type-safe AI flows using Go structs and JSON schema validation, a unified interface for multiple model providers (Google AI, Vertex AI, OpenAI, Ollama, etc.), support for tool calling, RAG, and multimodal content. It also highlights rich local development tools like a standalone CLI binary and Developer UI. A new command, `genkit init:ai-tools`, is introduced to integrate AI coding assistants (Gemini CLI, Firebase Studio, Claude Code, Cursor) with the Genkit framework.

10/15/2025

Introduced pseudo-terminal (PTY) support to Gemini CLI using the `node-pty` library, enabling the execution of interactive shell commands (e.g., vim, top, git rebase -i) within the CLI's context. Implemented a serializer to capture and stream terminal state (text, color, cursor position) for real-time display. Added capabilities for writing input to the terminal and on-the-fly resizing, ensuring two-way communication and adaptive layouts.

10/8/2025

Introduced the Genkit Extension for Gemini CLI, which provides deep integration between Gemini CLI and Genkit projects. This extension bundles Genkit's MCP (Model Context Protocol) server with specialized context files, giving Gemini CLI a comprehensive understanding of how to work with the Genkit SDKs. It offers Genkit-specific MCP tools (`get_usage_guide`, `lookup_genkit_docs`, `list_flows`, `run_flow`, `get_trace`) for intelligent development assistance, including adding new AI features, debugging applications, and following best practices. The extension integrates with the Genkit Developer UI and supports various providers, with a preference for Google Gen AI.

10/3/2025

Introduces the Jules API, an asynchronous coding agent for automating software development tasks. Key concepts include Sources (e.g., GitHub repos), Sessions (continuous blocks of work), and Activities (individual steps within a session). Provides examples of using the API to fix bugs from Slack and automate backlog triage, along with a quickstart guide and API documentation link.

10/2/2025

Introduces Jules Tools, a command-line interface (CLI) and terminal user interface (TUI) for interacting with Jules, an asynchronous coding agent. Jules Tools enables developers to manage Jules tasks, inspect its operations, and integrate it into their terminal workflows through commands and flags. It supports scripting and composition with other CLI tools, offering a hybrid approach to AI-assisted development.

9/26/2025

Introduces the integration of the Agent Development Kit (ADK) with AG-UI, an open protocol and UI layer for building rich, interactive AI user experiences. This integration enables ADK-powered agents to connect with production-ready frontends using AG-UI and CopilotKit, facilitating features like generative UI, shared state, human-in-the-loop control, and frontend tool interaction. Provides a quick start guide and code examples for setting up an ADK backend with a CopilotKit frontend.

9/25/2025

This post announces the broad availability of Gemini Robotics-ER 1.5, a new state-of-the-art robotics embodied reasoning model. It details the model's capabilities in visual and spatial understanding, task planning, progress estimation, and tool calling. Key new features include fast and powerful spatial reasoning with precise 2D point generation, orchestration of advanced agentic behaviors for long-horizon tasks, flexible thinking budgets for latency vs. accuracy trade-offs, and improved safety filters. The post provides examples of its application in tasks like object sorting, temporal reasoning with video analysis, and orchestrating complex sequences like coffee making, demonstrating its ability to reason about affordances and generate spatially grounded plans.

9/24/2025

Introduced the public release of the Data Commons Model Context Protocol (MCP) Server, a standardized interface for AI agents to access Data Commons' public datasets. This enables faster development of data-rich, agentic applications that reduce LLM hallucinations by supporting exploratory, analytical, and generative data queries. Highlighted a real-world use case with the ONE Data Agent for health financing data. Provided getting started resources including Gemini CLI integration, PyPi package, and ADK sample agent in Colab.

9/22/2025

Introduced integration between Gemini CLI and FastMCP, enabling local STDIO transport MCP servers to be installed via `fastmcp install gemini-cli server.py`. This simplifies the process of making FastMCP server capabilities available within Gemini CLI, automatically handling configuration, dependency management, and calls to Gemini CLI's MCP management system. This integration allows agents to perform actions and access context they would otherwise not have, by defining tools for actions/API interaction and prompts for slash commands.

9/16/2025

This post details the integration of the Agent Development Kit (ADK) for Java with the LangChain4j LLM framework in version 0.2.0. It explains how this integration allows developers to leverage a wide array of third-party and local Large Language Models (LLMs) beyond ADK's built-in Google Gemini and Anthropic Claude. The post provides concrete Java code examples for using Gemma 3 with Docker Model Runner and Qwen 3 with Ollama, demonstrating how to configure ADK agents with these external models via the `LangChain4j` bridge class. It also highlights other new features in the release, such as instance-based `FunctionTools`, improved async support for `FunctionTools`, programmatic control over agent loop execution with `endInvocation`, chained callbacks for agent lifecycle events, and new memory/retrieval services (`InMemoryMemoryService`, `VertexAiRagRetrieval`).

9/9/2025

Introduces A2A Extensions as a mechanism to add custom, domain-specific functionalities to the A2A protocol. Details the 'helloworld' extension for timestamps, a Traceability Extension with `ResponseTrace` and `Step` types (`ToolInvocation`, `AgentInvocation`), Twilio's Latency Extension for voice agents, and Identity Machines' zero-trust handshakes. Mentions Ethereum's proposed ERC-8004 for a trust layer for AI agents.

8/27/2025

This post announces the integration of Gemini CLI into the Zed code editor. It highlights how Gemini CLI's extensibility through standards like MCP, markdown-based instructions, and custom extensions has led to rapid community adoption. The integration with Zed allows for in-place code generation and refactoring, instant code explanations, and natural language chat within the editor's terminal. Key features of this new workflow include real-time agent execution tracking, a pull-request-like review interface for proposed changes, seamless handoffs back to the editor, and the ability to provide context from URLs.

8/21/2025

Gemini 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.

8/13/2025

Introduced integration between Gemini CLI and VS Code, enabling the CLI to access workspace and selected text for context-aware suggestions. Implemented native in-editor diffing for reviewing and modifying suggested code changes directly within VS Code.

7/23/2025

Introduced AI-optimized templates for Flutter, Angular, React, Next.js, and general Web frameworks within Firebase Studio, leveraging Gemini for autonomous agentic development. Enhanced integration with Firebase backend services through natural language prompts, automating library imports and code updates. Added the ability to fork workspaces to create copies of agent chat history for experimentation and collaboration. Increased project upload size to 100MB.

7/16/2025

This post introduces updates to the Agent Development Kit (ADK) that, when paired with the Gemini CLI, aim to eliminate friction in the agent development workflow. Key contributions include a revamped `llms-full.txt` file which is significantly shorter and more LLM-understandable, enabling Gemini CLI to have a deep, native understanding of the ADK framework. This allows for the translation of high-level plans into accurate, idiomatic multi-agent code with unprecedented speed. A practical example demonstrates building an AI GitHub issue labeling agent by ideating the plan with Gemini CLI and then generating the ADK code directly from the plan, showcasing an iterative loop of ideation, generation, testing, and improvement without manual code editing.

7/10/2025

Introduced three distinct modes in Firebase Studio for interacting with Gemini: 'Ask' for conversational planning, 'Agent' for proposing and approving changes, and 'Agent (Auto-run)' for autonomous reasoning and code generation. Added foundational support for the Model Context Protocol (MCP) to allow integration of MCP servers for extending Gemini workflows, such as using the Firebase MCP server for Cloud Firestore data exploration or Context7 for library-specific context. Integrated Gemini CLI directly into Firebase Studio for terminal-based AI-powered tasks like code generation and debugging.

7/10/2025

Introduced GenAI Processors, an open-source Python library designed to structure and simplify the development of complex AI applications, especially those involving multimodal input and real-time responsiveness. GenAI Processors define a `Processor` interface for data handling, pre-processing, model calls, and output processing, treating all input and output as asynchronous streams of `ProcessorParts`. The library optimizes concurrent execution of processors to minimize Time To First Token (TTFT) and integrates with the Gemini API, offering `GenaiModel` and `LiveProcessor` for turn-based and real-time streaming interactions, respectively. Key design principles include modularity, asynchronous/concurrent operations via `asyncio`, extensibility, unified multimodal handling, and stream manipulation utilities.

6/25/2025

This post introduces a research prototype simulating an operating system with a generative, infinite computer experience using Gemini 2.5 Flash-Lite. It details the technical concepts behind on-the-fly UI generation, including conditioning the model with a "UI constitution" (system prompt with rules) and "UI interaction" (JSON object of user actions). It also describes using interaction tracing for contextual awareness, streaming the UI for responsiveness via progressive rendering, and achieving statefulness with an in-memory cache for a generative UI graph. Potential applications like contextual shortcuts and "generative mode" in existing apps are discussed.

5/20/2025

This post announces the stable v1.0.0 release of the Python Agent Development Kit (ADK), marking it as production-ready. It also introduces the initial release of the Java ADK (v0.1.0), extending ADK capabilities to the Java ecosystem. A new Agent Engine UI is available in the Google Cloud console for managing deployed agents, sessions, traces, and monitoring. The Agent2Agent (A2A) protocol has been updated to v0.2, adding support for stateless interactions and standardized authentication. An official A2A Python SDK is now available. The post also highlights growing industry adoption and integrations with partners.

4/9/2025

Introduced the Agent Development Kit (ADK) as an open-source framework for building AI agents and multi-agent systems. ADK offers capabilities across the entire agent development lifecycle, including multi-agent design, a rich model and tool ecosystem, built-in streaming, flexible orchestration, integrated developer experience, built-in evaluation, and easy deployment. It provides Pythonic simplicity for defining agent logic, tools, and information processing, with examples for basic agents and more complex multi-agent systems involving delegation. The post also compares ADK with the Genkit framework, highlighting ADK's optimization for complex agents and multi-agent systems.

4/9/2025

Introduces the Agent2Agent (A2A) protocol, an open standard for AI agent interoperability. Details A2A's design principles (embrace agentic capabilities, build on existing standards, secure by default, support for long-running tasks, modality agnostic) and its technical workings, including capability discovery via Agent Cards, task management with lifecycle and artifacts, collaboration mechanisms, and user experience negotiation. Provides a real-world example of candidate sourcing using A2A and highlights partner contributions.

2/18/2025

This post introduces Langbase, a platform that integrates with Gemini models (specifically Gemini Flash) to build, deploy, and scale AI agents. It highlights the performance benefits of Gemini models for AI agents, including a 1M token context window, 28% faster response times, 50% cost reduction, and 78% higher throughput. Langbase offers a serverless agent development platform with managed semantic RAG and simplifies agent building by bundling infrastructure, agent construction, and model orchestration.

2/13/2025

This post introduces the application of agentic AI principles to Gemma models, demonstrating how to build proactive and autonomous AI systems. It details the use of "Function Calling" to enable interaction with external tools, the "ReAct" prompting style for cycles of reasoning and action, and "Few-shot prompting" to improve model performance. A practical example is provided for creating a dynamic lore generator for a fictional game, showcasing how these techniques can be used to expand Gemma's capabilities beyond its inherent knowledge base.

10/30/2024

This post introduces the integration of the Gemini API with AgentOps, a Python SDK for agent monitoring, LLM cost tracking, and benchmarking. It highlights the cost-effectiveness and performance of Gemini 1.5 Flash for AI agent development, enabling developers to build complex, multi-step agent workflows without prohibitive costs. The post details how AgentOps captures granular data on agent interactions, providing insights for debugging, optimization, and audit trails, and simplifies integration with Gemini models via LiteLLM.

7/17/2024

Introduces Project Oscar, an AI Agent reference for open-source project maintenance, and an early look at AI-generated UI for Flutter. Also highlights the Firebase AI Monitoring dashboard and the AI Testing Agent in Firebase App Distribution.

6/26/2024

This post details the technical implementation of the I/O Crossword game, showcasing the integration of Gemini API for topical content generation and a hint feature via Firebase Genkit. It highlights the use of Flutter for interactive UI and WASM compilation for performance, and Firebase for hosting, real-time data storage (Firestore), and security (App Check, anonymous auth). Dart Frog and Cloud Run are used for backend logic and autoscaling. The post also mentions the Gemini app for content creation and the Gemini API Dev Competition.

5/15/2024

Introduced Firebase Genkit, an open-source framework for building AI features in applications. Key features include a CLI and developer UI for testing and iteration, 'flow' primitive for observable end-to-end AI workflows, and the 'dotprompt' file format for managing prompts, models, and configurations. Demonstrated its use in the Compass app for generating embeddings with pgvector and text-embedding-gecko API, implementing semantic search with a retriever, and deploying to Cloud Run. Highlights the integration with Google Cloud, Firebase, and Vertex AI plugins.