Atlas: The Open-Source Source Control System With 3,000+ GitHub Stars Built for AI Coding Agents

What Is Atlas?

If you've been using AI coding agents like Claude Code, Codex, or Cursor, you've probably hit the same wall: every session starts from zero. Switch agents mid-task and you lose all context. Review what an agent did last week? Good luck.

Atlas solves all of this. It's a Rust-based IDE and source control system designed from the ground up for the age of AI-assisted coding. Instead of treating agents as disposable terminals, Atlas gives them persistent memory, cross-agent context sharing, and full audit trails tied directly to your git history.

Built by pacifio and already at 3,000+ GitHub stars (gaining 888 in a single day), Atlas is one of the fastest-growing developer tools on GitHub Trending right now.

How Atlas Changes the Agent Workflow

1. Checkpoints: Every Commit, Fully Explained

A traditional git commit tells you what changed. A checkpoint tells you why.

Atlas links every commit back to the exact agent session that produced it — including the prompts, tool calls, reasoning, and file changes. Months later, you can select a checkpoint and chat with it to understand exactly what happened.

# A checkpoint captures:
- Which agent made this commit (Claude Code? Codex? Atlas native?)
- The exact prompts that led to the change
- All tool calls and their outputs
- File-level diffs of what actually landed
- Secrets scrubbed before anything touches disk

Links survive rebases and amends through patch-id reconciliation. If a squash makes the link ambiguous, it orphans rather than guessing.

2. Multi-Agent Sessions: Run Any Agent Side by Side

Atlas doesn't lock you into one AI provider. Run Claude Code, Codex, Atlas's own Cersei-powered agent, or anything from the ACP (Agent Client Protocol) registry — all in the same window, against the same codebase.

# Supported agents (via ACP registry):
- Claude Code (subprocess via ACP)
- OpenAI Codex (subprocess via ACP)
- Atlas Native Agent (in-process via Ceresi, Rust framework)
- Cursor, OpenCode, Kilo Code, and more
- Any ACP-compatible agent

Sessions are independent of tabs, so switching never drops a run in flight. You can have three agents working in parallel on different aspects of the same project.

3. Shared Memory: One Brain, Every Agent

This is where Atlas gets genuinely innovative. A decision Claude Code made shows up in Codex's next prompt automatically. Plans, file changes, failures, and architecture notes are shared across all agents through an on-device semantic index.

The memory system uses local embeddings with HNSW (Hierarchical Navigable Small World) search. Every turn, Atlas:

• Injects shared agent memory — active plans, decisions, file changes from any agent
• Runs semantic matches — embeds your message on-device and matches against the project's memory index
• Provides session handoff — first message of a new session gets a curated fact pack plus the tail of your last session
• Folds in existing context — CLAUDE.md, AGENTS.md, Claude Code's memory files, and Codex's history all become one index

Embedding runs on your machine. Retrieval never leaves the device.

Real-World Example: Migrating a Feature Between Agents

Here's a scenario every AI-assisted developer knows: you start a feature with Claude Code, hit a wall with a complex refactoring, and want to switch to Codex.

Without Atlas: You open Codex, re-explain the entire architecture, paste relevant files, describe what you tried. Twenty minutes wasted, context still incomplete.

With Atlas: Open a new Codex tab. Atlas automatically injects the session handoff — Codex sees Claude Code's decisions, the current plan, files changed, and failures encountered. Your first message might be: "Continue the auth refactor, try a middleware approach instead." Codex has full context from turn one.

# What Codex receives automatically on first message:
1. Active plan from Claude Code's session
2. File changes and their rationale
3. Architecture decisions made (and why)
4. Failures encountered and lessons learned
5. Tail of the last conversation for continuity

The @ Mention System: Context at Your Fingertips

Atlas resolves @ mentions locally in Rust before the prompt is sent. You can reference:

• Files and folders — resolves to a path, not a paste (a 5,000-line file sends a pointer the agent reads on demand)
• Symbols — function names, classes, variables
• Branches and commits — bring git context into the conversation
• Notes and papers — from the built-in knowledge base and research tools
• Past sessions — reference previous agent conversations directly

This means one @ mention doesn't occupy the entire context window. Smart resolution keeps your agents focused.

Key Benefits

• 🔒 Local by default — Code, notes, and sessions stay on your machine. No account required.
• 🧠 Persistent agent memory — No more starting from zero every session.
• 🔄 Agent portability — Switch between Claude Code, Codex, and others without losing context.
• 📝 Full audit trail — Every commit linked to the session, prompts, and reasoning behind it.
• ⚡ Rust performance — Built with Tauri, runs natively on macOS with Linux/Windows support coming.
• 🔓 Open source (MIT) — No lock-in. Notes are markdown, sessions are JSONL, the editor is a file on disk.
• 🔬 Research integration — Search arXiv and Semantic Scholar, read papers in-app, and @-mention them into prompts.

Getting Started with Atlas

Download the latest .dmg from tryatlas.cc or the GitHub releases page.

To build from source:

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

Requires Bun, Rust (stable), and Xcode Command Line Tools. The first Rust compile takes a few minutes; after that, incremental builds are seconds.

To use Claude Code as an agent, install the claude CLI and put it on your PATH. Atlas's native agent needs no external CLI.

FAQ

What is Atlas?

Atlas is an open-source source control system and IDE built specifically for AI coding agents. It provides persistent memory, multi-agent sessions, and checkpoint-linked commits that tie every code change back to the agent session that produced it.

Is Atlas free?

Yes. Atlas is completely free and open-source under the MIT license. You can use it without an account, and all features work locally without any subscription.

Which AI agents does Atlas support?

Atlas supports Claude Code, OpenAI Codex, its own native Cersei-powered agent, and any agent compatible with the Agent Client Protocol (ACP) — including Cursor, OpenCode, and Kilo Code.

Does Atlas send my code to external servers?

No. Atlas is local-first. Your code, notes, sessions, and embeddings all stay on your machine. Nothing is uploaded to run an agent. Accounts and sync are entirely opt-in.

What platforms does Atlas support?

macOS is the primary supported platform with native .dmg downloads. Linux and Windows can build from the same Tauri codebase but are currently untested.

How does shared memory work between agents?

Atlas uses on-device embeddings with HNSW search to create a semantic index of all agent activity — decisions, plans, file changes, and architecture notes. Every agent reads from and writes to this shared index, so context flows naturally between Claude Code, Codex, and other agents.

Ready to try Atlas? Download it from tryatlas.cc or star the GitHub repo to follow development.

Looking to level up your coding skills? Check out CoddyKit's interactive courses — learn by doing with real-world challenges.