Installation
Install AutoDevOS CLI from PyPI using pip or pipx. Python 3.8 or newer is required.
pip install autodevos-cli
pipx install autodevos-cliAfter installation, the ados command is available globally in your shell.
System Requirements
| Requirement | Minimum | Notes |
|---|---|---|
| Python | 3.8+ | Tested on 3.10, 3.11, 3.12 |
| OS | macOS / Linux / Windows | Windows via WSL recommended |
| Disk | ~50 MB | Excluding local model weights |
| Memory | 512 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 setupThe 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
adosYou 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 itFirst 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 = 128000All Config Fields
| Field | Default | Description |
|---|---|---|
| model.provider | ollama | LLM provider to use |
| model.name | (provider default) | Model name or ID |
| model.temperature | 1.0 | Sampling temperature (0–2) |
| model.context_window | 128000 | Token context window size |
| model.requests_per_minute | (provider default) | Client-side rate limit |
| approval | on-request | Tool call approval policy |
| max_turns | 100 | Maximum agentic loop iterations per session |
| allowed_tools | null (all tools) | Restrict available tools by name |
| hooks_enabled | false | Enable lifecycle hooks |
| mcp_servers | {} | MCP server definitions |
| developer_instructions | null | Extra instructions injected into system prompt |
| user_instructions | null | User-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 = 50The 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.
| Provider | Default Model | API Key Required |
|---|---|---|
| anthropic | claude-sonnet-4-20250514 | Yes |
| openai | gpt-4o | Yes |
| gemini | gemini-1.5-pro | Yes (15 RPM on free tier) |
| openrouter | anthropic/claude-sonnet-4-20250514 | Yes |
| ollama | llama3.2 | No — local server |
| lmstudio | local-model | No — local server |
| vllm | local-model | No — local server |
| custom | — | Optional |
Switching Providers
ados config provider anthropic
ados config model claude-opus-4-5Local 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 adosCustom OpenAI-Compatible Endpoint
[model]
provider = "custom"
name = "my-model"
[model]
base_url = "https://my-llm-proxy.example.com/v1"CLI Commands
Main Commands
| Command | Description |
|---|---|
| ados | Start 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 --init | Create 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 providersAuth 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 tokenIn-Session Commands
These slash commands are available at the prompt while inside an interactive session:
| Command | Description |
|---|---|
| /help | Show all available in-session commands |
| /config | Display the currently active configuration |
| /tools | List all available tools (built-in + MCP) |
| /stats | Show session statistics — turns used, tokens, etc. |
| /save | Persist the current session to disk for later resumption |
| /clear | Clear the conversation history (does not save) |
| /model <name> | Hot-swap the active model without ending the session |
| /exit or /quit | End 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:
| Tool | Category | Description |
|---|---|---|
| shell | Execution | Execute shell commands with a configurable timeout; hard-blocks destructive patterns |
| edit | Write | Surgical text replacement — replaces old_string with new_string, optionally all occurrences |
| write_file | Write | Write or fully overwrite a file at any path |
| read_file | Read | Read file contents with optional byte offset and line limit |
| list_dir | Read | List the contents of a directory |
| glob | Read | Find files matching a glob pattern across the project |
| grep | Read | Search file contents with a regex — returns file, line number, and match |
| web_search | Network | Search the web via DuckDuckGo — returns titles, URLs, and snippets |
| web_fetch | Network | Fetch and return the readable text content of any URL |
| memory | Storage | Persistent key-value store — actions: set, get, delete, list, clear |
| todo | Tracking | Create 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'"| Event | Fires When |
|---|---|
| before_agent | Before the agent processes the first user message in a turn |
| after_agent | After the agent produces its final response for a turn |
| before_tool | Before any tool call is dispatched |
| after_tool | After a tool call completes successfully |
| on_error | When 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:
| Policy | Behaviour |
|---|---|
| on-request | Ask before every tool call — safest, default setting |
| on-failure | Ask only when a tool returns an error |
| auto | Approve all tool calls automatically — useful in CI |
| auto-edit | Auto-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 savingSaved 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 = 200000Persistent 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.