Atlas: Source Control for Coding Agents

What Atlas is

Atlas describes itself as “source control for coding agents.” It is a desktop application, built with Tauri and Rust, that records every coding-agent session in a project and links each resulting git commit back to the session that produced it: the prompts, the tool calls, the files touched and the reasoning. Atlas calls that link a checkpoint. The point is that months later you can ask why a piece of code looks the way it does and get the actual session history instead of a model-written commit message summarizing a diff.

The second half of the pitch is multi-agent work. Atlas runs Claude Code, Codex, its own native agent, or anything in the Agent Client Protocol (ACP) registry side by side against the same codebase, with a shared memory layer so a decision one agent made shows up in another agent's next prompt. It is aimed at developers who already use more than one coding agent and are tired of re-explaining context each session.

The README frames the problem in three parts: agents start from zero every session, switching agents loses the thread because Claude Code cannot read Codex's history and vice versa, and project context is scattered across a knowledge base, CLAUDE.md, AGENTS.md and each agent's own memory files.

How Atlas works

Atlas runs agents as they are and enriches what they see. Claude Code and Codex run as external subprocesses over ACP, which the README calls the most-used and most-tested path. Atlas Agent, the native agent, runs in-process on its own engine, described as a hard fork of an Apache-2.0 upstream. Other agents from the ACP registry (Cursor, OpenCode, Kilo Code and more are named) are spawned by pulling each one's official binary, and all of them go through the same send path.

Before a message reaches the agent, Atlas assembles context around it:

• @ mentions are resolved locally in Rust. Notes, skills, papers and past sessions are inlined; files and folders resolve to a path the agent reads on demand, so mentioning a 5,000-line file does not fill the context window.
• Shared agent memory (active plan, decisions, file changes, failures, architecture notes) is injected on every turn, regardless of which agent wrote it.
• Semantic matches: your message is embedded on-device and matched against the project's memory index using local embeddings and HNSW search.
• Session handoff: the first message of a session gets a curated fact pack plus the tail of the previous session, even if it came from a different agent.
• Existing context: knowledge notes, CLAUDE.md, AGENTS.md, Claude Code's memory files and Codex's history are folded into one index.

Session capture lives in .atlas/sessions.db, a SQLite file in the project's gitignored .atlas/ directory, with secrets scrubbed before anything is persisted. Commits are observed rather than intercepted, so a commit made from a terminal, another editor or while Atlas was closed still finds its session. Links survive amends and rebases through patch-id reconciliation; when a squash makes the link genuinely ambiguous, the README says it orphans the link rather than guessing.

Key features

• Checkpoints: each commit is linked to its agent session, and you can select a checkpoint and chat with it to recover what happened.
• Multi-agent sessions: Claude Code, Codex and the native agent selectable per session and running in parallel across tabs, with sessions independent of tabs so switching does not drop a run.
• Transcript import: backfills existing Claude Code history so the record starts before Atlas was installed.
• Skills and packs: SKILL.md files scoped globally or per project and symlinked into each agent's skills directory; packs install a GitHub repo of skills, subagents, commands and hooks discovered via the skills.sh index.
• Capture health: one OK, Degraded or Stopped signal per project, with a reason and next step.
• Mission control: a dashboard of agent usage over time, consumption breakdowns, timelines and a filterable log.
• Built-in workspace: a CodeMirror editor, a git commit graph with staging and diffs, a block terminal that records exit codes and durations, and split view up to three columns.
• Knowledge base: plain markdown in .atlas/knowledge/, versioned with the code, with backlinks, a link graph and HTML export.
• Research tab: search arXiv and Semantic Scholar, read papers in-app and @-mention them into prompts.
• Organisations: optional sign-in to sync across devices and teammates.

Getting started with Atlas

Prebuilt installers are on the project website and the GitHub releases page: a .dmg for macOS (Apple Silicon or Intel) and an .msi for Windows. To use the Claude Code agent, the claude CLI must be on your PATH; the native agent needs no external CLI.

Building from source requires Bun and stable Rust, plus Xcode Command Line Tools on macOS or the MSVC build tools on Windows:

git clone https://github.com/pacifio/atlas
cd atlas
bun install
bun run dev:app

Production builds:

bun run build:app       # macOS .app bundle
bun run build:app:dmg   # macOS .app + .dmg installer
bun run build:app:win   # Windows .msi installer

On Debian or Ubuntu, Linux builds need GTK and WebKit headers first:

sudo apt install -y libglib2.0-dev libgtk-3-dev libwebkit2gtk-4.1-dev

The README notes the first Rust compile takes a few minutes and subsequent ones take seconds.

Use cases

• Auditing agent-written code: trace a surprising change back to the exact prompt and tool calls that produced it, months after the fact.
• Switching agents mid-task: start a feature in Claude Code, hit a limit, continue in Codex without re-explaining the plan, since the handoff fact pack and shared memory carry over.
• Comparing agents: run several agents on the same codebase in parallel tabs and compare their approaches.
• Keeping project knowledge in the repo: write architecture notes as markdown in .atlas/knowledge/ and have every agent read them automatically.
• Research-heavy work: pull papers from arXiv into the project and reference them directly in prompts.

How Atlas compares

Atlas overlaps with several tool categories without fitting neatly into one. As a place to run agents, it competes with using Claude Code or Codex directly in a terminal; the difference is the session capture, cross-agent memory and context injection layered on top. As an editor, it is closer to agent-centric IDEs than to a plain git client, though it ships its own editor, terminal and git graph rather than integrating into an existing IDE. Its use of ACP, the protocol from the Zed project, means agent support follows that registry.

The README stresses lock-in avoidance: notes are markdown, canvases JSON, sessions JSONL, and the editor works on plain files, so you can close Atlas and continue in vim. The exception is the checkpoint database, which is SQLite because it is queried rather than read.

Things to know before adopting Atlas

• Platform support: macOS 13+ and Windows 10+ (x64) are supported. Linux builds from the same Tauri codebase but the README calls it untested.
• Telemetry is on by default: anonymous usage analytics collect coarse metadata, never code or prompts, according to the README. TELEMETRY.md documents what is collected and how to turn it off.
• Local by default: code, notes and sessions stay on your machine and session capture works offline with no account. Sync is opt-in through organisations.
• Registry agent QA is ongoing: the README says testing of the long tail of ACP registry agents is still in progress.
• Very young project: the repository was created in May 2026. Expect fast change; contributions target the current version branch rather than main.
• License: Apache-2.0, which is permissive and includes a patent grant.

Project activity

As of October 2026 the pacifio/atlas repository has roughly 8,700 stars. It was created on May 14, 2026, is written primarily in Rust (with a Bun-built frontend), and is licensed under Apache-2.0. Downloads and documentation are available from the homepage at tryatlas.cc, and the project runs a Discord community.