atom is a free, open source orchestration & scheduling project written in Python and released under AGPL-3.0. It has 911 GitHub stars, 93 forks and 2 open issues, and was last pushed 7 hours ago. On this registry it ranks #103 of 130 tracked projects in Orchestration & Scheduling, with 5 head-to-head comparisons available. It gained 11 stars over the last 30 tracked days.

What is atom?

Atom Agent is an open-source, self-hosted AI agent workforce platform, licensed AGPL-3.0 and written in Python, that lets teams delegate routine work to specialty agents under default-on governance checks — and it is aimed at organisations that want agent accountability, verifiable outcomes, and data ownership on their own hardware.

What it is

Atom is a self-hosted AI agent workforce: a team of specialty agents covering sales, support, finance, and engineering, which people delegate to in plain language. It ships as free, open-source software under AGPL v3, runs on Python 3.11 or newer, and lives in the Infrastructure and Operations category under Orchestration and Scheduling. Its distinguishing design choice is that agents do not begin autonomous: every agent starts as a supervised intern and graduates through a four-tier maturity model, STUDENT to INTERN to SUPERVISED to AUTONOMOUS, only after verified successful runs of 10, 25, and 50 episodes, outcome-checked rather than self-reported.

The concrete problem it addresses is the gap between agent pilots and production. The project cites an industry figure that 88 percent of AI agent pilots never reach production, and states that it makes no claims about its own deployments. It replaces the pattern where an agent responds to a command, reports completion, and is believed with a verified model: every mutating action is re-derived against the system of record by an independent postcondition oracle that is on by default, and confidence is separated into self-reported and externally verified values. A prompt-injected agent at any tier is bounded to that tier's scoped blast radius by a sandbox layer rather than assumed to be trustworthy.

Key capabilities

  • Four-tier agent maturity model (STUDENT → INTERN → SUPERVISED → AUTONOMOUS) with progression gated on outcome-checked episodes at 10, 25, and 50 runs.
  • Independent postcondition oracle re-derives every mutating action against the system of record, enabled by default, splitting self-reported from externally verified confidence.
  • Sandbox layer with filesystem scope, tool whitelist, tripwires, resource caps, kill-run, egress allowlist, and full provenance audit, measured at 0.027ms P99 per governance check.
  • Bring-your-own-key inference with keys configured in .env, treated as BYOK and encrypted at rest, never gated by plans or tiers.
  • Local model support through Ollama as a first-class option, plus any local OpenAI-compatible server such as LM Studio, vLLM, or llama.cpp server, for fully private deployments.
  • Sixteen or more LLM providers — OpenAI, Anthropic, DeepSeek, Gemini, MiniMax, and Groq among them — with automatic cost-aware routing, fallback, and self-healing, plus a learning router and caching tiers.
  • Embedded workflow store, agent state, and memory that require no cloud, with integrations spanning Gmail, Google Drive, Google Calendar, Notion, Shopify, calendar, and finance topics.

Who uses it and how

  • Teams that want to hand routine work — research, data entry, drafting, reconciliation — to agents while governance keeps a human in control.
  • Organisations that must keep workflow data, agent state, and memory on their own infrastructure rather than in a vendor cloud, which the embedded store supports without a cloud dependency.
  • Deployments with strict privacy requirements, which run local models through Ollama or another OpenAI-compatible server instead of hosted providers.
  • Organisations designing for EU AI Act data-governance obligations dated August 2026, which the project states it was designed for rather than retrofitted.
  • Commercial or managed adopters, where the same open-source code runs on the client's own infrastructure because there is no closed-source pro build.

Getting started

The repository itself is the free edition: clone it, install the Python 3.11+ service, and configure your provider keys in .env as BYOK, or point it at a local model server. A dedicated setup guide for the low-cost OpenCode Go provider is published at docs/guides/OPENCODE_GO_PROVIDER.md.

How it compares

