ADK-Rust v0.2.0: The First Stable Release

We're thrilled to announce ADK-Rust v0.2.0 - the first stable release of the Rust framework for building production-ready AI agents. This release marks a major milestone with significant new features, improved stability, and a commitment to semantic versioning going forward.

What's New in v0.2.0

🔀 Graph Agents (LangGraph-style Workflows)

The new adk-graph crate brings LangGraph-style workflow orchestration to Rust:

use adk_graph::{prelude::*, node::AgentNode};

let graph = GraphAgent::builder("support_router")
    .channels(&["input", "category", "response"])
    .node(classifier_node)
    .node(billing_node)
    .node(technical_node)
    .edge(START, "classifier")
    .conditional_edges("classifier", Router::by_field("category", vec![
        ("billing", "billing_agent"),
        ("technical", "technical_agent"),
    ]))
    .edge("billing_agent", END)
    .edge("technical_agent", END)
    .build()?;

Key features:

State Management: Typed state channels with automatic merging
Conditional Routing: Route based on state fields or custom logic
Checkpointing: SQLite and in-memory backends for fault tolerance
Human-in-the-Loop: Interrupt workflows for human approval
Cyclic Graphs: Support for ReAct patterns with iteration limits

🎙️ Realtime Voice Agents

Build voice-enabled AI assistants with bidirectional audio streaming:

use adk_realtime::{RealtimeAgent, openai::OpenAIRealtimeModel};

let agent = RealtimeAgent::builder("voice_assistant")
    .model(Arc::new(OpenAIRealtimeModel::new(&api_key, "gpt-4o-realtime-preview")))
    .instruction("You are a helpful voice assistant.")
    .voice("alloy")
    .server_vad()  // Voice Activity Detection
    .build()?;

Supported providers:

OpenAI Realtime API (gpt-4o-realtime-preview, gpt-realtime)
Google Gemini Live API (gemini-2.0-flash-live-preview)

Features:

Bidirectional audio streaming (PCM16, G711)
Server-side Voice Activity Detection
Tool calling during voice conversations
Multi-agent handoffs

🌐 Browser Automation

The adk-browser crate provides 46 WebDriver tools for web automation:

use adk_browser::{BrowserSession, BrowserToolset, BrowserConfig};

let session = Arc::new(BrowserSession::new(
    BrowserConfig::new().webdriver_url("http://localhost:4444")
));
let tools = BrowserToolset::new(session).all_tools();

let agent = LlmAgentBuilder::new("web_agent")
    .model(model)
    .instruction("Browse the web and extract information.")
    .tools(tools)
    .build()?;

Tool categories:

Navigation: browser_navigate, browser_back, browser_forward
Extraction: browser_extract_text, browser_extract_links, browser_extract_html
Interaction: browser_click, browser_type, browser_select
Forms: browser_fill_form, browser_submit
Screenshots: browser_screenshot, browser_screenshot_element
JavaScript: browser_evaluate, browser_evaluate_async

📊 Agent Evaluation Framework

Test and validate agent behavior with the adk-eval crate:

use adk_eval::{Evaluator, EvaluationConfig, EvaluationCriteria};

let config = EvaluationConfig::with_criteria(
    EvaluationCriteria::exact_tools()
        .with_response_similarity(0.8)
);

let evaluator = Evaluator::new(config);
let report = evaluator
    .evaluate_file(agent, "tests/my_agent.test.json")
    .await?;

assert!(report.all_passed());

Evaluation capabilities:

Trajectory validation (tool call sequences)
Response similarity (Jaccard, Levenshtein, ROUGE)
LLM-judged semantic matching
Rubric-based scoring with custom criteria
Safety and hallucination detection

🎨 ADK Studio: Visual Agent Builder

A drag-and-drop interface for building AI agents:

cargo install adk-studio
adk-studio

Features:

ReactFlow canvas for visual workflow design
Full agent palette: LLM, Sequential, Parallel, Loop, Router
Tool integration: Function, MCP, Browser, Google Search
Real-time chat testing with SSE streaming
One-click code generation to production Rust

🛡️ Guardrails

Input/output validation with the adk-guardrail crate:

use adk_guardrail::{Guardrails, PiiRedactor, ContentFilter};

let guardrails = Guardrails::new()
    .add(PiiRedactor::default())
    .add(ContentFilter::block_harmful());

let safe_input = guardrails.process_input(user_message)?;
let safe_output = guardrails.process_output(agent_response)?;

Built-in guardrails:

PII redaction (emails, phones, SSNs, credit cards)
Content filtering (harmful, inappropriate)
JSON schema validation
Custom validation rules

🖼️ Dynamic UI Generation

The adk-ui crate enables agents to render rich interfaces:

use adk_ui::{UiToolset, UI_AGENT_PROMPT};

let agent = LlmAgentBuilder::new("ui_assistant")
    .instruction(UI_AGENT_PROMPT)
    .tools(UiToolset::all_tools())
    .build()?;

Components: 28 UI components including cards, tables, charts, forms Templates: 10 pre-built templates for common patterns React Client: npm install @zavora-ai/adk-ui-react

Breaking Changes

RunnerConfig Changes

The RunnerConfig struct now includes a run_config field:

// Before (v0.1.x)
let runner = Runner::new(RunnerConfig {
    app_name: "my_app".to_string(),
    agent: agent.clone(),
    session_service: session_service.clone(),
    artifact_service: None,
    memory_service: None,
})?;

// After (v0.2.0)
let runner = Runner::new(RunnerConfig {
    app_name: "my_app".to_string(),
    agent: agent.clone(),
    session_service: session_service.clone(),
    artifact_service: None,
    memory_service: None,
    run_config: None,  // NEW: Optional RunConfig for execution settings
})?;

Dependency Updates

sqlx upgraded from 0.7 to 0.8 (required for SQLite compatibility)
Rust 2024 edition (requires Rust 1.85+)

Migration Guide

Update Cargo.toml:
```
adk-rust = "0.2.0"
```

Add run_config: None to RunnerConfig:

RunnerConfig {
    // ... existing fields ...
    run_config: None,
}

Update sqlx if using SQLite sessions:

sqlx = { version = "0.8", features = ["sqlite", "runtime-tokio"] }

Performance Improvements

Streaming optimization: Reduced memory allocations in event streaming
Session caching: Improved session lookup performance
Tool execution: Parallel tool execution where possible

Documentation

All documentation has been updated for v0.2.0:

Documentation is now available in 9 languages: English, Spanish, Chinese, Japanese, Portuguese, German, French, Arabic, Hindi, and Korean.

What's Next

We're already working on v0.3.0 with planned features:

Cloud integrations (AWS Bedrock, Azure OpenAI, GCP Vertex AI)
Enhanced memory systems with more vector database backends
Workflow templates and pre-built agent patterns
Performance profiling and optimization tools

Get Started

# Create a new project
cargo new my_agent
cd my_agent

# Add ADK-Rust
echo 'adk-rust = "0.2.0"' >> Cargo.toml
echo 'tokio = { version = "1.40", features = ["full"] }' >> Cargo.toml

# Set your API key
export GOOGLE_API_KEY="your-api-key"

# Run an example
cargo run --example quickstart

Thank You

A huge thank you to everyone who contributed to this release through code, documentation, bug reports, and feedback. ADK-Rust is built by the community, for the community.

Links:

Happy building! 🦀🤖