How to get multiple AI agents to work together in one repository without losing context

When you write code alongside neural networks every day, you quickly hit the same wall. You launch Claude Code to refactor a module, switch to Codex to write a couple of functions, open a separate chat to check an architectural idea. In the end, each agent starts from a blank slate, completely forgetting why we rejected a particular library five minutes ago.

All context is lost. Commits only contain dry diffs, while the model's thoughts and reasoning disappear in a closed terminal.

The folks at pacifio decided to tackle this systematically and released Atlas. It's a local workspace and version control system for AI agents that ties their memory together and links every commit to the session where it originated.

The core idea

The authors call the project "source control for coding agents." The concept is straightforward: if autonomous agents are writing code, we need a tool that tracks not just file changes, but the chain of reasoning behind them.

Atlas can launch multiple agents in parallel across different tabs. For example, Claude Code and Codex run as external sub-processes via the ACP (Agent Client Protocol), while Atlas's built-in agent runs directly in the process on its own Rust framework called Cersei.

The most interesting part happens at the context level. Before your prompt reaches the model, Atlas assembles a unified picture around it:

• Injects shared agent memory: the current plan, decisions made, errors, and architectural notes created by any other model in the project.
• Resolves files, folders, functions, git branches, notes, and even research papers locally via @.
• Appends the previous session tail and a summary of facts, even if the last task was solved by a different assistant.
• Builds local vector embeddings and searches for relevant chunks via HNSW without sending data to third-party servers.

The result: Claude sees the conclusions Codex reached, and Codex knows which tests just failed for Claude.

Checkpoints and commit linking

Usually, after an agent finishes its work, a commit appears in git, and a week later nobody remembers which prompt generated it.

Atlas saves sessions to a local SQLite database at .atlas/sessions.db. The program monitors commits from the outside rather than forcibly intercepting them. You can commit code through the standard terminal, VS Code, or even with Atlas closed. The app matches patches and links the commit to the agent session that wrote that code.

Links don't break during normal git rebase or git commit --amend thanks to patch-id verification. If you do a squash and the link becomes ambiguous, Atlas doesn't try to guess—it honestly marks the session as detached.

A nice touch: all secrets and tokens are scrubbed from logs before data touches the disk.

Inside the workspace

Atlas is built not just as a background daemon, but as a full-featured desktop work environment. Under the hood it's a combination of Tauri, Rust, and a web interface based on Bun and TypeScript.

Everything needed for daily work is included:

1. A code editor based on CodeMirror with state persistence across restarts.
2. A full-featured Git client with a visual commit graph, branches, and diffs.
3. A block terminal where each executed command stores its output, exit status, and duration. Full-screen utilities like vim and htop also work normally.
4. A knowledge base in the .atlas/knowledge/ folder. These are regular Markdown files that are versioned alongside code. Backlinks, link graphs, and HTML export are supported.
5. Research paper search via arXiv and Semantic Scholar with the ability to read PDFs in-app and send links to prompts via @.
6. A built-in browser based on the WebKit engine with support for logins and reading mode.

All project files remain regular files on disk. Notes are in Markdown, canvases in JSON, sessions in JSONL. If you close the program, you can calmly continue working in your favorite editor without losing access to your data.

How to run the project locally

macOS binaries are available as .dmg on the official website and in GitHub releases. Building on Linux and Windows is possible from source, though the developers note these platforms are currently less tested.

For local builds, you'll need Bun, stable Rust, and the Claude CLI client installed (if you plan to use Anthropic's agent).

Installing dependencies on Ubuntu or Debian:

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

Building and running in development mode:

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

The initial Rust compilation takes a couple of minutes, but subsequent incremental builds complete in seconds.

Who will find Atlas useful

The project will appeal to developers who actively experiment with multiple AI assistants and are tired of manually copying context between terminal windows.

There's no forced cloud subscription for basic features here: everything works offline, databases are stored in the project directory, and code doesn't leak anywhere. If you're looking for a way to organize your workflow with agents and preserve the history of their decisions for your team or for yourself a month from now, the repository is definitely worth checking out.