ADK-Rust gives developers a typed runtime for model calls, tools, memory, multi-agent workflows, realtime voice, and open agent protocols. Start with one agent and add the capabilities your product needs.
An ADK-Rust agent is an async Rust component. The Runner gives it the request and session context, the agent can call typed tools, and your interface receives structured events while the work is happening.
One agent turn
Follow the sequence
Stage 01 · Request
request.rs
Rust runtime
The application starts one agent turn.
The user, session, and message travel together. That gives the Runner enough context to continue an existing conversation or begin a new one.
let events = runner
.run_str(
"user-42",
"session-1842",
"Where is order 1842?",
)
.await?;
Event emitted
message.receiveduser-42 · session-1842 · Where is order 1842?
Choose how the work runs
Flexible execution models for every agent.
A conversational assistant, a controlled workflow, a live voice experience, and a coding agent have different operating needs. ADK-Rust gives each one a dedicated agent type while keeping the same Runner, tools, sessions, events, and production services around it.
When to use it
Let one agent reason, answer, and choose tools.
Use an LLM agent when the next step depends on the user’s request. Instructions define its role, typed tools give it actions, and the Runner streams each event to your application.
Good fit for
Support assistants, research agents, internal copilots, and product features that combine conversation with actions.
01Request
02LlmAgent
03Model + tools
04Typed events
llm_agent.rsTyped Rust
let agent = LlmAgentBuilder::new("support")
.model(model)
.instruction("Help the user and call tools when useful.")
.tool(Arc::new(LookUpOrder))
.build()?;
Runner::builder()
.agent(Arc::new(agent))
.session_service(sessions)
.build()?;
One composable runtime
Build an Agent System
Models are one part of an agent product. ADK-Rust keeps execution, tools, state, interfaces, and operating controls in clear layers so developers can replace a provider or service without rewriting the agent contract.
Product interfaces
People
Web, mobile, voice
The interfaces where people ask, review, and approve.
Agents
A2A, ACP, AWP
Structured interfaces for remote agents, coding agents, and websites.
Services
REST, SSE, WebSocket
Application APIs and live event delivery.
ADK-Rust Runner
Invocation context · session · typed event stream
Reason
LLM and custom agents
Flexible decisions backed by typed Rust behavior.
Coordinate
Workflows and graphs
Sequential, parallel, loop, conditional, and durable work.
Interact
Realtime agents
Bidirectional audio, video, transcription, and tools.
Execute
Coding and CodeAct
Bounded software and code-execution workflows.
Act
Tools + MCP
Typed actions and external capabilities.
Remember
State + RAG
Sessions, memory, artifacts, and knowledge.
Operate
Policy + telemetry
Authorization, approval, audit, and evaluation.
Replaceable services
Models
OpenAI, Gemini, Anthropic
Choose providers per agent and workload.
State
Memory and storage
In-memory, database, vector, graph, and artifact backends.
Production
Auth and observability
Security, secrets, policy, traces, evaluation, and deployment.
Choose the AI agent framework that fits your system.
Every framework below can call models and tools. The important differences appear when an agent must coordinate work, recover after an interruption, hold a live conversation, connect through open protocols, and operate as production software.
ADK-Rust advantages
Build the complete agent system in Rust.
Native runtime in Rust
The agent, workflow, tools, state, and server compile into the same type-safe system.
Protocol breadth
The reviewed framework documents MCP, A2A, ACP, and AWP together, with client and server roles where the protocol supports them.
Realtime with multiple providers
OpenAI Realtime and Gemini Live share one realtime agent model with tools and media events.
Modular production capabilities
Feature tiers let a team compile only the runtime, state, protocols, and operating controls it needs.
Strengths of other frameworks
The right choice still depends on your stack.
Google ADK
Broadest language coverage and a strong Google Cloud path.
LangGraph
Deep, well-documented graph persistence, recovery, replay, and time travel.
Microsoft Agent Framework
Distributed durable workflows and Microsoft enterprise integration.
OpenAI Agents SDK
The most direct route to OpenAI-native agents, voice, tools, and tracing.
CrewAI
Approachable role-based teams and flow-first orchestration for Python developers.
PydanticAI
Excellent Python validation ergonomics and mature durable-engine integrations.
Mastra
A broad TypeScript product toolkit with strong Studio, memory, voice, and deployment options.
Capability matrix
Compare documented framework capabilities.
Built inOfficial integrationPlatform or extensionPreview
ADK-Rust comparison with seven leading AI agent frameworks, reviewed in August 2026.
MCP plus A2A for exposing and consuming remote agents.
Official integration
MCP clients and MCP/A2A exposure through Agent Server.
Built in
MCP, A2A, and AG-UI integrations.
Official surface
MCP is documented in depth; A2A is advertised in the official surface.
Preview surface
MCP client/server plus experimental ACP server support in Harness.
Built in
MCP client/server, A2A client/server, and ACP coding-agent clients.
Production lifecycleWhat ships with the framework?
One modular workspace
Sessions, memory, artifacts, RAG, auth, guardrails, evaluation, and OpenTelemetry.
Built in
Sessions, guardrails, approvals, and tracing; your application owns storage and deployment.
Built in
Sessions, memory, artifacts, evaluation, and observability with Google Cloud options.
Core plus platform
Persistence is core; LangSmith adds tracing, evaluation, deployment, and operations.
Built in
Sessions, memory providers, middleware, evaluation, and OpenTelemetry.
Core plus platform
Memory and checkpoints in core; AMP adds tracing, RBAC, SSO, and deployment.
Built in
Validated outputs, evaluation, and OpenTelemetry; deployment remains application-owned.
Built in
Memory, evaluation, observability, Studio, and deployment adapters.
Deployment modelWhere can it run?
ADK-Rust advantage
A feature-tiered native binary for cloud, self-hosted, edge, and constrained environments.
Application-owned
Deploy the Python or TypeScript application on your infrastructure.
Cloud leader
Managed Agent Runtime, Cloud Run, GKE, or a portable container.
Server plus platform
Agent Server for self-hosting and LangSmith for managed operations.
Broad hosting
Foundry, Azure Functions, containers, Kubernetes, or self-hosted services.
Core plus platform
A self-hosted Python service or the AMP deployment platform.
Application-owned
Deploy a Python application and choose its durable execution backend.
Web-runtime leader
Node.js, Bun, Deno, Cloudflare, serverless platforms, or a standalone server.
Scroll horizontally to compare every framework. The capability and ADK-Rust columns remain visible.
Method, definitions, and primary sources
This is a documentation review dated 3 August 2026, not an exhaustive catalog. “Built in” means the capability is part of the documented framework surface. “Official integration” and “platform or extension” identify features supplied through an official companion. “Not in reviewed core” means no equivalent native surface was found in the official documentation reviewed; it does not mean a custom integration is impossible.
We do not claim a performance, security, cost, or maturity winner without comparable public benchmarks. Preview and experimental features are labelled. Hosted vendor services are separated from open-source framework capabilities where the documentation makes that boundary clear.
Your Rust process can own local tools and sub-agents directly. When another team, service, agent, coding environment, or website owns the capability, an open protocol gives both sides a stable contract.
Create an agent project, compile it, and run it locally.
The CLI starts from a working template. Choose the agent shape first, then add tools, sessions, telemetry, guardrails, realtime media, RAG, or protocols when the project needs them.
