Automatos is an operating system for AI work. You command a workforce of specialised agents — equipped with skills, tools and knowledge — through one voice, Auto, and they produce real Deliverables: reports, code, content, analysis. Self-host it with docker compose up, bring any model (paid APIs, free hosted open models, or your own Claude Code subscription), and keep your agents, data and Deliverables on infrastructure you control.

git clone https://github.com/AutomatosAI/automatos-ai.git && cd automatos-ai
cp .env.example .env   # set POSTGRES_PASSWORD, REDIS_PASSWORD, API_KEY
make up                # → http://localhost:3000, no login

Why an operating system?

Most agent frameworks give you a library. Automatos gives you the whole machine:

One codebase, two editions

The edition is a runtime flag (AUTH_EDITION=local|saas). Product capability is not gated: every agent, tool, Playbook, Mission and Deliverable feature in the code runs in the local edition. Session mode (your own Claude Code as an agent runtime) is local-only by design.

Marketplace agents · Composio tool integrations (bring your own key) · 400+ LLMs through OpenRouter, direct keys, or NVIDIA for free · Your own Claude Code as an agent · Reusable skills

Talk to your agents

One chat, routed to the right agent. The conversation stays where you left it across pages and reloads, opens several conversations as tabs, and a reply finishes even if the browser leaves mid-answer. Auto works in the open: its thinking streams into a collapsible block that gives way to the answer, every tool call stays visible as a line in the activity trail, and when it files a ticket for another agent it can wait, re-check, and report back in the same thread. Quick actions jump straight into coding, creating agents, managing knowledge, or building Playbooks.

Manage your AI workforce

100+ agents in the community marketplace — install what you need, when you need it. Code Reviewer, QA Engineer, Sentinel, Scribe, researcher and marketer roles, Shopify specialists, and more. Each agent has its own model route, capabilities, persona, and performance metrics. An agent is either an API agent (a model route you installed) or a session agent (your own Claude Code on your machine, below); you mix them freely on the same board.

Your own Claude Code, managed

Session mode turns your Claude Code subscription into an agent runtime — without an API key and inside Anthropic's terms. Pair a small host process on the machine that holds your repositories, give an agent the runtime Claude Code session, and Automatos becomes the manager above it:

• Auto files the tickets; the board tracks them. A ticket for a session agent is claimed by your host, runs as a real interactive Claude Code session under your own login, and lands like any other agent's work: files become Deliverables, the session log becomes the task report, and a permission question the session asks surfaces as an approval card.
• The agent's persona and skills ride into the session. What you configured on the agent is what the session is told; playbook steps and mission tasks reach session agents through the same ticket lane.
• The Runtime Canvas. Pick a session agent in the chat and the Canvas opens full-screen: a file explorer on the agent's workspace folder on the left, and on the right a terminal in which the host has already launched that agent's own Claude Code session — resumed if it exists. You type alongside it.
• Your folders, your rules. The host only runs sessions inside directories you registered; a git repository gets a worktree per ticket; sessions never push. The Claude Code binary is never modified, no token is ever touched or stored, and -p and --bare are never used.

1,000+ tool integrations

Connect your agents to GitHub, Slack, Jira, Stripe, Shopify, Datadog, Notion, HubSpot, and a thousand more through the Composio catalogue. Browse, install, and assign integrations to specific agents from a single dashboard — no glue code, no per-tool SDKs. In the local edition this needs your own COMPOSIO_API_KEY; without one the Tools page says so and the native platform tools keep working.

Tools chosen by meaning, not by menu

An agent with a hundred and eighty platform actions cannot be handed all of them on every turn. Before the prompt is assembled, the platform embeds your message and ranks the action catalogue by semantic similarity, so the model is offered the handful of tools that fit what you asked — one ranking per turn, shared by every surface that needs it, cached, and never replaced by the full list when the embedding is slow. Selections and outcomes feed the Intent Graph, the learned layer that ranks by what worked for phrasings like yours; it is seeded from example utterances so it is useful on day one, and a measured uplift gate decides whether it is allowed to route.

Workspace templates — entire teams in one click

Packaged bundles install a full operations team in a single step — agents, skills, playbooks, and dashboard widgets pre-wired together. Example: the Shopify package ships with 12 specialised agents, 32 Shopify skills, and a widget set for store ops, inventory, merchandising, SEO, campaigns, and customer support. Install it once, and your workspace goes from empty to a running e-commerce back office.

150+ reusable skills

Skills are portable, versioned capability packs — a system prompt, a set of tools, and an output contract. Drop Sentinel onto a security agent, Scout onto a research agent, or write your own. One skill, any agent, instantly productive. For a session agent the same skills are rendered into its Claude Code session.

