> Original repo: pacifio/atlas · Rust · MIT · +895 stars in a single day (2026-09-02)
A Chilling Question
You ask Claude Code to modify an auth module. It finishes, and the commit message is perfectly conventional. Three months later, a production bug appears — token refresh deadlocks in an edge case. You run git blame, and the line was written by an agent, with a commit message like "fix: handle token refresh edge case".
Then what?
Then you find nothing. The agent's reasoning at the time, which files it read, why it chose this approach over another — all of it evaporated when the terminal closed. Git records *what* changed, but not *why*.
pacifio/atlas targets exactly this gap. Its positioning is blunt: source control for agents — version control for agent-written code that records not just the code, but the entire thought process behind it.
Checkpoint: A Black Box for Commits
Atlas's core concept is the checkpoint. A checkpoint isn't just "which session produced which commit" — it binds four things together:
1. Prompt: what you asked at the time 2. Tool calls: which tools the agent invoked, with what arguments 3. File changes: which files changed and how 4. Reasoning: the agent's chain of reasoning
All of it is stored in a SQLite database under the project's .atlas/ directory. A key design decision: secrets are scrubbed on write — redacted before hitting disk, not before upload. That works because Atlas is fully local by default: no account, no network required.
One noteworthy detail: checkpoint links survive rebases and amends. Atlas uses patch-id reconciliation — when git rebase rewrites history, it re-associates commits with sessions via a hash of the patch content. If a squash makes the link genuinely ambiguous, it chooses to orphan the session rather than guess. That's more rigorous than most git tooling.
Multi-Agent Parallelism: Shared Memory, Not a Shared Context Window
Atlas's other core capability is letting multiple agents work in parallel on the same codebase. Claude Code, Codex, Atlas's own agent (built on the Rust-based Cersei framework), and any agent in the ACP registry (Cursor, OpenCode, Kilo Code, etc.) can run in the same window.
There's a design decision worth unpacking. Atlas doesn't try to build a "universal agent" — instead it builds an agent-agnostic context layer. All agents connect via the Agent Client Protocol (ACP) and go through the same send path. Before a message reaches an agent, Atlas injects five layers of context:
| Injected content | Source | Timing |
|---|---|---|
| @ mentions | Local Rust parser: files, folders, symbols, branches, commits, notes, papers, historical sessions | Every turn |
| Shared agent memory | Active plans, decisions, file changes, failures, architecture notes written by any agent | Every turn |
| Semantic matching | Your message is embedded locally and matched against the project memory index via HNSW search | Every turn |
| Session handoff | A curated fact pack plus the tail of the previous session — even if the previous session ran on a different agent | First message |
| Existing docs | CLAUDE.md, AGENTS.md, Claude Code memory files, Codex history — folded into one index | Continuous |
The implication: decisions made by Claude Code are visible to Codex in the next session, and vice versa. Two agents' memories are bridged — not by sharing a context window (which would explode), but through a local semantic index.
One clever detail: when you @ a 5,000-line file, Atlas sends the agent a path, not the file contents. The agent reads it when needed, so a single @ mention doesn't occupy the context window for the rest of the session.
Why Is This Growing?
+895 stars in one day isn't the top of GitHub Trending, but for a macOS-first desktop app (built with Tauri; Linux/Windows build from the same code but are untested), that level of attention means it has hit a real pain point.
The pain point: agents are writing more and more of the code, but auditability is near zero.
Imagine: a team of 5 developers, each writing 2,000 lines a day with Claude Code. A month later, the codebase contains 300,000 lines of agent-written code. When a bug appears, git blame shows nothing but "Claude Code" commits. You don't know the prompt, which files the agent read, or why it chose that approach.
This isn't hypothetical — it's the real state of many teams in 2026. By binding those four things together, Atlas is essentially building auditability infrastructure for agent-written code.
Relationship with Git: Enhancement, Not Replacement
Atlas is not another git. It depends on git and adds a layer of "reasoning metadata" on top. Whether you commit with a terminal, another editor, or with Atlas closed, it can associate commits back to sessions by observing git history.
This design choice is critical: Atlas doesn't intercept commits — it observes them. You don't need to change any existing workflow. Atlas works quietly as a passive recorder alongside you.
A Thought-Provoking Architectural Choice
Atlas stores session data in SQLite rather than markdown or JSON. The README explains: "because it is queried, not read."
That's an engineering-minded judgment. Session data is high-volume, structurally complex, and queried in diverse patterns (by time, file, agent, keyword) — SQLite beats a pile of markdown files by a wide margin. Meanwhile, the knowledge base (human-written notes) remains markdown, because that's "meant to be read."
Match the storage medium to the usage pattern — a simple principle many tools fail at. Notion stores everything, including notes that should be markdown, in a database; many agent frameworks cram everything, including structured session data, into markdown files. Atlas gets this layering right.
Limitations and Open Questions
- macOS-first: Linux and Windows build from the same Tauri code but are "untested," limiting the audience.
- ACP dependency: agents must support ACP to be managed by Atlas. Claude Code and Codex are the "most-tested path"; other registry agents are "QA ongoing."
- The cost of local-first: team collaboration requires signing in to create an organisation for sync. Conflict resolution for the local SQLite store isn't documented in detail.
One-Sentence Takeaway
Atlas puts a black box on agent-written code — not replacing git, but adding an auditable layer of "who changed what, when, and why" on top of it. As the share of agent-written code keeps rising in 2026, someone was bound to build this infrastructure. Atlas's timing is good.
GitHub: https://github.com/pacifio/atlas Docs: https://docs.tryatlas.cc/