adk-agent

Agent implementations for ADK-Rust (LLM, Custom, Workflow agents).

Overview

adk-agent provides ready-to-use agent implementations for ADK-Rust:

• LlmAgent - Core agent powered by LLM reasoning with tools and callbacks
• CustomAgent - Define custom logic without LLM
• SequentialAgent - Execute agents in sequence
• ParallelAgent - Execute agents concurrently
• LoopAgent - Iterate until exit condition or max iterations
• ConditionalAgent - Branch based on conditions
• LlmConditionalAgent - LLM-powered routing to sub-agents
• LlmEventSummarizer - LLM-based context compaction for long conversations

Installation

[dependencies]
adk-agent = "0.3"

Or use the meta-crate:

[dependencies]
adk-rust = { version = "0.3", features = ["agents"] }

Quick Start

LLM Agent

use adk_agent::LlmAgentBuilder;
use adk_model::GeminiModel;
use std::sync::Arc;

let model = Arc::new(GeminiModel::new(&api_key, "gemini-2.5-flash")?);

let agent = LlmAgentBuilder::new("assistant")
    .description("Helpful AI assistant")
    .instruction("Be helpful and concise.")
    .model(model)
    .tool(Arc::new(calculator_tool))
    .build()?;

LlmAgentBuilder Methods

Backward Compatibility

Existing builder paths remain valid and unchanged:

let agent = LlmAgentBuilder::new("assistant")
    .description("Helpful AI assistant")
    .instruction("Be helpful and concise.")
    .model(model)
    .build()?;

Skills are opt-in. No skill content is injected unless you call a skills method.

Minimal Skills Usage

let agent = LlmAgentBuilder::new("assistant")
    .model(model)
    .with_auto_skills()? // loads .skills/**/*.md when present
    .build()?;

Workflow Agents

use adk_agent::{SequentialAgent, ParallelAgent, LoopAgent};
use std::sync::Arc;

// Sequential: A -> B -> C
let pipeline = SequentialAgent::new("pipeline", vec![
    agent_a.clone(),
    agent_b.clone(),
    agent_c.clone(),
]);

// Parallel: A, B, C simultaneously
let team = ParallelAgent::new("team", vec![
    analyst_a.clone(),
    analyst_b.clone(),
]);

// Loop: repeat until exit or max iterations
let iterator = LoopAgent::new("iterator", vec![worker.clone()])
    .with_max_iterations(10);
// Default max iterations is 1000 (DEFAULT_LOOP_MAX_ITERATIONS)

Conditional Agents

use adk_agent::{ConditionalAgent, LlmConditionalAgent};

// Function-based condition
let conditional = ConditionalAgent::new(
    "router",
    |ctx| async move { ctx.user_content().text().contains("urgent") },
    urgent_agent,
).with_else_agent(normal_agent);

// LLM-powered routing
let llm_router = LlmConditionalAgent::new("smart_router", model)
    .instruction("Route to the appropriate specialist based on the query.")
    .add_route("support", support_agent, "Technical support questions")
    .add_route("sales", sales_agent, "Sales and pricing inquiries")
    .build()?;

Multi-Agent Systems

// Agent with sub-agents for transfer
let coordinator = LlmAgentBuilder::new("coordinator")
    .instruction("Route to appropriate specialist. Transfer when needed.")
    .model(model)
    .sub_agent(support_agent)
    .sub_agent(sales_agent)
    .build()?;

Guardrails

use adk_agent::LlmAgentBuilder;
use adk_guardrail::{GuardrailSet, ContentFilter, PiiRedactor};

let input_guardrails = GuardrailSet::new()
    .with(ContentFilter::harmful_content())
    .with(PiiRedactor::new());

let agent = LlmAgentBuilder::new("safe_assistant")
    .model(model)
    .input_guardrails(input_guardrails)
    .build()?;

Custom Agent

use adk_agent::CustomAgentBuilder;

let custom = CustomAgentBuilder::new("processor")
    .description("Custom data processor")
    .handler(|ctx| async move {
        // Custom logic here
        Ok(Content::new("model").with_text("Processed!"))
    })
    .build()?;

Features

• Automatic tool execution loop (with configurable timeout: DEFAULT_TOOL_TIMEOUT = 5 min)
• Configurable max iterations (DEFAULT_MAX_ITERATIONS = 100 for LlmAgent, DEFAULT_LOOP_MAX_ITERATIONS = 1000 for LoopAgent)
• Agent transfer between sub-agents (with validation against registered sub-agents)
• Streaming event output
• Callback hooks at every stage
• Input/output guardrails
• Schema validation
• Tool confirmation policies (ToolConfirmationPolicy::Never, Always, PerTool)
• Context compaction via LlmEventSummarizer

Context Compaction

LlmEventSummarizer uses an LLM to summarize older conversation events, reducing context size for long-running sessions. This is the Rust equivalent of ADK Python's LlmEventSummarizer.

use adk_agent::LlmEventSummarizer;
use adk_core::EventsCompactionConfig;
use std::sync::Arc;

let summarizer = LlmEventSummarizer::new(model.clone());
// Optionally customize the prompt template:
// let summarizer = summarizer.with_prompt_template("Custom: {conversation_history}");

let compaction_config = EventsCompactionConfig {
    compaction_interval: 3,  // Compact every 3 invocations
    overlap_size: 1,         // Keep 1 event overlap for continuity
    summarizer: Arc::new(summarizer),
};

Pass compaction_config to RunnerConfig to enable automatic compaction. See Context Compaction for full details.

Related Crates

• adk-rust - Meta-crate with all components
• adk-core - Core Agent trait
• adk-model - LLM integrations
• adk-tool - Tool system
• adk-guardrail - Guardrails

License

Apache-2.0

Part of ADK-Rust

This crate is part of the ADK-Rust framework for building AI agents in Rust.