Documentation

AutoDevOS CLI Docs

Everything you need to install, configure, and get the most out of AutoDevOS.

Installation

Install AutoDevOS CLI from PyPI using pip or pipx. Python 3.8 or newer is required.

pip install autodevos-cli

pipx install autodevos-cli

After installation, the ados command is available globally in your shell.

System Requirements

RequirementMinimumNotes
Python3.8+Tested on 3.10, 3.11, 3.12
OSmacOS / Linux / WindowsWindows via WSL recommended
Disk~50 MBExcluding local model weights
Memory512 MB+More recommended for large context windows

Quick Start

1. Run the Setup Wizard

On first use, run the interactive auth wizard to configure your LLM provider and API key:

ados auth setup

The wizard walks through selecting a provider, entering your API key, and setting a default model.

2. Open a Project

Navigate to any codebase and start an interactive session:

cd my-project
ados

You can also pass a directory directly, or run a single prompt without entering interactive mode:

ados ~/projects/my-app

ados "refactor the authentication module"

3. Describe Your Task

Type any natural language task at the prompt. The agent reads your project, selects tools, and executes autonomously:

> add input validation to the /register endpoint and write tests for it

First Run

When you start ados in a project directory, it automatically:

  • Reads any AGENTS.md files in the directory tree for project-level instructions
  • Loads .autodevos/config.toml if present in the project root
  • Merges project config with your global config at ~/.config/autodevos/config.toml
  • Discovers and registers all available tools (built-ins + configured MCP servers)
  • Presents an interactive prompt for your first task

Use ados --init to scaffold a starter .autodevos/config.toml in the current project.

AGENTS.md

Drop an AGENTS.md file at your repo root or in any subdirectory. The agent reads all matching files in the current path hierarchy and uses them as project-level instructions — coding conventions, testing notes, architecture decisions, and more.

Global Config

The global config lives at ~/.config/autodevos/config.toml. Settings here apply to every session unless overridden by a project config.

[model]
provider = "anthropic"
name = "claude-sonnet-4-20250514"
temperature = 1.0
context_window = 128000

All Config Fields

FieldDefaultDescription
model.providerollamaLLM provider to use
model.name(provider default)Model name or ID
model.temperature1.0Sampling temperature (0–2)
model.context_window128000Token context window size
model.requests_per_minute(provider default)Client-side rate limit
approvalon-requestTool call approval policy
max_turns100Maximum agentic loop iterations per session
allowed_toolsnull (all tools)Restrict available tools by name
hooks_enabledfalseEnable lifecycle hooks
mcp_servers{}MCP server definitions
developer_instructionsnullExtra instructions injected into system prompt
user_instructionsnullUser-level LLM instructions

Project Config

Place a .autodevos/config.toml in any project root to set project-specific defaults. These merge with and override global config.

developer_instructions = """
This is a FastAPI project. Follow PEP 8. Use pytest for all tests.
Never commit directly to main.
"""

allowed_tools = ["read_file", "write_file", "edit", "shell", "grep"]
approval = "auto"
max_turns = 50

The developer_instructions field is injected directly into the system prompt for every session in that directory, giving the agent permanent context about your stack and conventions.

Provider Setup

AutoDevOS supports 8 LLM providers. Use ados auth set-key <provider> to store an API key, or export the API_KEY environment variable before running.

ProviderDefault ModelAPI Key Required
anthropicclaude-sonnet-4-20250514Yes
openaigpt-4oYes
geminigemini-1.5-proYes (15 RPM on free tier)
openrouteranthropic/claude-sonnet-4-20250514Yes
ollamallama3.2No — local server
lmstudiolocal-modelNo — local server
vllmlocal-modelNo — local server
customOptional

Switching Providers

ados config provider anthropic
ados config model claude-opus-4-5

Local Providers (Ollama, LM Studio, vLLM)

Local providers need no API key. If your server runs on a non-default port, set BASE_URL:

ados config provider ollama
BASE_URL=http://localhost:11434 ados

Custom OpenAI-Compatible Endpoint

[model]
provider = "custom"
name = "my-model"

[model]
base_url = "https://my-llm-proxy.example.com/v1"

CLI Commands

Main Commands

CommandDescription
adosStart interactive session in the current directory
ados <dir>Start interactive session in the given directory
ados "prompt"Single-shot mode — run one prompt and exit
ados --initCreate a starter .autodevos/config.toml in cwd

Config Subcommands

ados config              # show active configuration
ados config provider     # list or set the LLM provider
ados config model        # set the model name
ados config url          # set a custom base URL
ados config providers    # list all available providers

Auth Subcommands

