Atomic Agent
A local-first AI agent that runs on your machine, with local or cloud models, driving your browser, files, shell, and memory.
Evidence shows approval gates for shell, file writes, HTTP, etc., privacy and egress documentation, anonymous analytics on by default but can be disabled, state files stored locally. Deductions: sensitive data handling incomplete (.env secrets inherited by skills and shell), dependency security lacks audit or lockfile, rollback mechanism only mentions update prompt restart, source attribution unverified publisher.
Self-consistency: README and package.json descriptions align, feature list matches code structure. Dependency availability: Node>=25.7 requirement is high, may limit environments; no lockfile provided. Failure messages: failure taxonomy and error handling described, but no concrete examples.
Audience clear (developers, local model users), scenarios diverse (TUI, CLI, HTTP, sidecar, Telegram). Capability boundaries clear (tool list, approval gates). Trigger precision: commands and config explicit. Environment fit: multi-platform support, but Linux depends on external tools, browser not bundled.
Information architecture clear (README structure complete). Install notes detailed (curl, PowerShell). Naming stability: APIs and commands still moving, pin version advised. Examples and FAQ: example commands and config, but no FAQ. Known limitations: developer preview and platform limitations noted. License: MIT. Versioning changelog: no CHANGELOG provided, but version numbers exist. Maintenance responsibility: maintainers not specified, publisher unverified.
Output usability: multiple usage modes, output formats clear. Marginal value: local-first, no API costs, inspectable state, unique value. Cost benefit: local models reduce API costs, but require hardware and setup.
Claim traceability: GAIA benchmark has docs and raw data links, but full reproduction steps not provided. Cross-source corroboration: single source only, no independent verification. Fact-inference separation: README distinguishes facts and inferences, but some claims (e.g., performance gains) lack independent verification.
- Publisher unverified, identity unknown.
- Sensitive data handling incomplete: .env secrets may be inherited by skills and shell commands, caution advised.
- Dependency security lacks audit or lockfile, recommend checking for vulnerabilities.
- APIs and commands still moving, pin version for production.
- Anonymous analytics on by default, privacy consideration.
What does this agent do, and when should you use it?
Atomic Agent is a local-first AI agent that runs the control loop and all state on your machine, not a hosted service. It drives your desktop: browse, read and edit files, run approved shell commands, inspect documents, remember context across sessions, schedule follow-ups, and call external tools over MCP. It is llama.cpp first, so small quantized models stay useful for long, multi-step work on consumer hardware. All state lives on your disk as plain files and SQLite databases, and it offers safety features like approval gates, append-only traces, and prompt drift replay. It can be used via CLI, TUI, HTTP server, Tauri sidecar, or Telegram remote control, and supports importing from Hermes or OpenClaw.
Atomic Agent runs an agent loop: a compact prompt goes to a local model, which returns a JSON array of tool calls. The core executes them, with independent reads running in parallel and risky actions requiring approval. Results and state are summarized, not pasted back in full, and the loop repeats until done. Concretely, it can navigate and interact with web pages via playwright-core, search the web (Exa, DuckDuckGo, Brave, SearXNG), make HTTP requests, read/edit files, run shell commands (approval-gated), extract text from PDFs and Office documents, perform Git read-only operations (status, log, diff, show, blame), manage memory (profile facts, notes, lessons, procedures) and tasks (cron, webhooks), run Markdown skills, and connect to external MCP servers. It also provides a Telegram bot for single-user remote control, with inline approval buttons and optional task reports.
- A developer wants a private AI assistant to automate browser workflows, file edits, and shell commands in a local development environment, without sending code to the cloud.
- A privacy-conscious user in a regulated industry needs an AI agent that runs entirely on-premises with local models, minimizing network egress.
- A power user wants to schedule daily reports from their local agent, receiving results via Telegram on their phone.
- A developer building a desktop app wants to embed an AI agent with full tool access, using the Tauri sidecar interface.
- An existing Hermes or OpenClaw user wants to migrate their setup seamlessly, using the /import command to carry over sessions, cron jobs, and provider keys.
- A user on consumer hardware wants to run a capable agent with a small local model (e.g., 9B) that still performs well on complex tasks.
What are this agent's strengths and limitations?
- Local-first architecture keeps control loop and state on your machine, eliminating per-token fees and ensuring privacy by default.
- Optimized for small local models via TurboQuant, achieving +30-50% throughput and state-of-the-art performance on GAIA L1 (69.8%).
- Rich tool surface: browser automation, filesystem, shell, documents, git, memory, tasks, skills, MCP, and Telegram.
- Comprehensive safety and observability: approval gates, append-only traces, prompt drift replay, failure taxonomy, and no-progress guard.
- Flexible deployment: CLI, TUI, HTTP server, Tauri sidecar, or Telegram.
- Developer preview: APIs, commands, config, and behavior are still moving, so you need to pin releases for stability.
- Requires configuration of llama-server and browser; browser binaries are not bundled, and external llama-server requires manual setup.
- Anonymous usage analytics enabled by default; must be manually turned off via /privacy analytics off.
- Managed local models only for Linux x64; other platforms (e.g., arm64) need external llama-server.
- Requires Node.js >= 25.7, which may be a high bar for some environments.
How do you install or deploy this agent?
Atomic Agent provides one-command installation scripts. On macOS/Linux, run: curl -fsSL https://atomicagent.io/install | sh. On Windows (PowerShell), run: irm https://atomicagent.io/install.ps1 | iex. The installer downloads the release archive, verifies checksum, and installs the CLI and support assets (grammars, native prebuilds, bundled ripgrep). For development, you need Node.js >= 25.7. Runtime requirements include a reachable llama-server (managed by the CLI or external), a Chromium-family browser (Chrome, Edge, etc.), and git.
How do you use this agent?
After installation, run atomic-agent tui to start the interactive console, or use atomic-agent run --cwd /path/to/work for a simple session. You can manage local models via CLI: atomic-agent models update, atomic-agent models pull qwen-3.5-4b, atomic-agent models use qwen-3.5-4b. For external llama-server, set env ATOMIC_AGENT_LLAMA_URL=http://127.0.0.1:8080 and start the server. To run as an OpenAI-compatible HTTP service, use atomic-agent serve --host 127.0.0.1 --port 8787 --cwd /path/to/work --api-key $ATOMIC_AGENT_API_KEY. For Tauri sidecar, send newline-delimited JSON requests over stdio. For Telegram remote control, enable it in config.json and set TELEGRAM_BOT_TOKEN.
How does this agent compare with similar options?
Compared to Hermes, on the GAIA Level 1 benchmark, Atomic Agent with the same local model achieves 69.8% accuracy versus 58.5% for Hermes, and has lower average wall-time per task (~217s vs ~351s).