Codex memories let local Codex clients carry useful context from earlier chats into later ones. The feature is experimental and off by default: turn it on with memories = true under [features] in ~/.codex/config.toml or with Enable Codex memories in the ChatGPT desktop app, then use /memories to control it per chat.
This guide covers what memories store, how to turn them on and off, the per-chat controls, every documented setting, where the files live, and what to know about privacy. Facts come from OpenAI's Memories page, Config basics and the configuration reference, read on 26 October 2026.
What are Codex memories?
Memories are short, generated notes that Codex builds from your past chats so it can recall useful context later, such as how a project is laid out or which commands you prefer. OpenAI's page opens with: "Memories let ChatGPT and Codex carry useful context from earlier work into future work."
There are two different memory systems, and it helps to keep them apart:
| Surface | Memory system | Where you manage it |
|---|---|---|
| ChatGPT web | ChatGPT memory | Settings > Personalization on the web |
| ChatGPT Work | The memory settings available to your account and workspace | Not local Codex controls |
| ChatGPT desktop app (Codex) | Local Codex memory store | Settings > Personalization > Enable Codex memories, plus /memories |
| Codex CLI | Local Codex memory store | config.toml and /memories |
| IDE extension | The connected Codex host's local store | Same chat-level controls as the CLI |
The memories page does not describe Codex Cloud tasks using the local store, so assume memories are a local feature.
What is the status of the memories feature?
The feature flags table on the Config basics page lists memories with a default of false and a maturity of Experimental. OpenAI's Feature Maturity page defines Experimental as "Unstable and OpenAI may remove or change it," with the guidance "Use at your own risk." The labels don't fully agree, though: in Codex CLI 0.164.0, codex features list shows memories at the stable stage, still off by default.
In managed workspaces, admins can pin the feature on or off for users with features.memories in requirements.toml. If memories won't turn on in a managed workspace, ask your admin whether that pin is set.
How do you turn Codex memories on?
There are three documented ways.
In the ChatGPT desktop app. Open Settings > Personalization and turn on Enable Codex memories. This applies to the selected machine.
In config.toml. Add the feature flag:
[features]
memories = true
From the command line. The CLI reference says codex features manages flags stored in $CODEX_HOME/config.toml, and that enable and disable persist changes for future sessions:
codex features list # shows each flag, its maturity and its effective state
codex features enable memories
codex features disable memories
Config basics also lists codex --enable memories as a way to enable a feature from the CLI. The CLI and IDE extension share the same configuration, so enabling it once covers both. Our Codex config.toml guide explains where the file lives and which layer wins.
How do memories get created?
According to OpenAI, once memories are on, Codex turns useful context from eligible prior chats into local memory files. A few rules shape what happens:
- Codex skips active or short-lived sessions.
- It redacts secrets from generated memory fields.
- It updates memories in the background rather than at the end of every chat.
- It waits until a chat has been idle long enough, so it doesn't summarize work still in progress.
- It can skip a background pass when your remaining Codex rate-limit percentage is below a threshold, so it doesn't spend quota when you're near a limit.
So if a fact from this morning's chat isn't recalled this afternoon, that is expected. The configuration reference sets the default idle wait, memories.min_rollout_idle_hours, to 6 hours.
How do you control memories for a single chat?
Type /memories in the Codex CLI or the ChatGPT desktop app. The memories page says it lets you decide "whether the current chat can use existing memories and whether Codex can use the chat to generate future memories," and that "Chat-level choices don't change your global memory settings."
One wording conflict to know about: the slash command walkthrough in the CLI reference says that after /memories, "Codex updates the relevant memory settings for future sessions," while the memories page says chat-level choices don't change global settings. If it matters, check config.toml after using the command.
The command is useful for one-off sessions: a quick experiment you don't want remembered, or a chat about a different client's code. If /memories doesn't appear, the feature is probably off; enable it first. The Codex slash commands guide lists the other commands.
Which memory settings can you change?
All of these live under [memories] in config.toml. Defaults come from the configuration reference.
| Key | What it controls | Default |
|---|---|---|
generate_memories |
Whether new chats are stored as memory-generation inputs | true |
use_memories |
Whether existing memories are injected into future sessions | true |
disable_on_external_context |
Keeps chats that used MCP tool calls, web search or tool search out of memory generation | false |
min_rate_limit_remaining_percent |
Minimum remaining rate-limit percentage before generation starts | 25 |
min_rollout_idle_hours |
Idle time before a chat is considered | 6 (1 to 48) |
max_rollout_age_days |
Maximum age of chats considered | 30 (0 to 90) |
max_rollouts_per_startup |
Candidates processed per startup pass | 16 (cap 128) |
max_raw_memories_for_consolidation |
Recent raw memories kept for consolidation | 256 (cap 4096) |
max_unused_days |
Days unused before a memory drops out of consolidation | 30 (0 to 365) |
extract_model |
Model override for per-chat extraction | Not set |
consolidation_model |
Model override for global consolidation | Not set |
A privacy-leaning setup that recalls but learns only from plain chats:
[features]
memories = true
[memories]
use_memories = true
generate_memories = true
disable_on_external_context = true
The older key memories.no_memories_if_mcp_or_web_search still works as an alias for disable_on_external_context. In the desktop app, the matching switch is Allow memories from tool-assisted chats.
Where are Codex memories stored?
Under your Codex home directory, which is ~/.codex by default or whatever CODEX_HOME points to. The main files live in ~/.codex/memories/ and, in OpenAI's words, "include summaries, durable entries, recent inputs, and supporting evidence from prior chats."
OpenAI asks you to treat them as generated state: inspect them when troubleshooting or before sharing your Codex home directory, "but don't rely on editing them by hand as your primary control surface."
To reset everything in the desktop app, select Delete Codex memories in Settings > Personalization and confirm. On that machine this also clears Computer History, where that macOS feature is available. The docs don't describe a separate reset command for the CLI.
What should you know about privacy?
The key points from OpenAI's page:
- Memories stay local. They are files in your Codex home directory, not ChatGPT web memory.
- Don't store secrets. Codex redacts secrets from generated memory fields, but you should still review memory files before sharing your Codex home directory or memory artifacts.
- External context can be excluded. Turn on
disable_on_external_contextif you don't want content from web pages or MCP tools to end up in memories. See the Codex web search guide for why web content deserves caution. - Memories are not rules. OpenAI says to keep required team guidance in
AGENTS.mdor checked-in docs and to "Treat memories as a helpful recall layer, not as the only source for rules that must always apply."
Memories vs AGENTS.md: which should you use?
Use both, for different jobs. AGENTS.md is a file you write, review and commit, so the whole team gets the same instructions every time. Memories are per-machine notes Codex writes for itself, which may lag behind and can change. Put build commands, style rules and do-not-touch paths in AGENTS.md, as covered in the Codex AGENTS.md guide, and let memories handle the small personal context. Claude Code users will recognize the split from the Claude Code memory guide.
Keep the durable parts in files you own
Because memories are generated and local, anything you rely on is better kept somewhere explicit. Kipt stores your prompts and Agent Skills as Markdown in a private GitHub repo you own, and npx skills add https://github.com/<you>/<repo>.git --all -g installs every skill into Codex on each machine you use.