Skip to content
atlas
DocsInstall Atlas

The memory layer for AI agents

Your AI should remember what it learns.

Atlas helps AI coding agents retain project context, decisions, and knowledge across working sessions.

Install AtlasExplore how it works

An MCP server for Claude Code. Memories are written to Walrus Memory on mainnet, with the blob id kept as onchain proof.

Assembling core
Indexing archive
02What is Atlas

Your context shouldn’t reset when the chat does.

Atlas is an MCP server. It reads your repository, writes what matters to Walrus Memory, and hands the same context back the next time an agent opens the project.

  • Repository contextatlas_get_repository_context
  • Architectural decisionsatlas_record_decision
  • Open tasksatlas_get_open_tasks
  • Memory searchatlas_search_memory
  • Session handoffsatlas_create_handoff
  • Tech stackatlas_scan_repository

Nine memory kinds are stored, each with an importance score and a resolved flag.

03How it works

From one session to the next.

Context moves in one direction: it is captured from the repository, preserved onchain, and restored when work resumes.

Opening stream
  1. 01Capture

    A session starts with the repository, not a blank slate. Atlas scans the project for its tech stack, reads back the last session's summary and open tasks, and extracts memories from git history.

    • atlas_scan_repository
    • atlas_extract_git_memories
  2. 02Preserve

    Decisions, bugs, warnings and important files are written as typed memories with an importance score. Each write goes to Walrus Memory on mainnet, and the returned blob id is kept on the local index as proof it is onchain.

    • atlas_save_memory
    • atlas_record_decision
  3. 03Restore

    When work resumes, context is read back — the repository summary, the tasks still open, recent sessions, and semantic search across everything written before. A handoff document can be generated for another agent.

    • atlas_get_repository_context
    • atlas_search_memory
Memory kindsARCHITECTUREDECISIONBUGTODOWARNINGIMPORTANT_FILEDEPENDENCYSECURITYCONTEXT
04Installation

Install Atlas in a few commands.

Requires Node 20 or newer, a Walrus Memory delegate key and its account id. A Tatum API key is optional. The installer checks Node and npm, backs up ~/.claude/settings.json before editing it, and leaves your existing instructions in place.

Opening portal

  1. Clone the repository

    The app and the MCP server come down together — the server is built from the same checkout.

  2. Create your .env

    Copy .env.example and fill in the MemWal delegate key and account id. A Tatum API key is optional — the Sui gateway also answers keyless requests today. The script exits if .env is missing.

  3. Run the installer

    It installs dependencies, creates the SQLite index, builds the server, and links the global atlas-mcp command.

  4. Restart your coding agent

    The installer registers Atlas with Claude Code and Codex. Restart your client, then ask it to start an Atlas session.

atlas — auto
git clone https://github.com/greyw0rks/atlas.git
cd atlas
git checkout feat/cinematic-landing
cp .env.example .env   # MemWal delegate key + account id; Tatum key optional
./install.sh

What the script does

  • Installs dependencies for the root package and the MCP server
  • Creates the local SQLite index with Prisma
  • Builds the MCP server and links the global atlas-mcp command
  • Registers the atlas server in ~/.claude/settings.json
  • Removes hooks that reference HANDOFF.md, leaving your other hooks intact
  • Installs the /atlas skill to ~/.claude/skills/atlas
  • Appends an Atlas block to ~/.claude/CLAUDE.md, keeping your instructions
  • Registers Atlas in ~/.codex/config.toml and appends instructions to ~/.codex/AGENTS.md
  • ! Your ~/.claude/settings.json is backed up first, as settings.json.backup-<date>.
  • ! Your global ~/.claude/CLAUDE.md is appended to, not replaced. Existing instructions stay.
Run the local dashboardRead the documentationBrowse the source
05Use cases

Keep the knowledge. Continue the work.

Four things Atlas is actually built to hold on to, each one backed by a tool you can call today.

Codebase understanding

Atlas scans manifests and lockfiles to record the stack it finds, and flags the files a change is most likely to break.

atlas_scan_repository

Architectural decisions

Record why a choice was made and what the alternatives were, so the reasoning is still there when the diff is long forgotten.

atlas_record_decision

Ongoing tasks

TODOs and bugs are tracked as memories with an importance score, and can be marked resolved without being deleted.

atlas_get_open_tasks

Project handoffs

Generate a structured handoff from the session's context — built for the next agent, or your own next session.

atlas_create_handoff

Resolving

Give your AI a memory.

Atlas runs as an MCP server inside Claude Code and Codex. Your context stays where you put it, and it is still there next session.

Install AtlasExplore the repository