ados auth                         # show current auth status
ados auth setup                   # run the interactive setup wizard
ados auth set-key <provider>      # store an API key for a provider
ados auth remove-key <provider>   # remove a stored key
ados auth generate-token          # generate a shareable team setup token
ados auth setup-token <token>     # apply a team setup token

In-Session Commands

These slash commands are available at the prompt while inside an interactive session:

CommandDescription
/helpShow all available in-session commands
/configDisplay the currently active configuration
/toolsList all available tools (built-in + MCP)
/statsShow session statistics — turns used, tokens, etc.
/savePersist the current session to disk for later resumption
/clearClear the conversation history (does not save)
/model <name>Hot-swap the active model without ending the session
/exit or /quitEnd the current session

Built-in Tools

These tools are registered automatically in every session. The agent selects and chains them based on the task at hand:

ToolCategoryDescription
shellExecutionExecute shell commands with a configurable timeout; hard-blocks destructive patterns
editWriteSurgical text replacement — replaces old_string with new_string, optionally all occurrences
write_fileWriteWrite or fully overwrite a file at any path
read_fileReadRead file contents with optional byte offset and line limit
list_dirReadList the contents of a directory
globReadFind files matching a glob pattern across the project
grepReadSearch file contents with a regex — returns file, line number, and match
web_searchNetworkSearch the web via DuckDuckGo — returns titles, URLs, and snippets
web_fetchNetworkFetch and return the readable text content of any URL
memoryStoragePersistent key-value store — actions: set, get, delete, list, clear
todoTrackingCreate and manage a task list scoped to the current session

Restricting Tools per Project

Limit the tools available in a project by setting allowed_tools in .autodevos/config.toml:

allowed_tools = ["read_file", "edit", "grep", "shell"]

MCP Integration

Extend the agent with any Model Context Protocol (MCP) server. Tools from MCP servers are discovered and registered at session startup alongside built-ins, and respect the same approval policies.

Stdio Transport

Launch an MCP server as a child process over stdin/stdout:

[mcp_servers.filesystem]
type = "stdio"
command = "npx"
args = ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"]

HTTP/SSE Transport

Connect to a running MCP server over HTTP Server-Sent Events:

[mcp_servers.my-server]
type = "sse"
url = "http://localhost:3100/sse"

Use /tools inside a session to verify MCP tools have been loaded successfully.

Lifecycle Hooks

Hooks let you run shell commands or scripts at specific points in the agent lifecycle. Set hooks_enabled = true and define hook entries in your config:

hooks_enabled = true

[[hooks]]
event = "after_tool"
tool = "edit"
command = "npm run lint -- --fix"

[[hooks]]
event = "after_agent"
command = "git add -A && git commit -m 'ados: changes'"
EventFires When
before_agentBefore the agent processes the first user message in a turn
after_agentAfter the agent produces its final response for a turn
before_toolBefore any tool call is dispatched
after_toolAfter a tool call completes successfully
on_errorWhen any tool call returns an error

Optionally filter a hook to fire only for a specific tool by adding a tool key to the hook entry.

Safety Controls

Approval Policies

Control when the agent asks for your confirmation before executing tool calls:

PolicyBehaviour
on-requestAsk before every tool call — safest, default setting
on-failureAsk only when a tool returns an error
autoApprove all tool calls automatically — useful in CI
auto-editAuto-approve file edits only; ask for shell commands
approval = "auto-edit"

Blocked Shell Commands

The shell tool hard-blocks a set of destructive patterns regardless of approval policy:

  • rm -rf / and similar root-level deletions
  • Fork bombs: :(){ :|:&};:
  • Filesystem format commands: mkfs.*
  • Other hard-coded dangerous patterns

Secret Variable Filtering

Environment variables matching *KEY*, *TOKEN*, and *SECRET* are stripped from the shell environment visible to the agent. Override or extend this list via the shell_environmentconfig section.

Path Validation

File read and write tools validate paths to prevent directory traversal outside the working directory.

Session Persistence

Save and resume sessions to pick up work across terminal restarts:

/save          # save the current session to disk
/clear         # wipe conversation history without saving

Saved sessions are stored in ~/.local/share/autodevos/sessions/. When you start ados and a recent session exists, it will prompt you to resume.

Context Compaction

When a conversation approaches the configured context_window, AutoDevOS automatically summarises older messages into a compact representation so the session continues without losing task context. Increase the window for models that support it:

[model]
context_window = 200000

Persistent Memory Tool

The memory tool gives the agent a persistent key-value store that survives across sessions, stored at ~/.local/share/autodevos/user_memory.json. Use it to remember preferences, project notes, or any context the agent should recall in future sessions.