中文
AI Tools / ai-coding

ADK-Rust

Reviewed by AIX Cove ·
ADK-Rust
ai-coding

ADK-Rust at a glance

ADK-Rust is a Rust framework for building AI agents, published by the zavora-ai community under an Apache-2.0 license. The name overlaps with Google's Agent Development Kit, but the two are separate projects. Google's ADK is Python; ADK-Rust is a community framework that targets the same jobs with Rust's type system.

I checked the repository, the docs, the wiki, and the discussions before writing this. The project is genuinely active. Version 2.0.0 shipped recently, the repo gets commits almost daily, and it sits at roughly 615 stars and 92 forks as of August 2026. That is a small community next to LangGraph or CrewAI, and it shows in the documentation, which is detailed but still catching up with new features.

What it actually gives you

The framework is organized into 42 crates behind one umbrella dependency. You pick a feature tier (minimal, standard, enterprise, full) and add individual crates on top. The parts people actually use:

  • Typed tools: a #[tool] attribute derives the JSON schema from your Rust argument types, so the model gets the right contract without hand-written schemas.
  • Graph workflows: LangGraph-style orchestration with subgraphs, dynamic routing, per-node retries and timeouts, and SQLite checkpointing. An interrupted run resumes from the same database file, even in a fresh process.
  • Model coverage: Gemini, OpenAI, Anthropic, DeepSeek, Groq, Ollama, Bedrock, and Azure AI, plus OpenAI-compatible presets for Fireworks, Together, Mistral, Perplexity, Cerebras, SambaNova, and xAI. Local inference runs through Ollama or the mistral.rs crate.
  • Realtime voice: OpenAI Realtime and Gemini Live with bidirectional audio, VAD, and video frames.
  • RAG and memory: chunking, embeddings, and vector search across six backends, plus a memory layer with a bi-temporal knowledge graph.
  • Servers and protocols: REST with SSE, A2A v1.0, MCP client and server support, background runs, and cron.
  • Ops extras: guardrails, RBAC with SSO, audit logging, OpenTelemetry tracing, an evaluation framework, browser automation, and sandboxed code execution.

The project publishes its own performance numbers: about 568 microseconds of agent-loop overhead per turn against 1,228 milliseconds for LangGraph in its June 2026 benchmark, with a 109 ms cold start. Treat those as vendor-measured until you reproduce them on your own workload. The tooling to do that ships with the framework (cargo adk bench).

Typical workflow

Setup is one install command, then a scaffold:

  • cargo install cargo-adk adds the cargo-adk subcommand.
  • cargo adk new my-agent --template rag scaffolds a project. Templates exist for llm, tools, sequential, parallel, loop, conditional, graph, realtime, rag, and api, plus pre-composed patterns like production, multi-agent, pipeline, chatbot, and a2a-server.
  • --addon composes extras such as telemetry, auth, sessions, memory, mcp, guardrails, eval, or browser with any template.
  • Add your API key to .env, then cargo run.

A typical first build looks like this. Scaffold with the tools template, define two or three #[tool] functions, point the model at your provider, and serve it over HTTP with the api template once the agent behaves. Provider swapping is deliberate. The agent, runner, and tools stay unchanged when you swap the client, so a Gemini prototype can move to Anthropic or a local Ollama model without rewriting the agent.

Where it fits

ADK-Rust earns its keep for teams already writing Rust that want a typed, self-hosted agent layer. Good fits:

  • Voice or realtime products that need low startup latency and tight control over the loop.
  • Workflows that must survive restarts, where SQLite checkpointing and durable resume matter.
  • Teams that want MCP-native tooling and protocol support (A2A, ACP) rather than vendor lock-in.
  • Anyone who wants local models via Ollama or mistral.rs in the same codebase as cloud models.

Weak fits: teams that do not write Rust, anyone optimizing for the largest ecosystem and community, and teams that want a managed runtime with support. The Python ADK, LangGraph, or CrewAI remain the lower-friction paths for most shops. If what you actually need is a coding agent, a product like OpenCode or Qwen CLI beats assembling one from framework parts.

Practical tips

  • Start with the minimal tier. The default feature set builds faster and keeps the dependency tree small. Add features like audio or browser only when the job needs them. A tier is a starting point, not a ceiling.
  • Pick the template by the job. rag for retrieval, graph for multi-step durable work, realtime for voice, api for serving. The scaffold code is a better starting point than a blank main.rs.
  • Use #[tool] metadata. Mark functions read_only, concurrency_safe, or long_running so the runner can parallelize or warn correctly instead of guessing.
  • Checkpoint every graph you care about. SQLite checkpoints plus a RetentionPolicy keep a week-long run steady. Without a retention policy, checkpoints accumulate without bound.
  • Validate before you deploy. cargo adk validate checks an agent definition without a full build, and cargo adk bench --dry-run shows the cost estimate before you pay for real API calls.
  • Pin model availability. The README warns that gemini-2.0-flash and gemini-2.0-flash-lite shut down on 31 March 2026. Model names and shutdown dates move, so keep your provider table in one place.

Limits and risks

  • Young project, small community. Around 615 stars and 13 open issues. Discussions are mostly technical Q&A, and several threads are people hunting for features the docs have not fully caught up with, the DeepSeek client thread being a good example.
  • Docs lag the code. The wiki, guides, and docs.rs are thorough, but the project moves fast. Expect to read source or open a discussion for bleeding-edge features.
  • Vendor benchmarks. The 568 microsecond loop figure and the 4,300+ test count are the project's own measurements. Re-run with your workload before quoting them in a decision.
  • Experimental corners. The managed agent runtime does not survive process loss, the Windows sandbox backend (AppContainer) is not implemented, and agentic payments are brand new. Read the stability tiers in STABILITY.md before building on any of these.
  • Version churn. Upgrading from 1.x to 2.0 changed six APIs and one default behavior. Budget time for migrations on major bumps.

Pricing and licensing

ADK-Rust itself is free under Apache-2.0. Your real costs are model API keys (Gemini by default, others per provider) or local hardware for Ollama and mistral.rs, plus whatever infrastructure runs the agent. There is no hosted version, no usage limit, and no vendor lock-in beyond the API keys you choose.

Related tools on AIXCove

Sources and further reading

Sources: official docs & pricing pages, hands-on testing where noted, and community feedback. Prices verified August 2026 and may change.