Google ADK

Orchestrates multiple agent types (LoopAgent, SequentialAgent, ParallelAgent) in hierarchical compositions using a BaseAgent abstract class with pluggable execution strategies. Agents communicate through InvocationContext, which maintains execution state, session data, and event history across the agent tree. The framework uses a Runner abstraction to execute agents with callback hooks at each lifecycle stage (pre-execution, post-execution, error handling), enabling introspection and dynamic control flow.

Enforces structured output by accepting JSON schema definitions that are passed to LLM providers (OpenAI, Anthropic, Vertex AI) with provider-specific formatting. The framework abstracts provider differences through a BaseLlm interface that normalizes schema handling, response parsing, and validation. Responses are automatically parsed and validated against the provided schema, with fallback error handling for malformed outputs.

Provides a web-based development interface for testing and debugging agents in real-time. The UI visualizes agent execution including LLM calls, tool invocations, and responses. Developers can inspect function call details, view streaming responses, and manually trigger tool calls. The UI integrates with the FastAPI server and provides endpoints for agent invocation, session management, and execution history retrieval.

Exposes agents as REST APIs through a FastAPI server with endpoints for agent invocation, session management, execution history retrieval, and artifact storage. The server handles request/response serialization, session routing, and error handling. Endpoints support both synchronous and asynchronous invocation, streaming responses, and session resumption. The server integrates with the development web UI and provides a foundation for production deployments.

Integrates distributed tracing (OpenTelemetry) and analytics (BigQuery) to provide observability into agent execution. The framework automatically instruments LLM calls, tool invocations, and state changes with trace spans. Traces are exported to tracing backends (e.g., Jaeger, Cloud Trace). The BigQuery analytics plugin automatically logs execution events to BigQuery for analysis and reporting. This enables monitoring agent performance, debugging issues, and analyzing usage patterns.

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 layer that supports multiple tool types: Python functions (via decorators), MCP (Model Context Protocol) servers, OpenAPI/REST endpoints, and BigQuery operations. Tools are registered in a schema-based registry that generates function calling schemas compatible with LLM providers. The framework handles tool invocation, authentication, confirmation workflows (HITL), and error handling through a common Tool interface.

Manages agent session state through an event-sourcing pattern where all agent actions (tool calls, LLM invocations, state changes) are recorded as immutable events in a database. Sessions can be resumed from any point in the event history, enabling session rewind and replay. The framework provides a DatabaseSessionService that persists session state to a database backend, with support for state hierarchy (global, agent-level, tool-level state) and event compaction for performance.

Implements context caching at the LLM provider level (OpenAI, Anthropic, Vertex AI) to reduce token costs and latency in multi-turn conversations. The framework automatically manages cache keys based on conversation history and system prompts, and reuses cached context across multiple invocations. Cache invalidation is handled transparently when context changes, with provider-specific caching strategies (e.g., Anthropic's prompt caching vs OpenAI's cache_control).

Provides a plugin architecture that allows intercepting agent execution at multiple points: before/after LLM calls, before/after tool calls, on errors, and on state changes. Plugins implement a BasePlugin interface and are registered with a PluginManager that coordinates their execution. Built-in plugins include logging, global instruction injection, and BigQuery analytics. Plugins can modify agent behavior (e.g., injecting instructions) or observe execution (e.g., logging, tracing).

Allows defining agent configurations in YAML files with support for environment variable substitution, enabling declarative agent setup without code changes. Configuration files specify agent type, LLM provider, tools, instructions, and execution parameters. The framework parses YAML configs and instantiates agents with the specified configuration, supporting config inheritance and composition. This enables non-technical users to modify agent behavior through configuration files.

Supports streaming LLM responses and tool outputs in real-time, enabling live interactions where users see agent progress as it happens. The framework handles streaming at the LLM provider level (OpenAI, Anthropic, Vertex AI) and aggregates streamed chunks into complete responses. Streaming is integrated with the event system, so streamed events are recorded in session history. The framework provides callbacks for handling streamed chunks, enabling custom UI updates or real-time logging.

Provides a framework for evaluating agent behavior through evaluation sets (collections of test cases), metrics (accuracy, latency, cost), and user personas (different user types with different expectations). Evaluation cases define expected outputs and success criteria. The framework runs agents against evaluation sets and computes metrics, enabling quantitative assessment of agent quality. Conformance testing validates that agents meet specified requirements (e.g., response time < 2s, cost < $0.10).

Implements a protocol for agents to communicate with other agents through a standardized message format. Agents can invoke other agents as tools, passing requests and receiving responses. The A2A protocol handles serialization, routing, and error handling transparently. This enables building complex multi-agent systems where agents can delegate work to specialized sub-agents without explicit orchestration code.