ADK-Rust: The Publishable Agent Framework
ADK-Rust is the clearest framework-first entry in this repo set. It is not a finished coding agent product with one signature UI. It is a multi-crate Rust workspace for building agents, servers, tools, workflows, browser automation, realtime interfaces, and payment-aware systems. The interesting story is how much of that surface is exposed as publishable crates instead of being trapped inside one app.
What ADK-Rust Actually Is
The first thing to get right is category. ADK-Rust is not trying to be
Claude Code, OpenCode, or Codex CLI. The root
Cargo.toml declares
34 workspace members, and the umbrella crate
adk-rust mainly re-exports lower layers such as
adk-core, adk-agent, adk-model,
adk-tool, adk-runner, and
adk-server. This repo is closer to a publishable
framework ecosystem than to a single CLI persona.
That changes how it should be judged. The question is not "is the TUI nice?" The question is whether the crates give you a coherent agent foundation you can assemble into your own product or service.
| Layer | Primary crates | Role |
|---|---|---|
| Core contracts | adk-core, adk-agent |
Agent, tool, event, session, and LLM interfaces |
| Runtime |
adk-model, adk-runner,
adk-session
|
Provider access, execution loop, state, history, compaction |
| Extensions |
adk-tool, adk-browser,
adk-graph, adk-realtime
|
Tools, browser automation, graph workflows, voice interfaces |
| Protocol and deployment |
adk-server, adk-awp,
awp-types, adk-payments
|
A2A services, AWP routes, commerce adapters, web exposure |
| Developer UX | cargo-adk, adk-rust |
Scaffolding and feature-tier packaging |
Feature Tiers Are the Real Product Boundary
The umbrella crate's feature table is more informative than any README
summary. The actual default is minimal, which pulls in a small starter stack around agents, models, Gemini,
runner, and sessions. Higher tiers then widen the framework.
Minimal
Default starter tier. No assumption that every build needs tools, auth, MCP, or server code on day one.
Standard
Adds the broader agent stack: OpenAI, Anthropic, graph workflows, server, auth, eval, plugins, artifacts, memory, telemetry, tools.
Enterprise
Adds browser automation, realtime, RAG, payments, and AWP. This is where the framework starts to feel platform-sized.
Full
Adds audio, code execution, and sandboxing. The repo keeps these as opt-in advanced modules instead of unavoidable defaults.
Rust solves this at compile time
OpenCode and Qwen push much of their configurability into runtime registries. ADK-Rust answers the same complexity problem with compile-time features and crate boundaries.
Model Strategy: Thin Core, Wide Adapter Surface
In adk-core/src/model.rs, the Llm trait is
intentionally tiny: name() plus
generate_content(). The richness lives in
LlmRequest, the response metadata, and the provider layer
under adk-model.
This is a pragmatic design. The core agent runtime stays stable, while provider-specific behavior can live in extensions. OpenAI-compatible endpoints such as xAI, Fireworks, Together, Mistral, Perplexity, Cerebras, and SambaNova are deliberately folded into one adapter family instead of each becoming a separate framework concept.
| Pattern | Evidence | Why it matters |
|---|---|---|
| Small core LLM trait | adk-core/src/model.rs |
Core compatibility stays simple |
| OpenAI-compatible consolidation | adk-model/src/lib.rs |
Broad provider reach without dozens of bespoke abstractions |
| Provider metadata escape hatch | LlmResponse.provider_metadata |
Vendor details can surface without bloating the core trait |
Tool System and File Editing
The tool layer is one of ADK-Rust's best engineering choices. The
#[tool] macro turns typed Rust functions into tools
without forcing you to hand-roll every schema. The built-in tool
surface then wraps provider-native capabilities where that is cleaner
than inventing a new cross-provider protocol.
File editing is the clearest example. In
adk-tool/src/builtin/anthropic.rs, ADK-Rust implements a
thin local executor for Anthropic's text-editor schema:
view, str_replace, insert, and
create. The implementation is intentionally strict:
positive 1-based line numbers, exact string matching, and no giant
fallback cascade.
OpenAI goes even further in the "provider-native first" direction. The
OpenAIApplyPatchTool in
adk-tool/src/builtin/openai.rs declares an
x-adk-openai-tool of type apply_patch, but
it does not locally execute patches. The error path explicitly says
patch outputs must be handled by the Responses API item protocol.
Anthropic path
Real local execution of provider-native editor commands with strict validation and exact-match behavior.
OpenAI path
Built-in declaration only. The framework exposes the provider's native patch concept instead of implementing its own parser.
The important contrast
Cline and OpenCode invest heavily in edit recovery logic. ADK-Rust mostly says: expose the provider contract cleanly, return precise errors, and let the caller decide whether to retry.
Workflow and Delegation Primitives
ADK-Rust has a broader orchestration surface than many product CLIs,
but it expresses that power as framework primitives rather than hidden
personas. The core set includes LlmAgent,
SequentialAgent, ParallelAgent,
LoopAgent, and the graph-focused GraphAgent.
The most interesting detail is SharedState. Parallel agents coordinate through explicit state passed in context instead of a magical global memory. That makes the orchestration model easier to reason about than many ad hoc task loops.
Deterministic workflows
Sequential, parallel, and loop agents are part of the ordinary core agent surface, not a separate orchestration product.
Graph workflows
adk-graph adds checkpoints, routing, durable resume,
and human-in-the-loop interruptions.
Realtime agents
adk-realtime introduces voice and streaming
interfaces, but the stability file correctly marks this area as
experimental.
Protocols and Broad Optional Capabilities
This repo is not satisfied with MCP alone. It layers MCP into the tool
system, exposes A2A services through adk-server, ships
AWP support through adk-awp and awp-types,
and even includes ACP and AP2 payment adapters under
adk-payments.
The important nuance is that these are not all treated as equally mature. ADK-Rust keeps advanced capabilities in separate crates with distinct risk profiles instead of pretending the whole workspace is one uniform blob.
| Capability | Where it lives | What stands out |
|---|---|---|
| AWP | adk-awp, awp-types |
Discovery, manifest, event, and health routes for agentic web deployments |
| A2A server | adk-server |
A real agent-to-agent service surface, not just an internal task helper |
| Payments | adk-payments |
Canonical transaction kernel behind ACP and AP2 adapters |
| Browser automation | adk-browser |
46 WebDriver tools plus smaller tool profiles for context control |
Security, Stability, and Tradeoffs
The repo is unusually honest about maturity.
STABILITY.md marks core crates such as
adk-core, adk-agent, adk-model,
adk-tool, adk-runner, and the umbrella crate
as Stable, while browser, realtime, eval, code,
sandbox, and audio remain Experimental.
That matters. ADK-Rust is architecturally ambitious, but it is not one monolithic product with uniform readiness. The sandbox story is a good example: the repo explicitly separates lightweight process execution from stronger WASM or OS-enforced isolation.
What is strongest here
Workspace organization, feature gating, typed tool definitions, protocol reach, and the discipline to separate stable crates from experimental ones.
What it gives up
There is no single iconic product UX to admire, and its file-editing path is deliberately thinner than Cline or OpenCode's local recovery stacks. You get a framework, not a finished house.
Verdict
ADK-Rust is the most library-shaped project in this workspace and one of the most important because of that. It is not trying to win the same contest as Claude Code or OpenCode. It is trying to give Rust developers a serious foundation for building agent systems that can scale from a tiny starter stack to graph workflows, browser automation, AWP routes, and payment-aware services.
If OpenCode is the best example here of a shared runtime becoming a platform, ADK-Rust is the best example of a publishable framework ecosystem. That is exactly why it belongs in this guide.