Yes, two kinds built in, and each stops somewhere. What AGENTS.md and local Codex memories keep, where they live and where they end, from OpenAI's documentation as of 26 October 2026, and what a memory layer adds.
Codex has two kinds of memory built in. AGENTS.md files hold the instructions you write; Codex reads them when it starts, and because project files are checked into the repository they travel with git, and other tools such as Claude Code read them too. Local Codex memories, off by default, let Codex turn useful context from earlier chats into memory files kept under its home directory on that machine; OpenAI's page describes no way to carry them to a second computer or into another tool, and ChatGPT uses a separate memory of its own. A memory layer adds the third piece: memory learned from your work, captured automatically, that follows you across machines and into Claude Code, Cursor and the other tools you use.
Two kinds, both documented by OpenAI. One you write, one Codex writes.
Codex builds an instruction chain when it starts, once per run. It reads a global AGENTS.md from your Codex home directory (~/.codex by default), then walks from the project root, typically the Git root, down to your working directory and takes at most one AGENTS.md or AGENTS.override.md per directory. Files are joined root first, so the one closest to your working directory wins. The chain stops at 32 KiB by default. Every line in it is a line someone wrote, and the project files live in the repository, so they travel with git to every machine and to every tool that reads AGENTS.md, Claude Code included.
Off by default. Turn them on with Enable Codex memories in Settings > Personalization of the ChatGPT desktop app, or with memories = true under [features] in config.toml. Once on, Codex can turn useful context from eligible earlier chats into memory files under ~/.codex/memories: summaries, durable entries, recent inputs and supporting evidence. It skips active or short-lived sessions, redacts secrets from what it generates, updates in the background after a chat has been idle for a while rather than the moment it ends, and can skip a pass when your remaining rate limit is below a threshold. In a chat, /memories decides whether that chat can use existing memories or feed future ones; chats that used MCP tools or web search can be kept out. Delete Codex memories resets the store for that machine.
Keep required team guidance in AGENTS.md or checked-in documentation.
Each point below is from OpenAI's Memories page. None of it is a criticism; it is the shape of a per-machine feature.
The Enable Codex memories setting is for the selected machine, the files live under that machine's Codex home, and Delete Codex memories resets that machine only. The IDE extension uses the memory store of the Codex host it is connected to. The page describes no sync between computers.
Local Codex memories are Codex's own generated state. ChatGPT web uses ChatGPT memory, while local Codex clients use a separate local memory store and controls, in OpenAI's words, and ChatGPT Work uses no local Codex store at all. Nothing in the page carries Codex memories into Claude Code, Cursor or any other tool. Computer History on macOS creates memories both ChatGPT and Codex can reference; deleting Codex memories clears it on that machine.
Memories may not update when a chat ends. Codex waits until the chat has been idle long enough to avoid summarizing work still in progress, and it may skip a background pass near your rate limit.
OpenAI's Memories page: "Keep required team guidance in AGENTS.md or checked-in documentation. Treat memories as a helpful recall layer, not as the only source for rules that must always apply."
The memory files are generated state. OpenAI says you can inspect them when troubleshooting or before sharing your Codex home directory, but not to rely on editing them by hand as your primary control surface.
On secrets: Codex redacts secrets from the memory fields it generates, and OpenAI still asks you to review the files before sharing your Codex home directory.
AGENTS.md and local memories are genuinely useful and they are the right first step. They are also bounded by design: AGENTS.md holds only what someone wrote down, and local memories stay in one tool on one computer, in a store OpenAI calls generated state. A memory layer keeps what is learned from the work itself outside any one tool, so the decision you made in Codex this morning is there when you open Claude Code on your laptop this evening.
The two are not either-or. A memory layer runs beside AGENTS.md and local memories; the trade-off worth naming is that a layer which spans tools also moves your data between them, so choose one whose controls and privacy practices you trust.
Codex built-in
Memory layer
Who writes it
Codex built-in: You (AGENTS.md) or Codex (local memories).
Memory layer: Captured from your work automatically, in every connected tool.
Where it lives
Codex built-in: AGENTS.md in the repository and in ~/.codex; local memories under ~/.codex on one machine.
Memory layer: Outside any single tool, synced to every machine you connect.
What it covers
Codex built-in: AGENTS.md: any tool that reads it, Claude Code included. Local memories: Codex only; ChatGPT keeps a separate memory.
Memory layer: Codex, Claude Code, Cursor, Claude Desktop and any other connected tool.
Portability
Codex built-in: AGENTS.md travels with git. Local memories stay per machine; the page describes no sync and no export format.
Memory layer: Follows you between tools and computers; yours to search, correct, forget and export.
Everything above describes Codex. Atlaso is one memory layer built for exactly this gap.
The Atlaso plugin installs hooks, an MCP server and a memory skill into Codex. Recall runs before each prompt and capture after each turn. Codex CLI and Codex Desktop share the same config, so one setup covers both.
What Codex captures is there in Claude Code, Cursor, Claude Desktop, OpenCode, Antigravity and Grok Build, and what they capture is there in Codex. One tool on one device is free; Pro shares that one memory across as many tools and devices as you like.
Atlaso doesn't ask you to turn Codex memories off or to retire AGENTS.md. Rules you want applied every time still belong in AGENTS.md; Atlaso carries the decisions, preferences and where-you-left-off that no one writes down.
See and search every memory in one dashboard, forget any single one, and it stops coming back in every tool.
Atlaso Gateway, coming soon, adds the same memory to Codex and Claude Code another way: their calls pass through Atlaso and arrive at the model with the memories that fit, on your own ChatGPT or Claude plan. Join the waitlist.
Yes, in two built-in forms. AGENTS.md files are read at the start of every run and travel with the repository. Local Codex memories, once you turn them on, let Codex turn useful context from earlier chats into memory files on that machine, and those stay per machine and Codex-only. A memory layer such as Atlaso adds memory learned from the work that follows you across machines and tools.
Still have a question?
Write to usEvery fact about Codex on this page comes from one of these pages, read on the date shown.
Connect Codex to Atlaso and what you decide today is there in tomorrow's session, and with Pro in Claude Code and on your other computer. Free to start, no credit card.
Get Started