cli;do

cli;do is a local-first, multi-provider CLI coding agent. Run it in your terminal, give it a task in plain language, and it uses AI (with tools like read, edit, search, and run) to get the job done—with permission prompts for anything that changes your files.

• CLI-first — Built for the terminal; scripting and automation are first-class.
• Multi-provider — Use different AI backends (e.g. Anthropic, OpenAI) via profiles.
• Safe by default — Destructive or state-changing actions require your approval.
• Session-aware — Resume after interrupt; cost and usage visible when you care.
• Production-grade agent loop — Tool inputs are validated against each tool’s JSON Schema before execution; failures carry typed categories for retry policy; configurable wall-time and tool-call caps, stall and doom-loop detection, and optional spacing between LLM calls (see docs/guide/configuration.md and docs/developer/agent-loop-production-plan.md).

Shipped today: multi-provider agent with tools, TUI, sessions, memory, MCP, semantic search, YAML workflows, checkpoints, audit log, skills (folder-based reusable instructions), and plan/todo UX in the TUI. See docs/guide/ for detail.

curl -fsSL https://clido.ai/install.sh | sh

Or build from source (requires Rust 1.94+):

git clone https://github.com/clido-ai/clido-cli.git && cd clido-cli
cargo install --path crates/clido-cli --locked

On first launch, clido will run an interactive wizard (clido init) that:

1. Prompts for your preferred provider (all supported providers — see below)
2. Asks for your API key or base URL
3. Writes ~/.config/clido/config.toml and a separate credentials file

You can also run clido init at any time to reconfigure.

Config is stored in ~/.config/clido/config.toml (global) or .clido/config.toml (project-local, takes precedence).

default_profile = "default"

[profile.default]
provider = "anthropic"
model = "claude-sonnet-4-5"

[profile.fast]
provider = "anthropic"
model = "claude-haiku-4-5"

[profile.local]
provider = "local"
model = "llama3"
base_url = "http://localhost:11434"

Switch profiles with --profile fast or CLIDO_PROFILE=fast.

Each profile defines a provider, model, and optional credentials. The setup wizard and clido profile create store API keys in a separate credentials file alongside config.toml (with chmod 600 permissions), keeping secrets out of the main config.

[profile.myprofile]
provider = "anthropic"        # required — see Supported Providers below
model = "claude-sonnet-4-5"   # required — model identifier
api_key_env = "MY_KEY"        # optional — name of env var holding the key
base_url = "https://..."      # optional — override API endpoint
# api_key = "sk-..."          # legacy fallback — prefer env var or credentials file

# Optional fast/cheap provider for utility tasks (titles, summaries, etc.)
[profile.myprofile.fast]
provider = "openai"
model = "gpt-4o-mini"

API key resolution order:

1. Environment variable (e.g. ANTHROPIC_API_KEY)
2. Credentials file (~/.config/clido/credentials, created automatically during setup)
3. Inline api_key in config.toml (legacy, backward-compatible)

Managing profiles:

clido profile list               # list all profiles
clido profile create myprofile   # create via guided wizard
clido profile switch myprofile   # set as default
clido profile edit myprofile     # edit via guided wizard
clido profile delete myprofile   # delete a profile

In the TUI, press Ctrl+P to open the profile picker or use /profile slash commands.

Add .md or .txt files under .clido/skills/ (project) or ~/.clido/skills/ (user). Optional YAML front matter sets id, name, purpose, etc. Control loading with [skills] in config.toml (disabled, enabled whitelist, extra-paths, no-skills, auto-suggest). CLI: clido skills list|paths|enable|disable. TUI: /skills …. Full guide: docs/guide/skills.md.

All providers except Anthropic use the OpenAI-compatible API format. Use clido list-models --provider <id> to see available models for a provider.

Model aliases: sonnet → claude-sonnet-4-5, opus → claude-opus-4-6, haiku → claude-haiku-4-5, 4o → gpt-4o, flash → gemini-2.5-flash, deepseek → deepseek-chat, r1 → deepseek-reasoner, grok → grok-3-beta, sonar → sonar-pro.

