• Built-in semantic code search - Runs a local CPU code-embedding model and combines dense retrieval with BM25 keyword matching, reducing code-search context compared with grep/find-only agent.
• Bring your own model provider - Use provider/model bindings for OpenAI-compatible, Anthropic-compatible, DeepSeek, Qwen, Kimi, GLM, MiniMax, Xiaomi MiMo, OpenRouter, or local endpoints.
• MCP support - Connect external tools and context through Model Context Protocol servers.
• Skill support - Package repeatable workflows, instructions, scripts, and references as reusable Agent Skills.
• Long-running task support - Let Devo manage context automatically across multi-turn work instead of losing the thread as tasks grow.
• Multi-agent support - Split work across specialized agents while keeping coordination visible in the session.
• Plan Mode - Break larger tasks into clear multi-step plans before implementation starts.
• Parallel tool calls - Run multiple independent tools at parallel so models spend less time waiting and more time making progress.
• Permissioned tool execution - Review sensitive tool calls before they touch your workspace.
• Auditable sessions - Keep model output, tool calls, approvals, token usage, and session history inspectable and resumable.
• Cost and context visibility - Show input/output tokens, cached tokens, and context-window usage where providers expose them.
• Lightweight Rust runtime - Built in Rust with low memory overhead and a compact local runtime.

Devo's built-in model catalog includes tested model definitions for Qwen, Kimi, MiniMax, GLM, and DeepSeek. Provider endpoints remain configurable through provider/model bindings.

Devo has been tested on macOS, Linux, Windows, and Kylin OS.

Kylin OS coverage is called out because domestic operating systems are often part of real deployment requirements in Chinese enterprise environments. HarmonyOS support is on the roadmap; contributors with HarmonyOS devices are welcome to build, test, and publish releases for that platform.

curl -fsSL https://raw.githubusercontent.com/7df-lab/devo/main/install.sh | sh

irm 'https://raw.githubusercontent.com/7df-lab/devo/main/install.ps1' | iex

The online installer places devo under the Devo home directory, installs the rg sidecar used for fast repository search, and can preinstall the local Hugging Face model used by code_search.

Preinstall the local code_search model:

Linux / macOS:

curl -fsSL https://raw.githubusercontent.com/7df-lab/devo/main/install.sh | sh -s -- --install-code-search-model

Windows:

$env:DEVO_INSTALL_CODE_SEARCH_MODEL = "1"; irm 'https://raw.githubusercontent.com/7df-lab/devo/main/install.ps1' | iex

Upgrade an existing installation to the latest release:

devo upgrade

The upgrade command runs the same platform installer, and the installer prints the version transition, for example Version: v0.1.12 -> v0.1.15.

sh ./install.sh --offline

.\install.ps1 -Offline

Configure a provider, open a repository, and start the TUI:

cd /path/to/your/repo
devo onboard

Useful commands:

devo                         # start the interactive TUI in the current repo
devo resume <session-id>

devo onboard is the recommended setup path. For manual configuration, Devo merges settings in this order:

1. Built-in defaults
2. DEVO_HOME/config.toml - user-level config, defaulting to ~/.devo/config.toml on macOS/Linux and C:\Users\yourname\.devo\config.toml on Windows
3. <workspace>/.devo/config.toml - project-level config
4. CLI flags

Credentials live separately in DEVO_HOME/auth.json; config.toml should refer to credential ids instead of storing API keys directly.

Minimal shape:

[defaults]
model_binding = "deepseek-v4-flash-api-deepseek-com"

[providers."api.deepseek.com"]
enabled = true
name = "api.deepseek.com"
base_url = "https://api.deepseek.com"
credential = "api_deepseek_com_api_key"
wire_apis = ["openai_chat_completions"]

[model_bindings.deepseek-v4-flash-api-deepseek-com]
enabled = true
model_slug = "deepseek-v4-flash"
provider = "api.deepseek.com"
model_name = "deepseek-v4-flash"
display_name = "DeepSeek V4 Flash"
invocation_method = "openai_chat_completions"
default_reasoning_effort = "high"

The important separation is:

• model_slug selects Devo's local model metadata from models.json.
• provider selects the configured connection record.
• model_name is the provider-specific model string sent on the wire.
• invocation_method selects the provider protocol, such as openai_chat_completions, openai_responses, or anthropic_messages.

If the model you want to use is not in the built-in list, add it to models.json, then bind it through config.toml.

User-level model catalog:

• macOS/Linux: ~/.devo/models.json
• Windows: C:\Users\yourname\.devo\models.json

Project-level overrides can also be placed at <workspace>/.devo/models.json. Catalog precedence is <workspace>/.devo/models.json, then <DEVO_HOME>/models.json, then the built-in catalog. In models.json, provider is the default wire API metadata for the model; the actual endpoint is still selected by the provider field in config.toml.

Example models.json entry:

[
  {
    "slug": "my-coding-model",
    "display_name": "My Coding Model",
    "channel": "Custom",
    "provider": "openai_chat_completions",
    "description": "Custom OpenAI-compatible coding model.",
    "thinking_capability": "unsupported",
    "context_window": 200000,
    "effective_context_window_percent": 95,
    "max_tokens": 4096,
    "input_modalities": ["text"],
    "base_instructions": "You are Devo, a coding agent. Help the user edit and understand code."
  }
]

Then reference that slug from a model binding:

[model_bindings.my-coding-model-example]
enabled = true
model_slug = "my-coding-model"
provider = "my.provider"
model_name = "provider-specific-model-name"
display_name = "My Coding Model"
invocation_method = "openai_chat_completions"

Devo is pre-1.0 and actively developed. It is ready for local evaluation, experiments, and contributor use; public APIs and configuration may still change.

Built-in model metadata currently covers Qwen, Kimi, MiniMax, GLM, and DeepSeek families. Any model endpoint that supports OpenAI-compatible Chat Completions, OpenAI-compatible Responses, or the Anthropic Messages API can be connected through provider/model bindings.

Contributions are welcome while the project is still early:

• Architecture feedback on the client/server runtime, provider layer, safety model, and TUI.
• Documentation and translations.
• Provider, model, and wire API coverage.
• Focused fixes with validation commands and regression tests.

Open an issue or pull request to discuss changes.

This project is licensed under the MIT License.

If you find Devo useful, please consider giving it a star.