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 (Gemini, OpenAI, Anthropic, DeepSeek, Groq, Ollama)
• Build System - Compile and run executables directly from Studio

Installation

cargo install adk-studio

Or build from source:

# Keep the adk-rust repo next to this one for now:
#   ../adk-rust
# Source builds also require Node.js/npm so the embedded UI can be built.
cargo build --release -p adk-studio

Source Build Notes

• adk-studio currently references the local sibling ../adk-rust checkout for ADK crates.
• Source builds require npm; the Rust build now runs the UI build automatically.
• To skip the UI build step when ui/dist is already present, set ADK_STUDIO_SKIP_UI_BUILD=1.

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

Code Execution

Studio uses a Rust-first code execution model powered by the adk-code crate:

• Primary path: Authored Rust executed in a sandbox via RustSandboxExecutor. The same Rust body is used in both the live runner and generated projects.
• Secondary scripting: Lightweight JavaScript transforms via EmbeddedJsExecutor (boa_engine). Useful for data shaping and compatibility.
• Container execution: Python and Node.js code runs in ephemeral Docker containers via ContainerCommandExecutor with strict isolation defaults.
• WASM guest modules: Precompiled .wasm plugins via WasmGuestExecutor for portable sandboxed logic.

Sandbox settings in the UI map to controls that the selected backend can actually enforce. If a configured limit is unsupported, Studio surfaces the incompatibility before execution or export.

Browser-page JavaScript execution (via adk-browser) is a separate capability and is not part of the adk-code substrate.

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

Team Collaboration: Repo-Local Projects

By default, projects are stored in a user-local directory. For teams that want to version-control Studio projects alongside source code, use a repo-local directory:

# Recommended convention: .adk-studio/projects at repo root
adk-studio --dir ./.adk-studio/projects

my-repo/
├── .adk-studio/
│   └── projects/       # Studio project JSON files
├── src/
├── Cargo.toml
└── .gitignore

Add to .gitignore to keep build artifacts out of version control:

.adk-studio/projects/*/build/
.adk-studio/projects/*/target/

Each team member launches Studio with the same --dir flag. Project JSON files are the source of truth — generated Rust code can always be regenerated.

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.