Google ADK

Supports composition of specialized agent types (LoopAgent, SequentialAgent, ParallelAgent) that can be nested and orchestrated together. Each agent type implements a distinct execution pattern: LoopAgent iterates until exit conditions, SequentialAgent chains agents linearly with state passing, and ParallelAgent executes multiple agents concurrently. The framework manages state hierarchy, context propagation, and inter-agent communication through an InvocationContext that tracks execution scope and agent relationships.

Enables agents to request structured outputs by defining JSON schemas that are passed to LLM providers with native support for structured outputs (Anthropic's json_mode, OpenAI's response_format with JSON schema, Vertex AI's structured output). The framework handles schema validation, response parsing, and fallback to text parsing when provider doesn't support structured outputs natively. Schemas are defined as Pydantic models or raw JSON schemas and automatically converted to provider-specific formats.

Implements comprehensive telemetry collection through tracing (execution traces with timing and error information) and BigQuery analytics (sends execution events to BigQuery for analysis). Traces capture agent invocations, tool calls, LLM requests, and latencies. BigQueryAnalyticsPlugin automatically sends execution telemetry to BigQuery tables for querying and analysis. Integrates with standard observability patterns and supports custom telemetry collection through plugin system.

Supports defining agents through configuration files (YAML or JSON) rather than code, enabling non-developers to configure agents. Agent configuration files specify agent type, LLM provider, tools, instructions, and execution parameters. The framework parses configuration files and instantiates agents at runtime. Supports configuration inheritance and templating for reusable configurations. Enables rapid iteration on agent behavior without code changes.

Implements context caching at the framework level to reduce costs and latency for repeated agent invocations with similar context. Caches are created for frequently-used context (system instructions, knowledge bases, tool definitions) and reused across invocations. Supports provider-specific caching (Anthropic prompt caching, Vertex AI cached content) and framework-level caching. Automatically manages cache lifecycle and invalidation.

Provides deployment templates and configuration management for deploying agents to Google Cloud infrastructure (Cloud Run, Vertex AI Agent Engine, GKE). The framework handles containerization, environment configuration, and service setup. Deployment configurations specify resource requirements, scaling policies, and environment variables. The framework supports blue-green deployments and canary releases through configuration.

Abstracts LLM provider differences through a BaseLlm interface that normalizes request/response handling across OpenAI, Anthropic, Vertex AI, and Ollama. The framework handles provider-specific features (function calling schemas, structured output formats, caching mechanisms) transparently. Agents can switch providers through configuration without code changes. The framework manages API key rotation, rate limiting, and fallback providers.

Provides a unified tool abstraction that supports multiple tool sources: Python functions decorated with @tool, OpenAPI/REST specifications parsed into callable tools, Model Context Protocol (MCP) servers for standardized tool interfaces, and native BigQuery tools for data querying. Tools are registered in a schema-based function registry that generates provider-specific function calling schemas (OpenAI function_calling format, Anthropic tool_use format). The framework handles tool authentication, parameter validation, and execution with optional human-in-the-loop confirmation.

Manages agent execution state through a session system that persists all events (agent invocations, tool calls, LLM responses) to a database. Sessions support resumability — interrupted executions can be resumed from the last checkpoint without re-running completed steps. The framework implements event compaction to reduce storage overhead and session rewind to replay execution from specific points. State is organized hierarchically with parent-child relationships between agents, and the database session service handles concurrent access and state consistency.

Provides a plugin architecture that intercepts agent and tool execution at multiple lifecycle points through callback hooks. Plugins implement BasePlugin interface and register callbacks for events like before/after agent invocation, before/after tool execution, on LLM responses, and on errors. The PluginManager chains multiple plugins and ensures callbacks execute in order. Built-in plugins include GlobalInstructionPlugin (injects instructions into all agent prompts), LoggingPlugin (logs execution events), and BigQueryAnalyticsPlugin (sends telemetry to BigQuery). Plugins can modify execution flow, inject context, or collect observability data.

Abstracts multiple LLM providers (OpenAI, Anthropic, Vertex AI, Ollama) behind a BaseLlm interface that handles request/response processing, streaming, and provider-specific features. Supports streaming responses with token-by-token delivery, context caching (Anthropic's prompt caching, Vertex AI's cached content) to reduce latency and costs for repeated context, and live streaming for real-time interactions. The framework manages provider-specific request formatting, response parsing, and error handling. Function calling requests are translated to each provider's native format (OpenAI function_calling, Anthropic tool_use).

Provides an evaluation system for testing agent behavior through evaluation sets (collections of test cases), metrics (quantitative measures of agent performance), and user personas (simulated users for testing). Evaluation cases define inputs, expected outputs, and success criteria. The framework supports conformance testing to verify agents meet specifications and includes built-in metrics for common scenarios. Evaluations can be run against agents to measure performance, and results are stored for comparison across versions.

Provides a FastAPI-based web interface for developing and debugging agents locally. The UI visualizes agent execution including function calls, LLM responses, and state transitions. Developers can inspect function call parameters and results, trace execution flow through multi-agent hierarchies, and replay execution from specific points. The UI connects to the agent runtime via API endpoints and provides real-time execution monitoring. Includes CLI commands for starting the development server and managing recordings/replays.

Implements a protocol for agents to communicate with and invoke other agents directly. Agents can call other agents as tools, passing structured inputs and receiving structured outputs. The protocol handles agent discovery, request routing, and response formatting. Supports both local agent invocation (same process) and remote agent invocation (via API). Enables building agent networks where agents can delegate tasks to specialized agents.

Provides deployment configurations and utilities for deploying agents to Google Cloud Platform. Supports deployment to Vertex AI Agent Engine (managed agent service), Cloud Run (containerized agents), and GKE (Kubernetes). The framework includes deployment configuration templates, Docker image building utilities, and environment setup scripts. Handles credential management, service account configuration, and API enablement for deployed agents.