Paid, free, or on your subscription — one router

Every model provider is a route in one registry, and a model is installed per route. Marketplace → LLMs has a tab per provider and shows one card per route with that route's own price: Kimi K3 · NVIDIA is free, Kimi K3 · OpenRouter is $3 / $15 per million tokens, and installing one tags your workspace with that provider. The runtime routes to the tag — a free route is never silently rerouted to a paid one when it is busy.

• OpenRouter — one key, 400+ models, priced per call — and web search for every model your agents run on (web access: reading pages needs no key at all).
• Direct keys — OpenAI, Anthropic, Google, DeepSeek, Azure OpenAI, AWS Bedrock, Grok / xAI.
• NVIDIA — the hosted open models on build.nvidia.com (Kimi, DeepSeek, Nemotron, Llama, Mistral, …) at no charge, under NVIDIA's trial terms and rate limit; the key is your own agreement with NVIDIA.
• Your Claude Code subscription — as a session agent, not as an API.

Mix cheap models for heartbeat work with frontier models for reasoning, and see what each route did and cost per request.

Command Center

See your entire AI workforce at a glance: live agent status, the board as a queue (Inbox → Assigned → In Progress → Review → Done), scheduled routines, and agent reports. Dragging a ticket to In Progress or pressing Run Now is the approval. The calendar shows heartbeats and schedules, board deadlines on the grid, and lets you or Auto schedule a board task for later — it is filed on the board when it fires.

Full cost visibility

Every call is recorded with the provider that served it and how it bills — a paid API route, a free NVIDIA route, a Claude Code subscription session, an embedding, a rerank. Analytics shows cost by provider, spend by lane (chat, board tickets, missions, heartbeats, retrieval), cost by agent for the selected period, cost by route over time, cache reads, failed calls, and a monthly projection. A session agent shows the tokens it used and "plan" instead of a dollar figure it never spent.

Knowledge bases with a graph

Upload documents, sync folders from Dropbox and cloud storage (the cloud connectors run through Composio), and let the platform chunk, embed, and index everything automatically. Your agents get RAG-powered access to your knowledge base — on pgvector in the local edition, on S3 Vectors in the hosted one — plus the Knowledge Graph built from it (entities, relationships, clusters), a CodeGraph of your repositories, and the memory layer, each with its own tab.

Core capabilities

Quick start (local edition)

git clone https://github.com/AutomatosAI/automatos-ai.git
cd automatos-ai
cp .env.example .env    # set the 3 required secrets: POSTGRES_PASSWORD, REDIS_PASSWORD, API_KEY
make up                 # first run builds the images and the database schema

Then open http://localhost:3000 (API reference at http://localhost:8000/docs).
No login. Add one model key and run the seeded Two-minute brief Playbook:

• OPENROUTER_API_KEY (400+ models), or OPENAI_API_KEY / ANTHROPIC_API_KEY / DEEPSEEK_API_KEY;
• NVIDIA_API_KEY from build.nvidia.com runs the hosted open models for free — in Marketplace → LLMs open the NVIDIA tab, sync once, add a model;
• keys can also be added later under Settings → API Keys.

To run your own Claude Code as an agent: set CLI_RUNTIME_ENABLED=true and LOCAL_PROJECTS_DIR=/path/to/your/projects in .env, make up, then Settings → Session mode → Get a pairing code and run the command it shows. Everything your agents write lands in one folder on your machine — AUTOMATOS_WORKSPACE_DIR, e.g. /path/to/your/projects/deliverables — which Deliverables → Explorer, the chat's Code mode and your sessions share. QUICKSTART.md is the short walkthrough; docs/getting-started/self-hosting.md covers every service, dial, session mode in depth, and what the local edition does not include.

Tech stack

Documentation

Platform documentation lives in /docs — architecture, APIs, agents, Playbooks, deployment. Most pages are generated from DeepWiki; the self-hosting guide, the analytics cost-tracking note and the contributing guide are maintained by hand.

Community

• Questions, ideas and show-and-tell: GitHub Discussions
• Bugs: open an issue — include your edition and what make up printed
• Security reports: privately, as SECURITY.md describes — never in a public issue

If Automatos is useful to you, a ⭐ helps other people find it.

Contributing

New here? Look for issues labelled good first issue. See CONTRIBUTING.md. Two things to know before the first PR:

• Sign off every commit (git commit -s). The Signed-off-by: trailer is your Developer Certificate of Origin attestation and the dco check verifies it on each pull request. There is no CLA; contributions are Apache-2.0 and ship in every edition.
• Capability first, core second. Skills, tools, MCP integrations, Playbooks and agent packages reach both editions unchanged and never conflict with core. Open an issue first for anything touching auth, storage, the tool router or a migration.