atomic-agent

A local-first operator agent runtime that squeezes the maximum out of models on your own machine — turboquant llama.cpp, curated quants, and a runtime engineered for local inference. The machine on your desk, not in somebody else's cloud.

atomic-agent is a compact agent runtime that can operate a real desktop: browser, files, shell, documents, git, local memory, scheduled work, approvals, traces, Telegram, MCP servers, and Tauri sidecars.

It is built for the OpenClaw / Hermes / OpenCUA class of operator agents, but every layer is engineered to squeeze the maximum out of local models running on your own machine. In managed mode it ships turboquant — a purpose-built llama.cpp backend (AtomicBot-ai/atomic-llama-cpp-turboquant) paired with curated quantized GGUF weights — and the whole runtime is tuned around it: KV-cache reuse via a byte-stable prompt prefix, grammar-constrained tool calls, small bounded prompt tails, resource-aware parallel read batches, and fully inspectable local state. The payoff is concrete: on the same hardware, a small quantized model behaves like a capable operator instead of a toy — see Benchmarks.

Developer Preview / Active Development: APIs, commands, config, and behavior are still moving. Expect sharp edges, and pin a release if you need a stable integration point.

Platform availability: current releases are available for macOS. Linux and Windows builds are coming soon.

Benchmarks

On the public GAIA validation Level 1 split (53 tasks), atomic-agent and Hermes drove the same local qwen-3.6-35b-a3b (llama-server, UD-Q4_K_XL), with the same step budget and timeout. The only variable is the agent runtime.

atomic-agent: +11.3 pp more accurate, ~1.6× faster per task — same hardware, same model, same budget.

xychart-beta
    title "GAIA L1 accuracy — higher is better (%)"
    x-axis ["atomic-agent", "Hermes"]
    y-axis "Accuracy (%)" 0 --> 100
    bar [69.8, 58.5]

xychart-beta
    title "Avg wall time per task — lower is better (s)"
    x-axis ["atomic-agent", "Hermes"]
    y-axis "Seconds / task" 0 --> 400
    bar [217, 351]

Full reproducible write-up: eval-agents/docs/GAIA-L1-EXPERIMENT.md. Raw artifacts (matrices, NDJSON traces, logs): gaia-l1-eval-2026-06-11 release.

Why It Maxes Out Local Models

Everything is tuned to get the most out of a model running on your hardware:

• turboquant llama.cpp — a purpose-built backend (AtomicBot-ai/atomic-llama-cpp-turboquant) shipped in managed mode, tuned for throughput on consumer machines.
• Curated quantized models — hand-picked GGUF quants (UD-Q4_K_XL and friends) that keep quality high while fitting real VRAM budgets.
• KV-cache reuse — a byte-stable prompt prefix plus slot affinity reuse the cache across steps instead of re-encoding the world every turn.
• Grammar + bounded prompts — GBNF tool-call grammar, small bounded prompt tails, and resource-aware parallel read batches keep every inference cheap and valid.

Quick Install/Update

curl -fsSL https://api.atomicbot.ai/agent-install | sh

The installer downloads the release archive, verifies the checksum, and installs the CLI plus runtime assets such as grammars/, native prebuilds, and bundled ripgrep.

Run

atomic-agent

Why Enthusiasts Care

Most agent products ask you to rent the control plane. Your files, browser context, prompts, traces, tool outputs, and usage patterns move through a hosted service, then the bill follows the token stream.

atomic-agent takes the enthusiast route:

• Run the agent loop locally.
• Bring your own llama-server, or let the CLI manage one.
• Keep sessions, memory, tasks, traces, skills, browser profile, and config under <stateDir>.
• Inspect the prompt, replay trace drift, edit skills, and replace parts without waiting for a vendor.
• Use cloud providers only when you deliberately configure them.

This is for people who like local models, terminal UIs, SQLite files, trace logs, hackable runtimes, and software that can be understood all the way down.

The Core Idea

A local model can operate software if the runtime stops wasting its context.

atomic-agent does not treat the model like an infinite planner. One inference produces one JSON array of tool calls. The runtime executes those calls, compresses the results, updates durable state, and asks the model for the next move.

user message
  -> compact prompt
  -> llama-server completion with tool-call grammar
  -> JSON array of 1..N tool calls
  -> resource-aware execution
  -> compressed results and durable state
  -> repeat until reply, finish, cancel, or max steps

The model chooses actions. The runtime owns the loop, the state, the approvals, the traces, and the failure boundaries.

What Makes It Different

Local-Model Native

• Stable prefix: persona, rules, tools, skills, capabilities, and instructions stay byte-stable inside a session so cache_prompt and slot_id can reuse KV-cache.
• Bounded tail: conversation, memory, world state, recalled notes, lessons, procedures, and loaded skill bodies are clipped into a predictable prompt budget.
• Externalized state: sessions, memory, tasks, skills, traces, browser snapshots, and model config live outside the prompt.
• GBNF tool calls: completions are constrained into a JSON array of tool calls, including the solo case [{...}].
• Parallel read batches: independent read-only calls can run concurrently after a single inference; dangerous actions remain approval-gated.
• Compact browser view: ordinary web operation uses accessibility / ARIA snapshots instead of screenshot-heavy page dumps.

This is architecture, not prompt superstition.

Real Operator Surface

atomic-agent can work across the local machine:

• Browser: navigate, click, type, inspect tabs, and read compact browser state through playwright-core against Chrome, Edge, or another Chromium-family browser.
• Filesystem and shell: read, write, patch, glob, grep, archive, hash, inspect processes, use clipboard, send notifications, and run approved commands.
• Documents: extract text from PDF, DOCX, DOC, XLSX, RTF, ODT, PPTX, archives, and plain text locally.
• Git: status, log, diff, show, blame, and branch inspection.
• Skills: Markdown playbooks with optional approved scripts; full skill bodies load only when needed.
• Memory: profile facts, notes, hybrid recall, links, lessons, procedures, voting, reflection, and bounded prompt rendering.
• Tasks: durable deferred turns, cron schedules, intervals, webhooks, and agent-created reminders.
• Vision: optional vision.describe for multimodal models with mmproj, kept outside the normal text transcript.
• Providers: local llama-server by default, plus OpenAI-compatible and OpenRouter-style providers for text or embeddings when configured.
• MCP: connect external MCP servers and expose their tools, resources, and prompts through the same tool registry.
• Telegram: single-user remote control with owner pairing and inline approval buttons.

Dangerous actions are routed through approvals. Read-heavy exploration stays fast.

Memory That Feels More Human

atomic-agent memory is not a giant chat log pasted back into the prompt. It is shaped more like human memory: durable identity, episodic notes, associations, distilled lessons, reusable procedures, and feedback from experience.

People do not remember by replaying every second of their life. They remember facts about themselves, recall relevant episodes, connect related ideas, learn principles from repeated outcomes, and develop procedures for familiar work. The runtime mirrors that pattern in a bounded, inspectable way:

• Profile facts render into ### profile with contextual keyword gating.
• Notes are stored in SQLite + FTS5, optionally paired with embeddings for hybrid recall.
• Links connect related memories into a bounded graph.
• **Lesso