Codex offers several continuity mechanisms, and they should not be confused - they solve different tasks. The session transcript stores the context of specific work. Memories is automatically maintained personal or project context. Chronicle is a summary view of work over time. Each has its own role and its own boundary, and the mistake is usually trying to use one mechanism instead of another: the transcript as documentation, memory as the team's source of truth.
The session transcript is the task's working memory, not repository documentation. It stores the course of a specific conversation and the decisions made in it, but is not meant to be the place where the team looks for how the project is arranged. The important from the transcript is carried outward - into AGENTS.md, docs or the tracker - because the transcript itself will expire, compact or be lost. Relying on it as a permanent source of knowledge about the project means building on what is temporary by nature.
Memories is a separate mechanism with its own rules. The /memories command manages their reading and generation: the agent can accumulate observations between sessions and blend them into future work. But this convenience has a hard boundary. Durable team truth is still kept in a version-controlled AGENTS.md, docs or skills: user memory must not be the only place for a critical command. If the important lives only in someone's memory, the team does not see or review it.
Two requirements for memories follow directly from their nature. They are checked - because a stale or wrong note will quietly influence the work, and you will not even notice from where. And no secrets are kept in them - because memory outlives the session and is available further on, and a secret in it turns into a leak stretched over time. Memories are useful while they are durable observations about the environment, not a dump of temporary state and certainly not a store of the sensitive.
It helps to gather the continuity mechanisms into a table by purpose and boundary once. Below is the map: transcript, memories, chronicle. You return to it when deciding where to put knowledge: the context of one piece of work - in the transcript, but not as documentation; recurring personal context - in memories, but with a check and no secrets; a summary picture of work over time - in chronicle. Choosing the mechanism for the type of knowledge matters more than cramming one with everything.
Import from Claude Code is a convenient bridge but requires a manual check. The /import command can open a picker with the Claude Code setup, project files and recent chats and carry them into Codex. It helps to see this capability once, but the result must be treated soberly: after import, do not trust the automatic correspondence. The two products' mechanisms are close but not identical, and a blind transfer carries the mismatches along with the settings.
| Mechanism | Purpose | Boundary |
|---|---|---|
| Session transcript | Context of specific work | Not repository documentation |
| Memories | Auto-maintained personal/project context | Check; do not store secrets |
| Chronicle | A summary view of work over time | A product feature, not a source of truth |
| /import (Claude Code) | Carry over setup, files, chats | Check paths, permissions, hooks, MCP by hand |
What exactly is checked after import is a concrete question, not an abstract one. Paths may point elsewhere, permissions may mean in Codex not the same as in the source, hooks may require re-reviewing trust, MCP a different configuration, and some commands may turn out stale or renamed. Each of these points is checked by hand rather than assuming "it imported, so it works". Import saves typing but does not cancel reviewing the carried configuration as your own.
The typical failures around continuity are predictable. Using the transcript as repository documentation and losing knowledge when the session expires. Keeping a critical command only in personal memory invisible to the team. Storing secrets or temporary state in memories. And trusting an import from Claude Code without a manual check of paths, permissions, hooks and commands. Separate the mechanisms by purpose, keep durable truth in version-controlled files, check memories and review the imported as your own.