Opendev

Introduction

OpenDev is an open-source, terminal-native coding agent built as a compound AI system. Instead of a single monolithic LLM, it uses a structured ensemble of agents and workflows -- each independently bound to a user-configured model.

Work is organized into concurrent sessions composed of specialized sub-agents. Each agent executes typed workflows (Execution, Thinking, Compaction) that independently bind to an LLM, enabling fine-grained cost, latency, and capability trade-offs per workflow.

OpenDev automatically routes each phase of work to the right model. Five workflow slots — Normal (execution), Thinking (reasoning), Compact (context summarization), Self-Critique (output verification), and VLM (vision) — each bind independently to any LLM you configure. For example, Claude Opus handles execution, GPT-o3 handles reasoning, and a lightweight Qwen model handles compaction — all routed automatically. Together, these form a compound AI system where multiple models collaborate, each optimized for its role.

OpenDev is written in Rust — it starts in 4.3 ms, uses just 9.4 MB of memory, and ships as a single 18 MB binary. That makes it the fastest and lightest coding agent available today — up to 128x faster startup and 30x less memory than alternatives.

macOS ARM64 (Apple Silicon) · Startup: hyperfine --shell=none --warmup 10 --runs 100 · Memory: /usr/bin/time -l median of 20 runs · Multipliers relative to OpenDev

Why OpenDev?

• Blazing fast, ultra lightweight. 4.3 ms startup, 9.4 MB RAM, 18 MB on disk. Written in Rust with zero interpreter overhead — it launches before other agents finish loading their runtime.
• Proactive, not reactive. OpenDev can plan, execute, and iterate autonomously. Kick off a refactoring, walk away, and come back to a PR ready for review.
• Multi-provider, multi-model. Assign different models from different providers to every workflow and session, all running in parallel. Your models, your rules.
• TUI + Web UI. A full terminal UI for power users and a Web UI for visual monitoring. The Web UI supports remote sessions, so you can start a task from your phone and let OpenDev work while you sleep.

⚡ Agent Fleet — Parallel Execution at Scale

Need to survey an entire codebase? Refactor across 20 crates? Run a dozen tool calls at once? Spawn a fleet.

OpenDev's agent fleet launches multiple sub-agents in parallel, each with its own LLM binding, context window, and tool access. Because the runtime is written in Rust with fully async I/O, there is zero interpreter overhead — agents fan out across your workspace and converge results back in seconds, not minutes.

You                          OpenDev Fleet
 │                           ┌─ Agent 1 → crate/agents
 │   "survey all crates"     ├─ Agent 2 → crate/http
 │ ─────────────────────►    ├─ Agent 3 → crate/tui
 │                           ├─ Agent 4 → crate/tools
 │                           ├─  ...
 │   ◄── aggregated results  └─ Agent N → crate/config

• Concurrent, not sequential. Every agent runs its own async task — no GIL, no queue, no waiting.
• Rust-native performance. Near-zero overhead per agent. Memory-safe parallelism via Tokio.
• Independent LLM bindings. Each agent in the fleet can target a different model or provider.

Installation

From crates.io (all platforms)

cargo install opendev-cli

macOS

# Homebrew (recommended)
brew install opendev-to/tap/opendev

# Shell installer
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/opendev-to/opendev/releases/latest/download/opendev-cli-installer.sh | sh

# Or download the binary directly from GitHub Releases:
#   opendev-cli-aarch64-apple-darwin.tar.xz  (Apple Silicon)
#   opendev-cli-x86_64-apple-darwin.tar.xz   (Intel)

Linux

# Shell installer (x86_64 and ARM64)
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/opendev-to/opendev/releases/latest/download/opendev-cli-installer.sh | sh

# Or download the binary directly from GitHub Releases:
#   opendev-cli-x86_64-unknown-linux-gnu.tar.xz   (x86_64)
#   opendev-cli-aarch64-unknown-linux-gnu.tar.xz   (ARM64 / Raspberry Pi)

Windows

# PowerShell installer
powershell -ExecutionPolicy ByPass -c "irm https://github.com/opendev-to/opendev/releases/latest/download/opendev-cli-installer.ps1 | iex"

# Or download opendev-cli-x86_64-pc-windows-msvc.zip from GitHub Releases

