opendev

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

A fleet of agents, each independently exploring a different crate — all running concurrently in a single session.

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.

OpenDev also works fully offline against local OpenAI-compatible endpoints (Ollama, LM Studio, llama-server): set OPENDEV_DISABLE_REMOTE_MODELS=1 to skip the models.dev catalog fetch and point OPENDEV_API_BASE_URL (or api_base_url in settings) at your local endpoint. See Offline and Air-Gapped Use.

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.

See the Roadmap for current priorities and areas where community contributions are most welcome.

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