The provided facts name no competing registry product, so Atom stands alone in this registry as a governed, self-hosted agent platform. The only adjacent tools named are the local inference servers it can run against — Ollama, LM Studio, vLLM, and llama.cpp server — which act as backends rather than alternatives. Where the README refers to other platforms, it refers to them generically as vendors of agent capability rather than agent accountability.

When to use it — and when not to

A self-hoster must operate a Python service, its embedded data store, and its own model access, whether through API keys held in .env or a local inference server. Teams that want a fully managed SaaS with no operational surface, or that cannot accept the AGPL-3.0 copyleft licence, should look elsewhere. The governance and throughput figures cited are repository benchmarks and the project is explicit that it makes no claims about its own production deployments, so the pilot-to-production evidence must come from the adopter's own verified runs.

project readme (upstream, from github) — read inline

ATOM Platform

The governed agent platform — autonomy, earned.

Atom Platform

88% of AI agent pilots never reach production.* Atom is built for the other path.

*Industry figure (Turion 2026). Atom makes no claims about its own deployments.

License CI Tests Governance Python Stars


What is Atom?

Atom is an open-source, self-hosted AI agent workforce — a team of specialty agents (sales, support, finance, engineering) that your people delegate to in plain language. Where other platforms sell agent capability, Atom sells agent accountability: autonomy that is earned through verified outcomes, executed inside a deterministic safety net, on your hardware.

Agents that earn trust, not assume it. Atom's agents don't just respond to commands — they operate autonomously within governed boundaries, handling routine work end-to-end. Every agent starts as a supervised intern and graduates through a 4-tier maturity model (STUDENT → INTERN → SUPERVISED → AUTONOMOUS) only after verified successful runs — 10/25/50 episodes, outcome-checked, not self-reported.

Verified outcomes, not self-report. Every mutating action is re-derived against your system of record by an independent postcondition oracle (on by default), and confidence is split into self-reported vs externally verified. An agent that says "done" is checked, not believed. A prompt-injected agent at any tier acts at that tier's scoped blast radius — bounded by a default-on sandbox layer: filesystem scope, tool whitelist, tripwires, resource caps, kill-run, egress allowlist, full provenance audit. 0.027ms P99 per check.

Your data stays yours. Workflow data, agent state, and memory live on your infrastructure — embedded store, no cloud required. LLM inference uses your own API keys (BYOK, encrypted at rest) — or local models (Ollama first-class, or any local OpenAI-compatible server: LM Studio, vLLM, llama.cpp server) for fully private deployments. EU AI Act data-governance obligations (Aug 2026)? Designed for, not retrofitted.

Free edition, full features (AGPL v3): everything in this repository — every agent, integration, and governance feature — is free and open source. Keys you configure in .env are treated as BYOK and are never gated by plans or tiers. Commercial/managed editions run this same code on the client's own infrastructure; there is no closed-source "pro" build.

💰 Budget-friendly AI agents: OpenCode Go subscription (~90% savings vs pay-per-token) — one $10/mo key unlocks general-purpose models (DeepSeek V4, Kimi K3, GLM 5.2, MiniMax M3, Qwen 3.7, Nemotron 3 Ultra, Grok 4.5) with full tool-calling & structured output — not just for coding, works for any agent workload. Setup guide →

No lock-in: 16+ LLM providers (OpenAI, Anthropic, DeepSeek, Gemini, MiniMax, Groq…) with automatic cost-aware routing, fallback, and self-healing — every run makes the next run cheaper (learning router + caching tiers).

The vision: every employee gets a personal agent team that knows their workflows, remembers context across weeks, and autonomously handles the repetitive work — research, data entry, drafting, reconciliation — while governance keeps you in control. Not AI replacing humans: AI handling the work humans shouldn't be doing.


Receipts: 0.027ms P99 governance checks (repo benchmark) · 616k ops/s cached throughput · 69+ documented TDD hardening rounds (~1,100 fixes in the deep security sweep alone) · 85k+ test functions (84,737 across 2,759 files, verified Aug 2026). External stats sourced in docs/marketing/RESEARCH_NOTES.md; copy kit in COPY_README.md + POSITIONING.md.


