adk-studio

Visual development environment for AI agents built with Rust Agent Development Kit (ADK-Rust).

Overview

adk-studio provides a visual, low-code development environment for building AI agents with ADK-Rust:

• Drag-and-Drop Canvas - Visual workflow design with ReactFlow
• Agent Palette - LLM Agent, Sequential, Parallel, Loop, Router agents
• Action Nodes - 10 non-LLM programmatic nodes for automation workflows
• Tool Integration - Function, MCP, Browser, Google Search tools
• Real-Time Chat - Test agents with live SSE streaming
• Code Generation - Compile visual designs to production Rust code
• Build System - Compile and run executables directly from Studio

Installation

cargo install adk-studio

Or build from source:

cargo build --release -p adk-studio

Uninstall

# Remove the binary
cargo uninstall adk-studio

# Optionally remove project data (macOS)
rm -rf ~/Library/Application\ Support/adk-studio/
# Linux
rm -rf ~/.local/share/adk-studio/

Quick Start

# Start ADK Studio server
adk-studio

# Open in browser
open http://localhost:3000

With Custom Host

# Bind to all interfaces (for remote access)
adk-studio --host 0.0.0.0 --port 8080

Features

Visual Agent Builder

• Drag agents from palette onto canvas
• Connect agents to create workflows (Sequential, Parallel, Loop)
• Configure agent properties: name, model, instructions, tools
• Add sub-agents to container nodes

Action Nodes

Action nodes are non-LLM programmatic nodes for deterministic workflow operations. They complement LLM agents by handling data transformation, API integrations, control flow, and automation logic.

Trigger Types

The Trigger node supports four trigger types for starting workflows:

Webhook Triggers

# Trigger via webhook (async - returns session ID)
curl -X POST "http://localhost:6000/api/projects/{id}/webhook/my-path" \
  -H "Content-Type: application/json" \
  -d '{"message": "Hello!"}'

# Trigger via webhook (sync - waits for response)
curl -X POST "http://localhost:6000/api/projects/{id}/webhook-exec/my-path" \
  -H "Content-Type: application/json" \
  -d '{"message": "Hello!"}'

Schedule Triggers

Schedule triggers use standard 5-field cron expressions:

• * * * * * - Every minute
• 0 9 * * * - Daily at 9 AM
• 0 0 * * 0 - Weekly on Sunday at midnight

Event Triggers

Event triggers match on source and eventType with optional JSONPath filtering:

# Send an event to trigger a workflow
curl -X POST "http://localhost:6000/api/projects/{id}/events" \
  -H "Content-Type: application/json" \
  -d '{
    "source": "payment-service",
    "eventType": "payment.completed",
    "data": {
      "orderId": "12345",
      "status": "active"
    }
  }'

Event filter example: $.data.status == 'active' only triggers when status is "active".

Action Node Configuration

All action nodes share standard properties:

// Standard Properties (shared by all action nodes)
{
  // Identity
  id: string;
  name: string;
  description?: string;
  
  // Error Handling
  errorHandling: {
    mode: 'stop' | 'continue' | 'retry' | 'fallback';
    retryCount?: number;      // 1-10, for retry mode
    retryDelay?: number;      // ms, for retry mode
    fallbackValue?: unknown;  // for fallback mode
  };
  
  // Tracing
  tracing: {
    enabled: boolean;
    logLevel: 'none' | 'error' | 'info' | 'debug';
  };
  
  // Execution Control
  execution: {
    timeout: number;     // ms, default 30000
    condition?: string;  // Skip if false
  };
  
  // Input/Output Mapping
  mapping: {
    inputMapping?: Record<string, string>;
    outputKey: string;
  };
}

Example: HTTP Node Configuration

{
  type: 'http',
  name: 'Fetch User Data',
  method: 'GET',
  url: 'https://api.example.com/users/{{userId}}',
  auth: {
    type: 'bearer',
    bearer: { token: '{{API_TOKEN}}' }
  },
  headers: {
    'Accept': 'application/json'
  },
  body: { type: 'none' },
  response: {
    type: 'json',
    jsonPath: '$.data'
  },
  errorHandling: { mode: 'retry', retryCount: 3, retryDelay: 1000 },
  mapping: { outputKey: 'userData' }
}

Example: Switch Node Configuration

{
  type: 'switch',
  name: 'Route by Status',
  evaluationMode: 'first_match',
  conditions: [
    { id: 'success', name: 'Success', field: 'status', operator: 'eq', value: 'success', outputPort: 'success' },
    { id: 'error', name: 'Error', field: 'status', operator: 'eq', value: 'error', outputPort: 'error' }
  ],
  defaultBranch: 'unknown',
  mapping: { outputKey: 'routeResult' }
}

Example: Loop Node Configuration

{
  type: 'loop',
  name: 'Process Items',
  loopType: 'forEach',
  forEach: {
    sourceArray: 'items',
    itemVar: 'item',
    indexVar: 'idx'
  },
  parallel: {
    enabled: true,
    batchSize: 5
  },
  results: {
    collect: true,
    aggregationKey: 'processedItems'
  },
  mapping: { outputKey: 'loopResults' }
}

Tool Support

• Function Tools - Custom functions with code editor and templates
• MCP Tools - Model Context Protocol servers with templates
• Browser Tools - Web automation with 46 WebDriver actions
• Google Search - Grounded search queries
• Load Artifact - Load binary artifacts into context

Real-Time Execution

• Live SSE streaming with agent animations
• Event trace panel for debugging
• Session memory persistence
• Thought bubble visualization

Code Generation

• View Code - See generated Rust code with Monaco Editor
• Compile - Generate Rust project from visual design
• Build - Compile to executable with real-time output
• Run - Execute built agent directly
• Smart Build Button - Send button transforms to Build when workflow changes need recompilation

Action Node Code Generation

Action nodes generate production Rust code alongside LLM agents:

All action nodes support {{variable}} interpolation in string fields and receive predecessor node outputs automatically. Dependencies are auto-detected and added to the generated Cargo.toml.

Architecture

adk-studio/
├── src/
│   ├── main.rs        # CLI entry point
│   ├── server.rs      # Axum HTTP server
│   ├── routes/        # API endpoints
│   ├── codegen/       # Rust code generation
│   └── templates/     # Agent templates
└── ui/                # React frontend
    └── src/
        ├── components/
        │   ├── ActionNodes/    # Action node components
        │   ├── ActionPanels/   # Action node property panels
        │   └── ...
        └── types/
            ├── actionNodes.ts  # Action node type definitions
            └── ...

API Endpoints

Environment Variables

Templates

ADK Studio includes curated workflow templates:

Agent Templates

• Simple Chat - Basic conversational agent
• Research Pipeline - Sequential researcher → summarizer
• Content Refiner - Loop agent for iterative improvement
• Support Router - Route requests to specialized agents

Automation Templates (Action Nodes)

• Email Sentiment Analysis - Analyze emails and update spreadsheet
• API Data Pipeline - Fetch, transform, and store data

Related Crates

• adk-rust - Meta-crate with all components
• adk-agent - Agent implementations
• adk-graph - LangGraph-style workflows
• adk-tool - Tool system

License

Apache-2.0

Part of ADK-Rust

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