Trusted by engineers at
Source control for agents. Use multiple coding agents, track their changes and query them in one place.
Run any agent. Claude Code, Codex, OpenCode, Atlas's own agent, or anything from the registry — side by side, against the same codebase. Agents keep their own authentication and model choices. Switch mid-task without starting over. Try the picker.
Read the docsDone. Every handler now runs behind an idempotency guard keyed on the event id. A replayed event returns the cached 200 instead of re-running the side effects.
Ledger writes are untouched, as asked. The guard sits one layer above them in webhooks/guard.ts, so a retry never reaches the ledger at all.
Verified. 38 handler tests pass, plus 6 new ones that replay each event twice and assert a single ledger row.
Every thread gets its own session worker, so you can fan work out across agents and projects simultaneously — one writing tests, one refactoring, one researching — and watch each one stream its tool calls live.
An Arc-style switcher holds all your projects in a single window. Hit ⌘. to flip between them — each carries its own editor tabs, terminals, git state, and agent threads, restored exactly as you left it.
+/− at a glance.
The record of what an agent did disappears the moment the terminal scrolls. Atlas keeps it. Every session lands on the timeline. Every commit an agent makes becomes a checkpoint, linked back to the session that produced it. Open a session to read the prompt, the tool calls and the response, or ask it questions. Click a row.
.atlas/sessions.db next to the repo — yours to grep, export, or delete.
Make the Stripe webhook handlers idempotent. - keys in Redis, 24h TTL - don't touch the ledger writes - replay each event twice in tests and assert one ledger row
Every handler now runs behind an idempotency guard keyed on the event id. A replayed event returns the cached 200 instead of re-running the side effects. Ledger writes are untouched.
webhooks/guard.ts) — Redis keys, 24h TTLDrafts are edited together, live. Send one straight to an agent when it's ready.
Create an organisation. Invite people with a link. The same window grows channels, direct messages and calls with recordings and transcripts. Draft prompts together in real time. Sketch on a canvas per conversation. Hand any message straight to an agent. Everything is scoped to the organisation, so switching orgs switches the whole workspace. Open a channel, switch tabs, try the canvas.
Chat with agents, run terminals, read code, browse docs, and capture plans — without leaving the room. Atlas keeps the loop tight.
memory.ts to use streams.Claude Code, Codex, OpenCode — any ACP agent. Stream responses, watch tool calls, and intervene mid-flight.
Branches, merges, deploys — rendered inline. Click any commit to walk diffs without leaving your chat.
atlas_wrap() for memory + traces.Client, Session, Tool.Capture ideas as notes on an infinite canvas. Drag them into chat to give agents fresh context.
Atlas is a desktop application. Compact, AMOLED, fast. Every detail is tuned for ten-hour days at the keyboard.
Split panes, tabs, search across history. Agents share the same shell — no context smuggling.
Read docs, copy snippets, save to Knowledge — without losing your place. Atlas indexes what you save.
Every agent edit as a real diff — changed-files tree, minimap, hunk staging, conflict resolution. The view you'd use to review a PR.
Every agent action, every tool call, every commit — timestamped, searchable, replayable.
See exactly which files, symbols, and tests an edit will touch — before the agent commits a single line.
Per-thread token, call, and dollar counters live in the status bar. No surprise bills, ever.
A custom lane-assignment graph renders every branch, merge, and deploy as you actually committed it — not as a flat list. Click any node to see the diff inline, without leaving your thread.
git log --graph can't.
@branch in any thread to give the agent that branch's context.
Token-refresh is opportunistic, not scheduled. The frontend never sees the refresh token; it lives only in the keychain proxy.
tauri-plugin-stronghold.auth.refresh.failed event.Atlas treats your project's knowledge base as a first-class surface. Notes live as plain markdown in .atlas/knowledge/ next to your code — one source of truth, read by you and by every agent thread in the project.
CLAUDE.md & AGENTS.md — no migration. Atlas reads what's already there.
Pull files, folders, branches, knowledge notes, commits, and entire threads into your prompts. Atlas resolves the references locally and hands the agent exactly the context it asked for — nothing more.
@src/auth.ts#L40-80 sends a slice, not the whole file.
@branch, @commit, @knowledge/auth-flow. Same syntax.
@thread:plan-acp-driver gives the agent a teammate's prior reasoning.
CodeMirror 6 with first-class support for JS, TS, Python, Rust, Go, Java, C++, JSON, YAML, Markdown, SQL, CSS, HTML, XML. Files are real files — ⌘S writes to disk.
Drop notes onto a spatial board. Link them with edges. Pin the ones the agent should treat as context. Everything persists as plain JSON in .atlas/canvas.json — so your thinking versions with your code.
Three things to land before we can register Codex.
atlas-agentsWhat every ACP adapter must implement:
fn spawn(&self) -> Result<Stream>
How do we surface streaming bytes from a long-running adapter to the chat panel without coupling to Claude's JSONL shape?
The native agent's session lifecycle; Claude Code subprocess hand-off.
cargo test --workspace — approve?acp-driver.rs — 3 files changed, +47 -12, all tests pass.src/features/chat/lib/acp-api.ts (148 lines).knowledge/threads/acp.md.acp/codex-adapter from main.Every meaningful agent event — permission prompts, completed streams, tool calls, knowledge saves, branch operations — surfaces in a unified inbox. Approve, dismiss, jump back to the thread.
⌘⇧I from anywhere. Click a row to land in the source thread.
Every meaningful event — chat sends, tool calls, file edits, git ops, terminal commands, knowledge writes — flows through a 500-event ring buffer in memory plus an append-only pinned log on disk. Searchable, filterable, JSON-expandable per row.
~/.atlas/log/pinned.jsonl.
jq from your terminal.
| Time | Source | Kind | Summary |
|---|---|---|---|
| 37s ago | agent | stream-done | Refactored acp-driver — 3 files changed, +47 -12, all tests pass. |
|
{ "source": "agent", "kind": "stream-done", "sessionId": "a2b9727-634b-4129", "exitCode": 0, "durationMs": 18404 } |
|||
| 1m ago | canvas | note-add | New note: "ACP driver plan" |
| 2m ago | editor | file-save | app.rs · 24 lines changed |
| 2m ago | chat | send-agent | "Wire the codex adapter into the chat panel." |
| 4m ago | git | branch | Created branch acp/codex-adapter from main. |
Architectural rule: every piece of state and business logic lives in Rust. React is a view layer — it renders store snapshots and forwards intent over Tauri IPC, nothing more.
Why: a single source of truth survives window reloads and keeps performance predictable.
How to apply: new state goes in a Rust command + event, not a React hook. See [[permission-mode-sync]].
Atlas surfaces the memory your agents accumulate — Claude Code's per-project markdown and Codex threads — as a browsable, read-only inspector. Every fact, with its frontmatter, in one place.
name / type / description the agent keys recall on.
[[links]] — follow the chain of reasoning.
See the whole memory as a semantic graph — on-device embeddings cluster related facts and wikilinks draw the edges. Then scrub a timeline that lays commits, agent sessions, and memory on one axis to watch what your agents knew, and when.
Organisations, accounts, team chat and the session timeline are live. What is still missing is a knowledge base that humans and agents both consume across a team — the multiplayer half of what ships today.
The same markdown files, mirrored across the team. Humans read them in Atlas; agents consume them as system prompt. One source of truth, both audiences.
Save any agent thread to the team knowledge base. Teammates pick up exactly where the agent left off, with full reasoning history attached.
Incremental versioning for CLAUDE.md, AGENTS.md, and every knowledge note. Diff agent context the same way you diff code. Roll back when an instruction regresses behaviour.
Import knowledge from Jira and Confluence. Map tickets to threads, sync designs to notes. Stop copy-pasting context into prompts.
Open a ticket, post the prompt, gather team votes on the agent's plan, then approve the run. Plan and execution, no Notion ↔ Linear ↔ Slack pinball.
Aggregate knowledge and system traces across the team into shared reference indices. Every agent inherits the team's best context automatically.
The app is free and your own keys always work. Plans add seats, synced projects, session storage and included AI for the team. Questions, or help choosing? Ask us on Discord.
| Free $0/ month Get started | Pro $20/ month Upgrade | Team $100/ month Upgrade | Business $200/ month Upgrade | |
|---|---|---|---|---|
| Usage | ||||
| Members | 3 | 5 | 25 | 100 |
| Synced projects | Unlimited | 10 | 50 | Unlimited |
| Session storage | Standard | 10 GB | 100 GB | 500 GB |
| AI each month | Not included | $8 | $40 | $80 |
| Vectorization tokens / month | Unlimited | 20M | 100M | 300M |
| Meeting minutes / month | Standard | Standard | Standard | Standard |
| Features | ||||
| Shared Threads | Included | Included | Included | Included |
| Participants per thread | 8 | 8 | 8 | 25 |
| Concurrent Runs per thread | 4 | 4 | 4 | 10 |
| Remote Runs | Not included | Not included | Included | Included |
| Also included | ||||
| Highlights |
|
|
|
|
Free during the alpha. Bring your own keys. Native binary for Apple Silicon, Intel and Windows, no Electron. The Atlas account is optional — nothing is gated behind it.