clido [FLAGS] [OPTIONS] [PROMPT]...
clido <SUBCOMMAND>

Run clido (no arguments, at a TTY) to launch the full-screen interactive TUI. The TUI shows:

• A scrollable conversation panel with assistant responses, tool calls, and diffs.
• Side-by-side diff view when the terminal is wide enough (≥120 columns); falls back to inline unified diff on narrower terminals.
• A header strip with provider, model, session ID, cost, and context window usage (% filled).
• A status strip with live tool activity.
• A hint bar with key bindings.

Type / in the input bar to see completions. Commands are grouped by category:

Session

Model & Roles

Settings

Git

Context & Cost

Plan

Project

Global

Chat input

Scrolling

Pickers & overlays

Permission prompts

Pass a JSON or YAML config file to connect external MCP tool servers:

clido --mcp-config ./mcp.json "use the file-system server to list project files"

{
  "servers": [
    { "name": "fs", "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "."] }
  ]
}

Each server entry requires name and command; args and env are optional. MCP tools appear alongside built-in tools.

Clido stores long-term memories automatically during agent sessions. The agent reads relevant memories from the previous N sessions and can create new ones.

clido memory list              # show recent memories (default: 20)
clido memory list --limit 50   # show more
clido memory prune --keep 100  # keep only the 100 most recent
clido memory reset --force     # delete all memories

Memories are injected into the system prompt context automatically — no manual configuration needed.

Build a file and symbol index so the agent can use SemanticSearch to find relevant code:

clido index build                            # index current directory (rs,py,js,ts,go)
clido index build --dir ./src --ext rs,toml  # custom directory and extensions
clido index stats                            # show index stats
clido index clear                            # delete the index

Once the index is built, the agent automatically uses SemanticSearch for relevant queries.

Run multi-step declarative YAML workflows:

clido workflow run ./my-workflow.yaml
clido workflow run ./my-workflow.yaml --input key=value
clido workflow run ./my-workflow.yaml --dry-run   # validate without API calls
clido workflow validate ./my-workflow.yaml        # check YAML structure
clido workflow list                               # list workflows in configured dirs

Example workflow YAML:

name: summarize-and-test
steps:
  - id: summarize
    prompt: "Summarize the changes in the last git commit"
  - id: test
    prompt: "Run the test suite and report failures"
    depends_on: [summarize]

Pass --planner to enable task decomposition before execution:

clido --planner "refactor the auth module, add tests, and update docs"

The planner decomposes the prompt into a DAG of subtasks shown in the TUI. On plan failure or low-quality output, it falls back to the standard reactive agent loop transparently. Use /plan in the TUI to review the current plan.

Every tool call is recorded in the audit log:

clido audit                        # show all entries
clido audit --tail 20              # show last 20 entries
clido audit --session <ID>         # filter by session
clido audit --tool Bash            # filter by tool name
clido audit --since 2026-01-01     # filter by date
clido audit --json                 # JSON output

cargo build --release             # build
cargo run --release               # interactive TUI
cargo run --release -- "task"     # one-shot run
cargo test --workspace            # run all tests (CI uses `cargo nextest run --workspace`)
cargo tarpaulin --workspace --config tarpaulin.toml --out Stdout  # line coverage; fails below 70% per tarpaulin.toml
cargo bench -p clido-cli          # run startup benchmarks

See Building for build/test commands and Contributing for contributor workflow.

V1+ implementation: Core agent loop, six tools, config with profiles, sessions with resume and stale-file detection, context compaction, permission modes, clido doctor and clido init, interactive TUI (clido with no args at a TTY), first-run setup, memory, repo index, declarative workflows, audit log, stats, shell completions, man page, list-models, planner (experimental), MCP support, agent profiles (create/switch/edit/delete with optional fast provider), checkpoints and rollback, unified credential storage, side-by-side diff viewer, and multi-provider support including Anthropic, OpenAI, OpenRouter, Mistral, MiniMax, Alibaba Cloud, and local (Ollama). Build and test: see Build above.

MIT