💻 Quick Start

Clone to first governed workflow in ~10 minutes. Start small — one workflow, one integration, one approval gate.

git clone https://github.com/rush86999/atom.git && cd atom
make setup                 # one-shot dev bootstrap (venv, deps, .env, frontend)
make backend               # full backend on :8001
# in a second terminal:
make frontend              # Next.js UI on :3001

To use LLM features, set one key in backend/.env (or add via Settings > AI):

  • OPENCODE_API_KEY for low-cost subscription coding models (~90% savings, recommended) or
  • OPENAI_API_KEY / ANTHROPIC_API_KEY / DEEPSEEK_API_KEY / GOOGLE_API_KEY … or
  • ATOM_LOCAL_ONLY=true + OLLAMA_BASE_URL=http://localhost:11434/v1 for fully local

Expected result: open http://localhost:3001 → sign in as admin@example.com (password in backend/logs/bootstrap_admin_password.txt) → describe a workflow in plain language and watch it build with an approval gate before anything ships.

Full Quick Start → · Docker → · DigitalOcean 1-Click →

Solo operator? Skip setup — import a pre-built personal starter (invoice chase, candidate pipeline, support triage), each with an approval gate so nothing sends without your OK: Personal → Team Playbook →


🚀 AI-Generated Workflow Automation

Describe the outcome. Atom builds and runs the workflow.

What you say What Atom delivers
"When a lead comes in HubSpot, research the company, score it, create an Asana task for the rep, and ping Slack" A governed, replayable workflow with Human-in-the-Loop approval gates
"Extract invoice data from Gmail PDFs, match against QuickBooks, flag discrepancies" End-to-end pipeline: Gmail → PDF OCR → QuickBooks reconciliation → Slack alert
"Monitor Zendesk tickets for sentiment, auto-escalate urgent ones, draft replies" Real-time triage agent with approval before send
"Generate a weekly sales report from Salesforce, format in Excel, email the team" Scheduled workflow: SOQL query → formula-evaluated Excel → Office 365 send

Why it's different from Zapier/Make/n8n:

  • Agents, not just steps — Agents reason (not just execute): they research, decide, retry, and self-correct
  • Governance built-in — Maturity gates, HITL approval, audit trail, sandbox isolation
  • Self-hosted & private — Your data, your keys, your infrastructure
  • Office-native — Real Excel/Word/PPTX with formula evaluation, live Canvas co-editing
  • Agent-authored — You can chat with an agent to build/modify workflows (no drag-and-drop required)

Workflow Automation Guide → · Quick Start →


⚡ The AI Agent Landscape — Where Atom Fits

🧵 Consumer Assistants 🧰 Developer Frameworks 🏢 Enterprise Workforce
Examples ChatGPT, Claude, Notion AI, Copilot, Perplexity LangGraph, AutoGPT, CrewAI, AutoGen ✅ Atom
Interaction Single chat, reactive only Code-first, build-your-own Delegate to agent teammates in plain language
Data & hosting Cloud-only Self-hosted; bring your own integrations Self-hosted + 46+ native business integrations
Governance None DIY Governed by design

Atom is the only open-source platform that delivers:

  • Enterprise governance (maturity tiers, HITL, audit) — without vendor lock-in
  • Agents that know when to ask — autonomy earned per action type from verified track records, auto-revoked on regression; governed agent orgs with delegation contracts & privilege leases
  • Self-hosted privacy — your data, your keys, your infrastructure
  • Autonomous agent teammates — agents that work with your people, not just for them
  • Agent-authored workflows — chat to build, no drag-and-drop
  • Office/Canvas native — real Excel formulas, live co-editing
  • 46+ business integrations — Salesforce, HubSpot, Slack, Jira, Stripe, QuickBooks…

📊 Comparisons

