ADK-Rust: a 43-crate agent framework for Rust teams that want their agent runtime to be Rust
Rust Agent Development Kit (ADK-Rust): Build AI agents in Rust with modular components for models, tools, memory, realtime voice, and more. ADK-Rust is a flexible framework for developing AI agents with simplicity and power. Model-agnostic, deployment-agnostic, optimized for frontier AI models. Includes support for real-time voice agents.
At a glance
- What is it?
- ADK-Rust is a Rust agent development kit covering models, tools, memory, graphs, realtime voice and deployment. It ships as a workspace of publishable crates, so the first decision is not whether to use it but how much of it to pull in.
- Who is it for?
- Adopt ADK-Rust if your agent runtime has to live inside a Rust service and you want orchestration, checkpoints and a runtime UI in the same language as the rest of the process. Do not adopt it if you want a Python-first agent stack, or if a single-file script with an LLM call is enough.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository last received commits 3 days ago.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 29, 2026, and from our analysis. They are not legal advice.
Editorial analysis
What ADK-Rust is for, and who ends up using it
ADK-Rust targets engineers who have already decided the agent loop belongs in the same process and language as the service around it. The README frames the project as "a production-ready Rust framework for building AI agents", model-agnostic, type-safe and async, spread across 43 publishable crates for agent orchestration. That crate count is the real shape of the product. There is no single monolith to adopt; there is a workspace where models, tools, memory, sessions, artifacts, graphs, guardrails, payments and voice each live in their own package.
The audience is narrower than "anyone building an agent". If your agent is a Python notebook that calls a model and prints a string, nothing here helps. The fit is a team that needs checkpoints that survive a process restart, tool calls with approval boundaries, and a server it can deploy. The README's own framing of v2.0.0, "Agents That Act", points the same way: workflows that resume where they stopped, graphs that change course, approvals bound to a digest.
One practical consequence of the crate split is that a first-time reader has to choose a level. The umbrella `adk-rust` crate exists, and the README shows it as the drop-in for an existing project. Individual crates such as `adk-agent`, `adk-model` or `adk-graph` are the alternative when you want a smaller dependency graph. The project does not hide this, but it also does not pick for you.
How the workspace is put together: models, runners, graphs, sessions
The architecture visible in `Cargo.toml` is a layered workspace. `adk-core` sits at the bottom, with `adk-rust-macros` beside it. Above that come the pieces an agent actually touches: `adk-model` for provider access, `adk-tool` for callable tools, `adk-agent` for agent definitions, `adk-runner` for execution, and `adk-session` plus `adk-artifact` and `adk-memory` for state that outlives a single turn. `adk-server` exposes the runtime over HTTP, which is what the five-minute quickstart drives.
Provider coverage is deliberately broad rather than deep in any one direction. The workspace includes `adk-gemini`, `adk-anthropic`, `adk-gcp` and `adk-mistralrs` for local inference, and `.env.example` lists keys for Google Gemini (marked as the default provider), OpenAI, Anthropic, DeepSeek, Groq, OpenRouter, Fireworks AI, Together AI, xAI, Mistral AI, Perplexity, Cerebras and SambaNova, plus Azure OpenAI, Azure AI Inference and AWS Bedrock credentials. That file is the honest map of what the framework expects to talk to.
Two orchestration surfaces coexist: a workflow style and a graph style. `adk-graph` handles nodes, edges, subgraphs and runtime routing, and v2.2.0 adds native tool confirmation pauses to graph workflows. The README's episode notes say the project kept two orchestration APIs where other ADKs deprecated one, and that is a deliberate cost: more surface to learn, in exchange for not being forced into a rewrite when a workflow outgrows a linear shape. v2.2.0 also fixes tracing so one invocation exports as one trace instead of several disconnected ones, which suggests the earlier behaviour was a real annoyance in production.
Installing ADK-Rust and running a first agent with cargo-adk
The README's quickstart is a scaffold, not a library snippet. The `cargo-adk` CLI generates a project from a template and a provider, and the generated project reads its key from `.env`. The README gives this sequence for an OpenAI-backed agent with the HTTP runtime and embedded UI:
cargo install cargo-adk
cargo adk new quickstart_agent --template api --provider openai
cd quickstart_agent
cp .env.example .env
# Open .env and replace the OPENAI_API_KEY placeholder, then:
cargo runAfter `cargo run`, the README says to open `http://127.0.0.1:8080/ui/`, enter a prompt and press Enter. The UI creates the session, streams the run, renders Markdown and tool results, animates the active agent or workflow edge, and keeps the event timeline, state, artifacts and telemetry beside the conversation. The generated single-agent project uses the same UI with a one-node graph; the animation in the README comes from a richer team example.
The README also gives an independent check that the server is up, which is worth running before you debug anything in the UI:
curl -fsS http://127.0.0.1:8080/api/healthIf you are adding ADK-Rust to a project that already exists rather than scaffolding, the README shows the dependency line directly:
[dependencies]
adk-rust = "2.2.0"The repository pins a minimum toolchain of Rust 1.95 in its README badge, so an older stable will not build the workspace. The README points to `docs/official_docs/quickstart.md` for an explanation of the generated files and a console-only alternative, and to the `runtime_ui_showcase` example for a version with tool, graph and team agents.
Where ADK-Rust stops being the right tool
The project is candid about at least one gap, and it is worth repeating because it changes deployment planning. In the v2.0.0 episode notes, under "What It Costs", the project lists no automatic crash recovery and an unbounded child ledger. Checkpointing lets a paused or stopped workflow resume from a SQLite checkpointer in a fresh process that shares only the database file, but that is resume-from-checkpoint, not supervision. If a node panics or the host dies mid-run, the framework does not promise to notice and restart it. You build that layer, or you accept that a run can end without a terminal state.
The unbounded child ledger is the second constraint. Spawning sub-agents is cheap to write and, per those notes, not bounded by the framework. Long-lived or recursive delegation is therefore a resource decision you own, not one the runtime enforces for you.
The 2.0 migration is a third boundary. The README states that six APIs changed shape and that the fan-in default changed behaviour without an API change. A behaviour change that does not break compilation is the kind that surfaces in production rather than in CI, so anyone upgrading from 1.x should read `docs/official_docs/migration/1.0-to-2.0.md` before bumping the version.
Finally, the crate count cuts both ways. Forty-three publishable crates plus a local-inference member with separate GPU build targets mean a build that is heavier than a single dependency. The `Makefile` separates plain builds from feature-specific ones for OpenAI, Anthropic and Ollama, and from `adk-mistralrs` builds with Metal or CUDA, which tells you the default build is not the one that pulls in local inference.
ADK-Rust versus Rig and other Rust agent libraries
The comparison people search for is ADK-Rust against Rig. The difference in approach is scope and structure. Rig is a Rust library for building LLM-powered applications, and it is typically adopted as a dependency you compose with your own application code. ADK-Rust is a workspace of 43 crates with an agent runtime at the centre: a runner, sessions, artifacts, memory, a graph engine with subgraphs and runtime routing, a server with an embedded UI, guardrails, evaluation, sandboxing and deployment crates. Choosing between them is closer to choosing between a library and a platform than between two libraries.
That also means ADK-Rust carries more opinion. It expects you to work with agents, sessions and runs as first-class objects, and its quickstart generates a project rather than showing a minimal call. If you want to embed a model call and a couple of tools inside an existing service with the smallest possible footprint, a library-shaped option fits better. If you want checkpointed workflows, approval interrupts bound to a digest, and a runtime UI you can hand to someone who is not reading the source, the ADK-Rust shape is the point.
The name is a second source of confusion. ADK-Rust is explicitly a Rust counterpart to Google's Agent Development Kit, and the workspace contains `adk-gemini` and `adk-gcp` alongside a `gemini-agent-platform` consumption path for Vertex AI RAG Engine retrieval, Agent Registry discovery and remote ReasoningEngine agents. Being Gemini-compatible is not the same as being Gemini-only: the provider list in `.env.example` runs well past Google.
Maintenance, versioning and what the licence actually says
The repository is not archived, and the last push was on 2026-09-08. Releases have been frequent and close together: v2.0.0 on 2026-08-17, v2.1.0 on 2026-08-25, and v2.2.0 on 2026-09-01. v2.2.0 is described as an API-compatible minor release, and the project has been semver-stable since 1.0.0 according to its own episode notes. That is a good sign for upgrade cost, with one caveat already noted: the 1.x to 2.x jump changed six APIs and one default.
The licence field on the repository is NOASSERTION, which means the platform could not classify it automatically. The README badge and the repository's `LICENSE` file both point to Apache 2.0, and the badge links to that file. If you need certainty for a redistribution or a patent grant question, read `LICENSE` yourself rather than trusting the badge; this is a packaging detail, not a legal opinion.
Upgrade cost in practice is dominated by the workspace rather than by any single crate. Because the crates are published individually to crates.io, a version bump can move several of them at once, and the README's own note that all 43 crates are available at 2.2.0 suggests they are released in lockstep. `STABILITY.md` and `CHANGELOG.md` are the two files to read before a bump. The repository also carries `SECURITY.md` and `ROADMAP.md`, and the README links a migration guide specifically for the 1.0-to-2.0 transition.
Editorial conclusion
Adopt ADK-Rust if your agent runtime has to live inside a Rust service and you want orchestration, checkpoints and a runtime UI in the same language as the rest of the process. Do not adopt it if you want a Python-first agent stack, or if a single-file script with an LLM call is enough. Before committing, verify the crate split against your dependency budget, read STABILITY.md and the 1.0-to-2.0 migration guide for the six APIs that changed shape, and confirm the fan-in default change, which the README says altered behaviour without an API change.
Frequently asked questions
What does ADK stand for in ADK-Rust?
ADK stands for Agent Development Kit. The repository topics include agent-developer-kit, and the project is presented as a Rust counterpart to Google's Agent Development Kit, with a google-adk-rust topic on the repository.
How do I use ADK-Rust to create my first agent?
Install the CLI with cargo install cargo-adk, then run cargo adk new quickstart_agent --template api --provider openai. Copy .env.example to .env, replace the OPENAI_API_KEY placeholder, run cargo run, and open http://127.0.0.1:8080/ui/ to prompt the agent.
Is ADK-Rust the same as Google ADK?
No. ADK-Rust is a separate Rust framework from zavora-ai that is model-agnostic and lists providers including OpenAI, Anthropic, DeepSeek and Groq in its environment template. It does include Gemini and Google Cloud crates, and v2.2.0 completes a Gemini Enterprise Agent Platform consumption path.
Which Rust version does ADK-Rust require?
The README badge states Rust 1.95 or newer. The workspace also uses resolver 3, so an older toolchain will not build it.
Can ADK-Rust resume an agent run after the process stops?
The v2.0.0 episode notes describe SQLite checkpointers and delta checkpoints, with a pause that resumes in a fresh process that shares only the database file. The same notes list no automatic crash recovery as a cost, so resuming from a checkpoint is supported but supervising a crashed run is not.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/zavora-ai-adk-rust)