Shared memory is what lets a second agent pick up where the first one stopped. When Claude Code settles a decision, Codex can find it in the next session. When an approach fails, the next agent can see that before it tries again.

Memory belongs to a repository on your machine. Every worktree and subdirectory of one repository shares one record, and outside git the record belongs to the folder the agent started in. It lives in the project's .atlas/memory/ directory, so it is not synced to your teammates.

How agents get memory

Atlas never adds memory to your prompt. The text you type reaches the agent exactly as you wrote it.

Instead, Atlas runs a memory tool server on your machine and hands it to every session that can use it: Atlas Agent, and any external agent that advertises HTTP MCP support. The server's instructions ask the agent to:

• read a briefing when a session starts
• check what other sessions recorded when it resumes
• search before asking you to repeat project history or retrying an old approach
• remember or forget durable context as the work changes

The agent decides when to call those tools. An agent without HTTP MCP support gets no shared memory, and an agent that never calls the tools gets nothing pushed to it.

Agents you run in a terminal can share the same record through the Atlas CLI, which adds the memory server to each agent's own config.

What memory holds

Memory keeps six kinds of entry:

Plans and file changes describe the current stretch of work. Decisions, facts, failures and architecture notes are durable: they accumulate and are what agents search.

Entries arrive three ways:

• Atlas records them as it watches a session: plans, file changes and the session's start and end.
• Atlas extracts them from finished turns. Extraction is a model call through the Atlas gateway when you are signed in, or through your own provider key when you choose one in the memory settings. Without either, Atlas skips extraction.
• Agents write them with the memory tools, on their own or when you ask.

A briefing also carries the tail of the most recent other session in the repository, whichever agent ran it, and the useful parts of your existing CLAUDE.md, AGENTS.md and Claude memory files.

Save a conversation with /remember

Type /remember in the composer to have the agent save the decisions, facts, dead ends and architecture from the current conversation. Add a focus after it, such as /remember the retry rule, to narrow what it records.

/remember is a skill Atlas installs into ~/.agents/skills, so it appears for every agent that reads skills from there.

Keep memory across agent switches

When you switch agents in a session that already has a conversation, two settings in Settings → Sessions decide what carries over:

• Switching agents in a session: choose Hand off to attach the conversation to your next message, so the new agent continues where the last one stopped.
• Save to memory before switching agents: Atlas sends /remember to the agent you are leaving and waits for it to finish before switching. This costs one turn, and you can skip the wait from the notice.

Choose how the handoff is summarized

The handoff is the previous session's tail, as served in the next agent's briefing. Open the sliders button beside Shared in the Memory panel to choose how it is prepared:

• Raw sends the last turns verbatim. There is no model call and no delay. This is the default.
• Provider condenses the tail with a model from one of your provider keys. If the call fails or takes longer than a few seconds, Atlas falls back to the raw tail.

The same choice decides which model extracts durable entries for the project.

Mirror your instructions into AGENTS.md

Some agents read AGENTS.md and ignore CLAUDE.md. Turn on Mirror CLAUDE.md and .claude/rules into AGENTS.md in Settings → General, and Atlas keeps a marked block in the project's AGENTS.md with the contents of CLAUDE.md and every .claude/rules file, rewritten as they change.

Your own text outside the block is never touched. Turning the setting off removes the block. Hooks and permission lists are not instructions, so they are not copied.

Turn sharing off for a project

Sharing is on for every project by default. Open Memory from the bottom of the sidebar and click Shared to switch it off for the current project.

The switch controls everything: with it off, sessions are not offered the memory tool server, Atlas records nothing, and extraction does not run.

Carry durable facts across repositories

Atlas promotes a fact to your cross-project memory in ~/.atlas/memory only when the same high-confidence content appears in at least two repositories. Cross-project results fill gaps when a repository's own memory is thin. They never outrank a stronger local match.

Inspect or correct memory

Open Memory from the bottom of the sidebar. It opens as a full page while your session keeps running; press Esc or select the back arrow in the bar to return to the session. Memory has three tabs:

• Graph maps the semantic index Atlas builds from your instruction files, agent memory files and knowledge notes. Search it in plain language, switch between a tree and a force layout, or play it back over time. The first visit downloads a small embedding model.
• Policy lists the standing rules Atlas found in your instruction and memory files.
• Shared shows the record itself: the event log, captured plans, and the memory entries with their source, agent and confidence. Filter by agent or kind.

Edit an entry to correct it, or forget it to delete it along with the events that produced it. From the Shared tab you can also import your existing Claude memory, or clear the project's shared memory entirely.

Keep the code index current

Atlas separately indexes your codebase so memory search stays grounded in the repository. When you work with Atlas Agent, the composer shows how many files are indexed; click it to rebuild the index.

Embeddings are computed on your machine. Choose the model in Settings → Memory → Embedding model. Changing it rebuilds the index after Atlas asks for confirmation.

Next

• Policy: review the rules your agents work from
• Knowledge base: write deliberate project notes
• Skills: give agents reusable instructions
• Atlas CLI: shared memory for agents in your terminal