Alternative Focus Key Difference Deep Dive
Hermes Agent (Nous Research) Personal coding/productivity assistant Single-agent, no governance, no integrations, no sandbox Atom vs Hermes →
OpenClaw Personal productivity, messaging-first Single-agent, Markdown memory, smart home focus Atom vs OpenClaw →
LangGraph / CrewAI / AutoGen Developer frameworks Code-first, build-your-own governance & integrations Why Atom? ↓
Zapier / Make / n8n Workflow automation Step-based (not agents), no reasoning, no governance AI-Generated Workflow Automation

TL;DR: If you're evaluating personal agents → Hermes/OpenClaw. If you need governed multi-agent business automation → Atom.

Full feature matrix: Why Teams Choose Atom ↓


⚡ Key Capabilities

Category Features
🤖 Multi-Agent Orchestration Queen Agent (structured workflows) + Fleet Admiral (open-ended tasks) + Conductor (5 execution strategies) + validated state machine with rollback; governed fleet routing with ranked specialist matching
🛡️ Governance & Safety 4-tier maturity (Student→Autonomous), policy-gated HITL approval, comprehensive audit trail, AI-powered training, OIDC SSO + SCIM v2 provisioning + 8-role RBAC
✅ Outcome Verification Postcondition oracle re-derives success against the system of record — on by default, a refuted self-report is stamped UNVERIFIED (ATOM_ORACLE_ENFORCE kill switch); two-tier confidence provenance (self-reported vs externally verified); opt-in reviewer re-delegation loop
🎚️ Agents That Know When To Ask Every action type earns interruption-free status from its verified track record, keeps asking when evidence is thin (ask fails safe), and loses the privilege automatically when results regress — autonomy only relaxes after passing a held-out certification gate (Brier ≤ 0.25, denial-coverage ≥ 0.7)
🏛️ Governed Agent Teams Multi-agent fleets fail like human orgs — ignored instructions, redone work, nobody accountable. Atom ships the countermeasures: delegation contracts with a single accountable agent, expiring privilege leases instead of titles, conflict-of-interest detection, contribution credit feeding graduation, opt-in nightly alignment sweeps
🧠 Memory & Learning Per-turn fact extraction, 2-tier recall (SQL + LanceDB), episodic memory, memory_remember/forget, self-evolution (Memento/AlphaEvolver, self-evolving harness)
🔎 Hybrid Search documents.search fuses BM25 (FTS5/tsvector) + vector (LanceDB) via Reciprocal Rank Fusion (RRF) — semantic + precise retrieval with citations
🗂️ Knowledge VFS Agent-native document tree — ls/cat/grep/search with line-numbered citations instead of bespoke per-store queries
📻 Agent Radio Lateral peer-to-peer messaging between agents (mention-first, budget-governed) — agents coordinate without hardcoded teams
💼 Office Automation Agent-driven Excel/Word/PPTX editing on Canvas with live preview broadcast; formula-evaluating workbook runtime; agent↔document sync
🧩 Mini-Apps Agent-authored stateful canvas apps — Firecracker microVM isolation, per-instance chat
🔍 GraphRAG & Intelligence Multi-hop expansion, Leiden community detection, JIT fact verification, D3 visual explorer
🌐 46+ Business Integrations Salesforce, HubSpot, Slack, Teams, Gmail, Notion, Jira, Linear, Stripe, QuickBooks, Shopify, GitHub, GitLab, Zoom…
🛰️ LLM Gateway OpenAI/Anthropic-compatible API over your BYOK — point Claude Code, n8n, or any OpenAI-SDK app at Atom
💰 Cost-Aware Routing 5-tier cognitive classification, 16+ providers, opt-in learning router (feedback-based re-ranking), RTK token compression
🤝 Interoperability MCP client for external tool servers, ACP endpoint for standard agent clients, A2A Agent Card + message/send for agent-to-agent delegation, span tracing with optional Langfuse export
🎯 Goal-Driven Loops Agents terminate on a definition_of_done predicate instead of always burning to max_steps; utility targets, custom action surfaces, stuck-detection

🛡️ Production-Ready Security (Default-On)