From source (all platforms)

Requires Rust 1.94+.

git clone https://github.com/opendev-to/opendev.git
cd opendev
cargo build --release -p opendev-cli
# Binary at target/release/opendev (or opendev.exe on Windows)

If you use the repo for development, you may also have a local symlink at ~/.local/bin/opendev pointing at target/release/opendev. That can take precedence over the Homebrew binary in /opt/homebrew/bin/opendev.

To test a Homebrew install from a clean shell state:

rm -f ~/.local/bin/opendev
hash -r
brew uninstall opendev
brew untap opendev-to/tap
brew tap opendev-to/tap
brew install opendev-to/tap/opendev
which opendev
opendev --version

See DEVELOPMENT.md for the full local development and Homebrew testing workflow.

All release binaries, checksums, and installers are available on the GitHub Releases page.

Supported platforms

Verify installation

opendev --version

If Homebrew reports Not a valid ref: refs/remotes/origin/main while auto-updating the tap, remove the stale local tap clone and retry:

brew untap opendev-to/tap
brew tap opendev-to/tap
brew install opendev-to/tap/opendev

Quick Start

# Set an API key (OpenAI, Anthropic, or Fireworks -- any one will do)
export OPENAI_API_KEY="sk-..."
# export ANTHROPIC_API_KEY="sk-ant-..."
# export FIREWORKS_API_KEY="fw_..."

# Start the interactive TUI
opendev

# Or start the Web UI
opendev run ui

# Single prompt (non-interactive)
opendev -p "explain this codebase"

# Resume most recent session
opendev --continue

Prefer a guided walkthrough? Run opendev config setup to interactively choose providers, models, and workflow bindings.

See the Provider Setup Guide for all 9 supported providers, authentication details, and advanced configuration.

Multi-Provider Support

OpenDev supports 9 LLM providers: OpenAI, Anthropic, Fireworks, Google, Groq, Mistral, DeepInfra, OpenRouter, and Azure OpenAI.

Each provider's models can be independently assigned to 5 workflow slots:

• Normal -- Primary execution model for coding tasks and tool calls
• Thinking -- Complex reasoning and planning (falls back to Normal)
• Compact -- Context summarization when history grows long (falls back to Normal)
• Critique -- Self-critique of agent reasoning (falls back to Thinking)
• VLM -- Vision/image processing (falls back to Normal if it supports vision)

Mix and match providers per slot in ~/.opendev/settings.json:

{
  "model_provider": "anthropic",
  "model": "claude-sonnet-4-20250514",
  "model_thinking_provider": "openai",
  "model_thinking": "o3"
}

See the Provider Setup Guide for the full list of env vars, fallback chains, and configuration options.

MCP Integration

Dynamic tool discovery via the Model Context Protocol for connecting to external tools and data sources.

opendev mcp list
opendev mcp add myserver uvx mcp-server-sqlite
opendev mcp enable/disable myserver

Development

git clone https://github.com/opendev-to/opendev.git
cd opendev
cargo build --workspace
cargo test --workspace

cargo check --workspace       # Type check
cargo clippy --workspace      # Lint
cargo fmt --all               # Format
cargo test -p opendev-cli     # Test a specific crate

Detailed local-dev, symlink, Homebrew, and release-testing notes are in DEVELOPMENT.md.

Web UI

The frontend is a React/Vite app in web-ui/:

cd web-ui && npm ci && npm run build

Contributing

If you're interested in contributing to OpenDev, please open an issue or submit a pull request.

How OpenDev Compares

• vs. Claude Code / Codex CLI / Gemini CLI: Closed-source tools that lock you into a single provider. OpenDev is fully open source and lets you mix models from any provider, independently bound per workflow (execution, thinking, critique, compaction, vision).
• vs. OpenCode: OpenCode is a great open-source coding agent with TUI, Web UI, and LSP support. However, its architecture is not modular enough to support per-workflow model binding, concurrent multi-agent sessions, or compound AI orchestration.
• vs. OpenClaw: OpenDev and OpenClaw share similar concepts around autonomous AI agents. The key difference is focus: OpenDev is purpose-built for the software development lifecycle, with context engineering, structured agent workflows, and deep code understanding.

Star History