Layer What you get
Execution Sandbox Filesystem scope, tool whitelist, tripwires, resource caps, KillRun — enforced at every tool-dispatch hub (in-process policy checks); mini-apps run in Firecracker microVMs
Encrypted Credentials OAuth integration tokens encrypted at rest (Fernet); production fails closed without key
Per-Agent Capability Bindings Zero-trust tool scoping — agent can never exceed its tier floor
Outbound Gatekeeper Rate limiting, response masking, HITL mutation approval on integration calls
Data-Taint Tracking Restricted data observed in a run blocks external outbound actions
External MCP Client Connect to arbitrary external MCP servers (Cloudflare portals)

Security Architecture → · Sandbox Deep-Dive →


📚 Documentation & Discoverability


🎯 Example Use Cases by Department

Department Scenario Key Integrations
Sales New HubSpot lead → Research company → Score → Asana task → Slack notify HubSpot, Asana, Slack, LinkedIn
Finance Gmail PDF invoice → OCR extract → QuickBooks match → Flag discrepancies Gmail, QuickBooks, Excel, Slack
Support Zendesk ticket → Sentiment analysis → Auto-escalate urgent → Draft reply Zendesk, Slack, Email
HR BambooHR new hire → Provision accounts → Invite to Slack → Schedule orientation BambooHR, Google Workspace, Slack, Calendar
Engineering GitHub PR → Run tests → Security scan → Post summary → Auto-merge if green GitHub, GitLab, Slack, Jira
Marketing Content calendar → Generate posts → Human review → Schedule multi-platform Notion, Slack, LinkedIn, Twitter, Meta

🏗️ Repository Layout

atom/
├── backend/            # FastAPI app — main_api_app:app (full) / minimal_app:app (smoke)
├── frontend-nextjs/    # Next.js web UI
├── mobile/             # React Native (Expo) companion app
├── menubar/            # Tauri macOS menubar companion
├── scripts/ · infra/ · installer/ · examples/
├── docs/               # project documentation
├── Dockerfile          # dual-app image (backend + frontend)
└── Makefile            # common tasks (start here)

🌟 Why Teams Choose Atom

Per-competitor analysis: 📊 Comparisons ↑

Atom Zapier/Make/n8n LangGraph/CrewAI OpenClaw LangChain
AI Agents (reason, not just execute) ✅ ❌ ✅ ✅ ✅
Governance (maturity + HITL + audit) ✅ ❌ ❌ ❌ ❌
Outcome verification (re-derived from system of record, not self-report) ✅ ❌ ❌ ❌ ❌
Default-on Sandbox (all dispatch paths) ✅ ❌ ❌ ❌ ❌
Self-Hosted / Private (your keys, your infra) ✅ ❌ ✅ ✅ ✅
Office/Canvas Native (Excel formulas, co-edit) ✅ ❌ ❌ ❌ ❌
Agent-Authored Workflows (chat to build) ✅ ❌ ❌ ❌ ❌
46+ Business Integrations (CRM, finance, support) ✅ ✅ — 50+ personal —
Cost-Aware LLM Routing (16+ providers) ✅ ❌ ◐ ◐ ◐
Mini-Apps (agent-authored stateful apps) ✅ ❌ ❌ ❌ ❌
GraphRAG / Episodic Memory ✅ ❌ ◐ ◐ ◐

🤝 Contributing & Support

We welcome contributions — see CONTRIBUTING.md. Quality bar: CI-gated core suite green, typecheck clean on changed files, review required, docs updated. See docs/compliance/COMPLIANCE_MAPPING.md for the security/compliance control mapping.


Built with FastAPI | SQLAlchemy | LangChain | Playwright | Next.js

Experience the future of self-hosted AI automation — safe enough for your whole team.

⭐ Star us on GitHub — it helps!

Frequently asked questions

Is atom free to use?

atom is open source under the AGPL-3.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does atom do?

Atom Agent, Open-Source Governed AI Agent Platform for Self-Hosted Automation

What is atom written in?

atom is primarily written in Python. Its source is publicly available at https://github.com/rush86999/atom, and it has 911 GitHub stars.