Codex Automatic Recaps vs Experimental Context Management: Token Budgets, History Notes, New Context, and Session Eligibility

Why long Codex sessions need explicit continuity controls

Long Codex sessions fail in a different way from short question-and-answer chats: the model may still be producing plausible code edits, but the session’s working memory can become crowded with old patches, terminal output, rejected approaches, review comments, and partially resolved instructions. The September 3, 2026 OpenAI changelog for Codex CLI 0.153.0 addresses this operational problem from two directions: recap controls in the terminal UI, and a separate disabled-by-default experimental context-management mode for eligible ChatGPT sessions using the Codex backend.

The distinction matters because “remembering enough” is not the same as “remembering everything.” A developer running a five-minute refactor can usually keep intent, constraints, and recent files inside the live conversation. A founder or engineering manager running a multi-hour Codex investigation may need the assistant to preserve the current objective, decisions already made, files already touched, and known hazards without dragging every failed test run and every verbose dependency trace into the next turn. Good continuity tooling compresses the past into actionable state; bad continuity practice either loses critical intent or floods the model with stale context.

OpenAI’s changelog identifies several related Codex CLI 0.153.0 changes that make this comparison timely. It lists tui.auto_recap = false as a configuration option for disabling automatic recaps while preserving manual /recap. It also notes fuller TUI history for patches, terminal input, and completed commands, plus broader compressed-history resume behavior. Separately, the configuration/API notes introduce a disabled-by-default experimental context-management mode that can provide token-budget context, history notes, and a new_context tool for eligible ChatGPT Plus, Pro, and Pro Lite sessions using the Codex backend.

For Codex Long Context, How to Use Codex with 1M Token Context Window: Complete Guide to Enabling and Optimizing GPT-5.6’s Extended Context for Large Codebases is the most relevant adjacent resource. The one-million-token Codex context-window guide explains enablement and optimization for large repositories, establishing the high-capacity baseline against which recap and experimental context-management strategies should be evaluated.

For AI Coding Session Memory, Memory Architectures for Long-Running AI Agents is the most relevant adjacent resource. The long-running-agent memory architecture guide compares durable-state and summarization patterns, helping developers understand how session continuity differs from raw conversation history.

The short version: recap is available workflow; experimental context management is not a default promise

Codex automatic recap and manual /recap belong to the current CLI/TUI workflow described in the 0.153.0 changelog. The changelog’s concrete user-facing change is that operators can set tui.auto_recap = false to disable automatic recaps while still keeping the manual /recap command available. That means a team can opt out of automatic recap behavior without losing the ability to explicitly ask Codex to summarize the working session when the operator decides a checkpoint is useful.

The experimental context-management mode is a different category. OpenAI’s implementation notes for pull request #42385 define features.context_management.experimental_mode. When explicitly configured, and only for eligible ChatGPT Plus, Pro, or Pro Lite sessions using the Codex backend, the session can receive token-budget context, history notes, and a new_context tool. The same source says the feature is disabled by default and under development. This article therefore treats it as an emerging implementation path, not as something administrators should assume is active in ordinary API-key, custom-provider, or non-Codex sessions.

Operational warning: do not design a production workflow that depends on experimental context management unless your environment has explicitly enabled it and matches the eligibility rules described by OpenAI. Automatic and manual recaps are the safer baseline to document because the changelog identifies their current CLI behavior directly.

Definitions: automatic recap, manual /recap, and experimental context management

Automatic recap

An automatic recap is Codex TUI behavior that creates continuity without the user invoking a recap command at that moment. The changelog does not publish a universal trigger formula or promise a particular recap cadence, so operators should not assume that automatic recap fires after a fixed number of messages, a specific token count, or a predictable wall-clock interval. The useful operational definition is narrower: it is an automatic summarization path intended to help preserve usable session continuity as the interaction grows.

Automatic recaps are convenient in exploratory work because developers often do not know when a session is about to cross from “fresh enough” into “too much history.” In a debugging session, for example, the operator may paste an error, ask Codex to inspect a failing test, apply two patches, revert one file, then discover that the real issue is an environment variable. An automatic recap can help carry forward the final state of that exploration without requiring the user to pause and manually summarize every branch of the investigation.

The trade-off is control. Any summarization process has to decide what is important. A recap that preserves the high-level plan but drops a rejected migration path may be perfect for implementation. A recap that drops a subtle security constraint, a test flake, or a maintainer instruction can push the next turn in the wrong direction. That is why the new tui.auto_recap = false setting matters: it gives operators a way to disable automatic recaps when they prefer to control recap timing themselves.

Manual /recap

Manual /recap is the explicit operator-invoked recap command. The changelog’s key point is that disabling automatic recaps with tui.auto_recap = false preserves manual /recap. This is an important administrative distinction because many teams want deterministic workflow checkpoints without surrendering the ability to summarize a long session on demand.

A practical use case is a pull-request repair loop. After Codex has inspected reviewer comments, modified files, run tests, and recorded remaining failures, the operator can invoke /recap before switching tasks or before asking a narrower follow-up. The recap should be treated as a checkpoint artifact: it is not a legal audit record, not a complete transcript, and not a guarantee that every discarded idea was preserved. Its value is to compress current intent, decisions, touched areas, and unresolved work into a more manageable state for continuation.

Manual recap also gives administrators a clean training rule for teams: recap at phase boundaries. Good boundaries include “after repository discovery,” “after the first patch compiles,” “after a failed test investigation identifies a root cause,” “before handing the session to another operator,” and “before requesting a final implementation pass.” This reduces the chance that a recap captures the session in the middle of an unresolved branch where the model may mistake a hypothesis for a decision.

Disabled-by-default experimental context management

The experimental context-management configuration is not simply “automatic recap with a new name.” OpenAI’s Codex pull request #42385 describes a feature flag, features.context_management.experimental_mode, that can add token-budget context, history notes, and a new_context tool for eligible sessions. Those concepts point toward more structured context handling than ordinary recap: the session can be informed about budget, can use notes about history, and can access a tool intended to establish new context.

The eligibility constraints are part of the feature definition, not a footnote. According to OpenAI’s changelog and implementation notes, the experimental mode is limited to configured ChatGPT Plus, Pro, and Pro Lite sessions using the Codex backend. API-key sessions are not included in the stated eligibility. Custom providers, provider credentials, non-Codex endpoints, and temporary structured threads are excluded. If your team runs Codex through custom provider credentials or a non-Codex endpoint, you should assume this experimental mode is unavailable unless OpenAI documents a change.

The safest way to describe the feature today is: under development, disabled by default, and available only where explicitly configured and eligible. That phrasing protects operators from a common rollout mistake: seeing a merged implementation pull request and treating it as universal product availability. A merged implementation can document direction, constraints, and internal behavior, but it does not automatically mean every user, plan, endpoint, and session type receives the feature.

How token budgets change the continuity problem

A token budget is the practical limit on how much information can be carried into a model turn. For coding agents, the budget has to serve competing needs: the user’s latest instruction, relevant files or diffs, terminal output, tool results, policy and safety instructions, past decisions, and the assistant’s own reasoning context. When a session grows, old material competes with new material. The core continuity question becomes: which parts of history deserve scarce space in the next step?

Recaps answer that question by compressing history into a summary. Experimental context management, as described by OpenAI, adds token-budget context as an explicit session ingredient. The source notes do not specify exactly how the budget is calculated or displayed, so teams should avoid inventing a numeric model around it. The practical implication is still clear: context management is moving from informal “the model has a lot of chat history” toward more deliberate accounting of what history can be used.

For developers, the biggest risk is stale context with high confidence. Suppose Codex first investigates a failing integration test and suspects the database fixture. Later, a log proves the failure is actually caused by a changed environment variable. If the session summary overweights the earlier hypothesis, the agent may keep editing fixture code. A good recap or history note should preserve the correction: “Initial fixture theory was rejected; current root cause is missing environment variable in test runner configuration.” That one sentence is more valuable than pages of obsolete stack traces.

For enterprise administrators, the token-budget lesson is governance-oriented. Teams should standardize what must survive compaction: current objective, repository branch or task scope, files changed, commands run, tests passed or failed, approvals granted, approvals denied, security constraints, external systems touched, and unresolved risks. They should also standardize what should be dropped or downgraded: speculative theories, noisy logs after the key line is extracted, duplicate terminal output, and instructions that were superseded by the user.

History notes and new_context: what can be said safely today

OpenAI’s source notes identify two named pieces of the experimental mode: history notes and a new_context tool. A history note should be understood as structured continuity information about what happened earlier in the session. The available sources do not define a public schema, retention guarantee, user interface, or administrator reporting surface for these notes. Therefore, it is not safe to claim that history notes are editable, exportable, policy-enforced, or visible in any particular UI unless OpenAI separately documents that behavior.

The new_context tool should be treated with similar caution. Its name indicates a mechanism for introducing or shifting context, and OpenAI’s implementation notes list it as part of the experimental mode. The sources do not provide enough public detail to describe exact invocation semantics, permissions, logs, or failure behavior. In practical terms, the right administrative posture is to treat new_context as an experimental backend capability that may affect how eligible sessions refresh or restructure working context, not as a stable integration API for production workflows.

This caution does not make the feature unimportant. It means its value should be evaluated through controlled testing rather than assumption. If your organization becomes eligible to test it, compare sessions with and without the experimental mode on the same repository task. Track whether important constraints survive, whether superseded hypotheses are dropped, whether the agent asks for clarification at the right time, and whether operators can understand why the session changed direction. Do not measure only whether the code compiles; measure whether the session preserved the right operational memory.

Recommended opening posture for teams

Recommendation: keep automatic recap enabled for general exploratory use unless your team has a reason to control every recap boundary manually. Automatic recap is useful when operators run long investigations and may not remember to checkpoint. It is especially helpful for solo developers, support engineers, and small teams that use Codex interactively rather than under a formal runbook.

Recommendation: set tui.auto_recap = false for workflows where recap timing is part of process control. Examples include regulated code review, production incident response, sensitive migration planning, or sessions where a human operator must verify the exact state before context is compressed. In those cases, preserve manual /recap and train users to invoke it only after they have corrected wrong hypotheses and recorded unresolved risks.

# Example configuration intent only.
# Confirm the exact file location and configuration scope in your Codex environment.

tui.auto_recap = false

Recommendation: treat features.context_management.experimental_mode as a test-only capability until OpenAI documents broader availability. Do not write onboarding material that says “Codex has history notes and new_context” without also stating the eligibility limits: configured ChatGPT Plus, Pro, or Pro Lite sessions using the Codex backend, excluding API-key sessions, custom providers, provider credentials, non-Codex endpoints, and temporary structured threads.

The rest of this article uses that framing: recap is the practical continuity tool teams can reason about today, while experimental context management is an important but constrained development path. The operational goal is not to maximize memory at all costs. The goal is to preserve the right state at the right time, with enough human control that a long Codex session remains auditable, correctable, and safe to continue.

Side-by-side comparison: when each continuity mechanism should carry the session

Codex now has three different continuity concepts that can appear similar during a long task but should be governed differently: automatic recaps, manual /recap, and the disabled-by-default experimental context-management mode. OpenAI’s September 3 Codex changelog confirms that users can set tui.auto_recap = false to disable automatic recaps while keeping manual /recap available, and PR #42385 describes a separate experimental mode that can add token-budget context, history notes, and a new_context tool for eligible sessions. The operational distinction is simple: recap is a summarization control for today’s Codex workflow, while experimental context management is a configured, eligibility-gated capability still described by OpenAI as under development.

For Codex Recap Feature, The Complete Guide to ChatGPT and Codex Shared Context: Memory, Projects, and Cross-Platform Workflows is the most relevant adjacent resource. The shared-context guide examines memory, projects, and ChatGPT-to-Codex continuity, providing the broader cross-platform context for automatic recaps and the manual /recap control.

Comparison matrix for operators and team leads

How the trigger model changes your workflow

Automatic recaps optimize for continuity without requiring the user to remember a command. That is useful when a developer is deep in a patch-review loop and does not want to stop after every compiler error, log inspection, or search result. The trade-off is timing: because the trigger is managed by the client and its configuration rather than by a human milestone, the recap may occur before the user would have chosen to summarize. A team that wants to inspect every transition in a sensitive migration can disable automatic recap with tui.auto_recap = false and still allow engineers to use manual /recap when they reach an approved checkpoint.

Manual /recap is better when the operator knows that the last segment of work has reached a stable state. A neutral example is a dependency upgrade investigation: the user asks Codex to inspect failing tests, compare release notes, and identify the single package causing a regression. After the root cause is confirmed but before any code modification, the user can run /recap and ask Codex to preserve the package name, failing test names, ruled-out causes, and the planned edit. This reduces the chance that the next turn will re-open solved branches while keeping the checkpoint aligned with a human-understood milestone.

Experimental context management has a different trigger posture because it depends on explicit configuration and session eligibility rather than a single user command. OpenAI’s implementation source says eligible ChatGPT Plus, Pro, and Pro Lite sessions using the Codex backend can receive token-budget context, history notes, and a new_context tool when the feature is configured. The same source excludes custom providers, provider credentials, non-Codex endpoints, API-key sessions, and temporary structured threads. A platform team should therefore treat this as a controlled evaluation surface, not as a behavior that every developer can assume will appear in local Codex, CI-attached sessions, or provider-swapped environments.

Token-budget awareness is the key dividing line

Recaps and token-budget context solve adjacent but not identical problems. A recap condenses what happened so the agent can continue with less dependence on the full raw transcript. Token-budget context, as described for the experimental mode, gives the system an explicit representation of budget pressure. The difference matters when deciding whether to compress, defer, or start fresh. In a long refactor, a recap may preserve “we renamed the public interface and updated three call sites,” but token-budget-aware context management may be designed to reason more directly about how much room remains for source snippets, logs, test output, and historical notes.

A practical decision rule is to use manual /recap at semantic boundaries even if automatic recaps remain enabled. Good boundaries include after a failing test is reproduced, after a database migration plan is approved, after a security constraint is clarified, and before switching from diagnosis to code changes. Bad boundaries include immediately after a confusing trace, before the user has labeled which hypothesis won, or while approvals are unresolved. Recapping confusion can preserve the confusion; recapping a verified state can preserve a useful operating plan.

Recommended manual recap prompt after a stable debugging milestone:

/recap

Include:
- the confirmed root cause and the evidence for it
- files inspected and files not yet changed
- commands already run and their important results
- hypotheses that were ruled out
- approvals or risky actions that are still pending
- the next safest action, not a broad rewrite plan

This sample is intentionally conservative. It does not ask Codex to claim that all context is preserved, and it does not ask for hidden state. It asks for concrete artifacts that an engineer can verify: files, commands, evidence, rejected hypotheses, and next steps. The same pattern works for support escalations, release preparation, and data-pipeline triage because those workflows fail most often when the agent loses track of what was already proven versus what was merely considered.

History notes and new_context should not be back-ported into ordinary recap policy

OpenAI’s PR #42385 names history notes and new_context as elements of the experimental context-management mode. That wording is important because it prevents a common governance mistake: writing a team standard that assumes every recap-enabled session also has history notes and a new_context tool. If a developer is using an API-key session, a custom provider, provider credentials, a non-Codex endpoint, or a temporary structured thread, the source notes say the experimental mode is excluded. In those cases, the safe fallback is manual checkpointing with explicit summaries, not reliance on unavailable context-management primitives.

For enterprise administrators, the right policy is to separate “allowed recap behavior” from “experimental context-management enrollment.” The recap policy can define when automatic recap is acceptable, when tui.auto_recap = false should be used, and what engineers must include in a manual checkpoint. The experimental-enrollment policy should define which users, plans, backends, and session types are eligible; how the team verifies that the mode is configured; and what workflows are prohibited from depending on it until OpenAI documents stable behavior. This distinction keeps ordinary development productivity separate from controlled evaluation of an under-development feature.

Neutral workload examples

Example 1: a solo developer is iterating on a medium-sized CLI bug with repeated test runs and small patches. Automatic recaps are reasonable if the developer values flow and the repository is not subject to strict change-control review. The developer should still run manual /recap before a major direction change, such as switching from a minimal bug fix to a broader parser refactor, because the recap can capture why the smaller fix was insufficient.

Example 2: a site reliability engineer is handling a production-adjacent incident simulation. Manual /recap is the safer default because the operator can create a checkpoint after each verified observation: alert condition, affected service, commands run, rollback constraints, and remaining approvals. Automatic recap may still be useful, but the runbook should not allow an automatically generated summary to replace the incident log. Any action that changes production, uses credentials, communicates externally, or modifies infrastructure still requires explicit human authorization outside the recap mechanism.

Example 3: a platform team is evaluating the experimental context-management mode in an eligible ChatGPT Plus, Pro, or Pro Lite session using the Codex backend. The test plan should choose non-production repositories, record whether token-budget context and history notes are actually present, and verify how workflows behave when moved to an excluded environment such as an API-key session or custom provider. The goal is not to prove that the experimental feature replaces recaps; the goal is to learn which tasks benefit from budget-aware context and where the absence of the feature breaks assumptions.

Recommended governance stance: treat automatic recaps as convenience, manual /recap as an intentional checkpoint, and experimental context management as an opt-in evaluation path whose availability must be verified per session.

Risk controls for teams adopting all three

• Record the mode in handoffs. A handoff note should say whether automatic recap was enabled, whether manual /recap was used, and whether experimental context management was configured. This prevents the next engineer from assuming unavailable continuity features.
• Keep source-of-truth artifacts outside the model transcript. Ticket comments, commit messages, incident logs, test reports, and approval records should remain authoritative. Recaps are working aids, not compliance records.
• Do not depend on experimental mode in excluded sessions. OpenAI’s implementation notes exclude API-key sessions, custom providers, provider credentials, non-Codex endpoints, and temporary structured threads, so prompts and automations must degrade safely without new_context or history notes.
• Checkpoint before risk increases. Run manual /recap before applying broad patches, changing infrastructure, touching authentication logic, editing migrations, or asking Codex to synthesize a final implementation plan.
• Audit summaries for omissions. After any recap, scan for missing constraints, rejected hypotheses, unresolved approvals, and commands whose outputs matter. A concise recap that omits a failed migration or denied approval can be more dangerous than no recap.

The most durable operating model is layered rather than exclusive. Keep automatic recap enabled where convenience and speed matter; disable it where the team wants deliberate checkpointing only; use manual /recap to preserve verified milestones; and evaluate experimental context management only in sessions that meet OpenAI’s stated eligibility conditions. This gives developers practical continuity today while protecting operators and administrators from building procedures around an under-development capability that may be absent in many real deployments.

Eligibility is a narrow gate, not a plan-wide entitlement

OpenAI’s September 3 Codex changelog describes experimental context management as a disabled-by-default mode for eligible ChatGPT Plus, Pro, and Pro Lite sessions using the Codex backend. That wording matters operationally: plan membership is only one condition, explicit configuration is another, and the backend used by the session is a separate requirement. A team should therefore treat features.context_management.experimental_mode as an opt-in experiment that may be present in a particular configured Codex path, not as a universal behavior attached to every Plus, Pro, or Pro Lite account.

The implementation source for the feature identifies the configuration flag as features.context_management.experimental_mode and ties the experiment to three context-management additions: token-budget context, history notes, and a new_context tool. The safe reading is that those additions can be made available only when the session passes the experiment’s eligibility checks. The unsafe reading is to assume that a user who pays for an eligible ChatGPT plan automatically receives those capabilities in every CLI, API, custom provider, or temporary-thread workflow.

For engineering managers, the practical consequence is that eligibility should be documented at the session level. A rollout ticket should state the account type, the Codex client version being evaluated, the configured feature flag, the backend route, the provider configuration, and the thread type. If any one of those fields is unknown, the test should be classified as “recap-only continuity” until the team verifies that experimental context management is actually active.

How to read features.context_management.experimental_mode in configuration reviews

The configuration name should be reviewed as a feature gate, not as a stable contract for application design. OpenAI describes the mode as under development, and the source notes say it is disabled by default. That combination means an administrator can intentionally evaluate it, but a product team should not make customer-facing guarantees that require the setting to exist, remain named the same way, or behave identically across future Codex releases.

# Example configuration review note, not a universal deployment recipe:
# Goal: evaluate disabled-by-default Codex context-management experiment.
# Required source condition: features.context_management.experimental_mode is explicitly configured.
# Required session condition: eligible ChatGPT Plus, Pro, or Pro Lite session.
# Required backend condition: Codex backend.
# Excluded: API-key sessions, custom providers, provider credentials,
#           non-Codex endpoints, and temporary structured threads.

In a change-management record, the flag should be accompanied by a rollback owner and a test boundary. A good boundary is “one developer workstation, one non-production repository, one long-running refactor branch, no external side effects.” A poor boundary is “enable for all developers and compare productivity,” because the experiment’s availability and behavior are not documented as general, default, or production-stable.

The safest first test is a continuity test rather than a performance test. Ask Codex to inspect a small repository, summarize its working assumptions, make a low-risk edit, and continue after the context has grown. The evaluation question is not “did it become smarter,” but “did the session expose token-budget context, history notes, or new_context in a way that changes how we should operate long sessions.” That framing avoids unsupported benchmarks and keeps the test aligned with OpenAI’s documented feature surface.

Why the Codex-backend requirement is the main architectural boundary

The Codex-backend requirement separates this experiment from generic model routing. If a company routes Codex-like workflows through a custom provider, an internal gateway, a non-Codex endpoint, or provider credentials, the documented experiment should be treated as unavailable for that path. That is true even if the visible user experience resembles Codex, because the exclusion is about backend eligibility and provider configuration, not about whether the task is “coding.”

This distinction is especially important for platform teams that abstract model access behind a single internal interface. A developer may believe they are running “Codex” because the task starts from a Codex-branded workflow, while the actual request travels through a custom provider or API-key-backed endpoint. For this experiment, that abstraction can invalidate eligibility. The platform owner should therefore expose enough routing metadata for testers to confirm whether the session is actually using the Codex backend.

For Codex Token Budget, What AI Coding Tools Really Cost in 2026: Complete Guide to Hidden Expenses, Token Budgets, and ROI Calculation for Engineering Teams is the most relevant adjacent resource. The AI-coding cost guide breaks down token budgets, hidden expenses, and engineering-team ROI, reinforcing why recap timing and context compression should be monitored as economic as well as technical decisions.

Exclusions that should stop a rollout test before it starts

OpenAI’s notes identify several explicit exclusions: custom providers, provider credentials, non-Codex endpoints, API-key sessions, and temporary structured threads. These are not edge cases to “try anyway” if the goal is a reliable evaluation. They are disqualifying conditions for this specific experiment, and test results from those paths should be labeled as excluded rather than failed.

The API-key exclusion deserves special emphasis because it is easy to misunderstand. A founder or platform engineer may read “Plus, Pro, and Pro Lite sessions” and assume that a paid account plus an API key is sufficient. The source notes say otherwise: API-key sessions are excluded. That means a product embedding Codex-like behavior through API credentials should not advertise token-budget context, history notes, or new_context from this experiment as part of its customer-facing capability set.

Safe testing procedure for eligible sessions

A controlled evaluation should begin with a negative-control run. Start a comparable Codex session with the experimental flag absent or disabled, then run a long but harmless coding workflow that would normally rely on manual recap or automatic recap. Save the transcript, the session metadata you are allowed to record, and the operator notes. This establishes what ordinary continuity looks like in your environment before introducing the experimental mode.

1. Confirm plan and session scope. Verify that the tester is using an eligible ChatGPT Plus, Pro, or Pro Lite session, and do not substitute an API-key session for convenience.
2. Confirm backend routing. Record that the session is using the Codex backend and not a custom provider, provider-credential path, or non-Codex endpoint.
3. Enable only where explicitly supported. Configure features.context_management.experimental_mode for the test environment only, and keep the change out of shared production defaults.
4. Use a reversible repository task. Choose a non-production branch with tests that can be run locally, such as refactoring a utility function or adding a small validation case.
5. Capture continuity artifacts. Note when token-budget context, history notes, or new_context appears, but do not assume undocumented semantics beyond what is visible.
6. Compare against recap behavior. Evaluate whether the new signals changed the operator’s decisions, not whether they produced a subjective improvement.
7. Rollback immediately after the test. Remove the experimental configuration unless the next test has an approved scope and owner.

The test prompt should avoid secrets, production deploys, credential handling, external messages, destructive file operations, and changes that require privileged approval. The point is to observe continuity mechanics, not to stress every safety boundary at once. If the session asks for sensitive action or proposes a production change, stop and handle that request under your ordinary approval policy rather than treating the experiment as an authorization layer.

Sample prompt for a safe continuity test:
"Inspect this non-production repository branch. Identify one small refactor
that reduces duplication without changing public behavior. Before editing,
state your assumptions and the files you expect to touch. After the edit,
summarize what changed, what tests should be run, and what context a future
turn would need if the session continues for another hour."

Observability: what to log without over-collecting

Observability should answer three questions: whether the session was eligible, whether the experimental mode was configured, and what continuity signals appeared. A useful log entry can include the Codex client version, configuration state, plan/session classification, backend classification, repository name or anonymized project identifier, branch name, start and end time, and operator notes about token-budget context, history notes, or new_context. Avoid logging source code, secrets, private customer data, or full transcripts unless your organization already has a compliant retention policy for those artifacts.

Administrators should separate “feature presence” observations from “model quality” observations. A feature-presence note says, for example, that a session exposed a token-budget context signal during an eligible configured test. A quality note says the agent made a good or bad decision after that signal appeared. Mixing the two creates false confidence, because an experimental capability can be present without being reliable enough for a workflow guarantee.

For ChatGPT Plan Comparison, ChatGPT Plans Compared August 2026: Free vs Go vs Plus vs Pro vs Team vs Enterprise — Complete Tier Analysis is the most relevant adjacent resource. The August 2026 plan comparison maps Free, Go, Plus, Pro, Team, and Enterprise tiers, giving readers the subscription background needed to interpret experimental-context eligibility for Plus, Pro, and Pro Lite sessions.

Rollback should be boring, fast, and documented

Rollback for this experiment should mean removing or disabling features.context_management.experimental_mode and returning the workflow to ordinary recap-based continuity. Because the feature is disabled by default, the rollback target is straightforward: no experimental context-management flag in the tested environment, no expectation of token-budget context, no expectation of history notes from the experiment, and no reliance on new_context.

A rollback should be triggered if the team cannot verify backend routing, if a session unexpectedly uses an excluded provider path, if operators begin relying on undocumented behavior, if the experiment appears in a production workflow without approval, or if logs show that users are confusing history notes with durable memory or compliance records. These are governance failures even if the coding task itself succeeds, because the risk is over-inference from an under-development feature.

Rollback checklist:
1. Remove the experimental context-management configuration from the test scope.
2. Restart or recreate affected sessions according to normal Codex procedures.
3. Label prior observations as experimental and session-scoped.
4. Re-enable ordinary continuity guidance: manual recap, automatic recap policy,
   source-control commits, issue comments, and human-authored handoff notes.
5. Update team documentation so excluded paths are not retested as if eligible.

Teams should not use rollback as evidence that the experiment is unsafe or broken. A rollback may simply mean the evaluation window ended, the session did not meet eligibility, or the team was not ready to operationalize the feature. That distinction matters when communicating with developers: the correct message is “we are returning to documented recap workflows until the experiment is explicitly approved again,” not “Codex context management failed.”

Claims that should stay out of documentation and sales materials

Do not claim that experimental context management increases effective context length, guarantees better long-session accuracy, prevents hallucinations, eliminates the need for recaps, or provides durable memory across all Codex work. The official notes identify token-budget context, history notes, and new_context; they do not publish a benchmark, a universal retention model, a security guarantee, or a general-availability commitment. Any internal or external material should preserve that boundary.

Do not claim that the feature is available to all paid ChatGPT users. The documented scope is eligible ChatGPT Plus, Pro, and Pro Lite sessions, explicitly configured, using the Codex backend. That excludes several common enterprise and developer paths, including API-key sessions and custom-provider integrations. A precise support answer is better than a broad promise, because it prevents account teams and administrators from troubleshooting an excluded configuration as though it were a defect.

Recommended wording for internal documentation: “Experimental Codex context management is disabled by default and may be evaluated only in explicitly configured eligible ChatGPT Plus, Pro, or Pro Lite sessions using the Codex backend. Excluded paths include API-key sessions, custom providers, provider credentials, non-Codex endpoints, and temporary structured threads.”

The conservative operating model is to keep automatic and manual recap as the dependable continuity baseline, then test experimental context management only where all eligibility conditions are satisfied. That model lets developers learn from token-budget context, history notes, and new_context without building process debt around an under-development feature. It also gives administrators a clean answer when a session is excluded: use recap, source control, issue tracking, and human handoff notes until OpenAI documents broader availability.

Selection guide by workload: choose continuity controls deliberately

For most teams, the practical decision is not “recap or context management.” The safer decision is “what continuity artifact should be trusted for this workload.” Automatic recaps and manual /recap are available workflow tools in Codex CLI 0.153.0, with tui.auto_recap = false available when a team wants to disable automatic recaps while preserving manual recap. OpenAI’s experimental context-management mode is a different class of mechanism: according to the Codex changelog and implementation notes, it is disabled by default, under development, and limited to explicitly configured eligible ChatGPT Plus, Pro, and Pro Lite sessions using the Codex backend.

The following guidance treats continuity controls as operational aids, not records of truth. For repositories, production systems, regulated reviews, and customer-impacting work, durable artifacts should remain in commits, tickets, design documents, incident timelines, test reports, deployment logs, and review approvals. A recap can help the agent continue; it should not replace the human-readable record that another engineer, auditor, or incident commander can inspect later.

Short fixes: optimize for clear diffs, not memory depth

A short fix usually has one defect, one test target, and one code path. The best continuity control is a compact issue description and a verifiable test command. Automatic recap can remain enabled under the team’s normal Codex CLI policy, but the operator should not wait for recap behavior to clarify the work. If the fix touches authentication, billing, data deletion, or production configuration, the approval record and test evidence should live outside the conversational context.

Recommended workflow: start with the bug, expected behavior, file or module boundary, and the test command; ask Codex to produce the minimal diff; review the patch; then record the rationale in the commit message. Use manual /recap only if the session will be handed to another person or continued later. If the recap says “fixed validation bug” but the actual risk is “changed default authorization behavior,” the recap is too vague to be relied on.

Long refactors: create human checkpoints before compaction decides for you

Long refactors are where recap becomes valuable, because the session may include discovery, design tradeoffs, dependency cleanup, patch review, and test failures. The risk is that recap compresses the visible path but loses the decision trail. A team should create explicit checkpoints at phase boundaries: baseline behavior, intended invariant, migration strategy, files already changed, tests already run, and known unresolved risks. Those checkpoints can be manual /recap outputs, but they should also be copied into a project note or design ticket.

Experimental context management may be worth testing for long refactors only when the session is eligible and the organization wants to evaluate token-budget context, history notes, and the new_context tool as a controlled feature. It should not be presented to developers as guaranteed availability, and it should not be the only place where migration rationale lives. Treat the experiment as a way to study continuity quality, not as permission to run unbounded sessions without documentation.

Incident response: keep the incident log authoritative

During an incident, operators need a timeline, decision owner, mitigation status, and rollback path. Recaps can help a Codex session remember what logs were inspected, what hypotheses were rejected, and what command outputs mattered. They must not replace the incident log, because a compressed session summary may reorder events, omit uncertainty, or blur whether a step was proposed, approved, executed, or rolled back.

OpenAI’s documented reconnect safety model for Codex TUI is relevant here: when an external app-server transport disconnects, drafts and queued input can be preserved while uncertain submissions and automatic replay are blocked for review. That pattern is the right operational instinct for incident work. When continuity state is uncertain, pause and review rather than allowing hidden context or queued instructions to continue acting. If a session contains credentials, customer data, exploit indicators, or live remediation commands, use the organization’s sensitive-session policy before enabling any continuity experiment.

Audits: summaries are indexes, not evidence

For audits, use recaps as an index into work already performed: “reviewed access-control middleware,” “compared policy files,” “flagged missing negative test,” or “no production deployment performed.” The evidence should remain in file paths, diffs, command outputs, exported reports, screenshots where appropriate, and reviewer sign-off. A recap that says “no issue found” is not enough; it must point to what was examined and what was excluded.

Experimental history notes should be treated with the same caution. They may improve session continuity in eligible configured sessions, but they are not an audit ledger. If a review has regulatory, contractual, or security significance, require a human-authored scope statement and result summary. Also require a stale-note check before final conclusions: compare the current branch, current dependency versions, and latest test results against whatever the session believes it has already reviewed.

Multi-agent tasks: prevent useful summaries from becoming shared contamination

Multi-agent work benefits from concise handoffs, but it also creates a context-contamination problem. One agent may infer a design constraint that another agent repeats as fact. One agent may see sensitive implementation details that another agent does not need. One agent may summarize a failed hypothesis so briefly that a later agent revives it without understanding why it failed.

For Codex Context Window Optimization, Why OpenAI Reduced Codex Context Windows for GPT-5.6 and What It Means for Developer Workflows is the most relevant adjacent resource. The context-window reduction analysis explains practical effects on repository navigation and coding sessions, making it a useful companion for teams deciding when to rely on automatic recap, manual recap, or a preview context system.

Sensitive sessions: less retained context can be the safer design

Sensitive sessions include credentials, incident indicators, customer data, unreleased financial information, regulated records, security vulnerabilities, legal strategy, or production-change authority. In these sessions, the central question is not whether the model can remember more. The question is what the session is allowed to retain, summarize, transmit to tools, or expose to later operators.

Codex CLI 0.153.0 gives teams a concrete control: tui.auto_recap = false can disable automatic recaps while keeping manual /recap available. That is useful when policy requires a person to review every summary before continuity text is created or shared. Experimental context management should face a stricter bar because, according to OpenAI’s implementation notes, it introduces additional context-management behavior such as token-budget context, history notes, and new_context. Do not enable it for API-key sessions, custom providers, provider credentials, non-Codex endpoints, or temporary structured threads; those are outside the described eligibility boundary.

Repeatable automation: make the replay path independent of session memory

Repeatable automation should be driven by deterministic artifacts: repository scripts, task definitions, fixtures, schema files, CI workflows, and checked-in prompts where appropriate. Recap can help a human operator continue a session, but automation that only works because a prior session remembered an implicit constraint is brittle. If the same task must run weekly, convert the instructions into a version-controlled procedure and keep the Codex session as an execution assistant rather than the memory store.

Recommended automation handoff file:
- Task name and owner
- Repository, branch, and required environment
- Inputs and secrets policy
- Exact commands to run
- Expected outputs and validation checks
- Rollback or cleanup procedure
- Human approval points
- Known failure signatures and escalation path

Failure modes to test before rollout

Lost rationale

Lost rationale occurs when the continuity artifact preserves “what changed” but not “why this approach won.” It is common in refactors, audits, and performance work where rejected options matter. The control is simple: require a decision log for nontrivial work. Each entry should name the decision, alternatives considered, evidence used, and rollback condition. A recap may quote or summarize that log, but it should not be the only copy.

Stale notes

Stale notes appear when a session summary describes a branch, dependency, ticket, or operational state that has changed. The failure is subtle because the note can still sound authoritative. Add a “freshness check” before using any recap or history note after a long pause: verify branch name, latest commit, test status, deployment state, open incident status, and current owner. If any item changed, ask Codex to reconcile the old summary with the new facts before making a patch or recommendation.

Premature compaction

Premature compaction is the point at which details are summarized before the team has extracted the artifacts it needs. This can hide edge cases, command outputs, failed tests, or approval boundaries. The mitigation is to checkpoint early and deliberately. Before large edits, ask for a plan. Before compaction-prone sessions continue, capture file lists, assumptions, and unresolved questions. Before handoff, require a human-readable state packet rather than relying on whatever the session retained.

Context leakage

Context leakage happens when information from one scope influences another scope where it does not belong. Examples include secrets moving into a recap, customer-specific assumptions influencing a general patch, incident details leaking into a routine automation session, or one agent inheriting another agent’s speculative conclusion. Reduce leakage by splitting sessions by trust boundary, redacting unnecessary details, using reviewed manual summaries for sensitive work, and avoiding broad transcript sharing.

Operational rule: if a later operator would not be authorized to read a detail in the original transcript, do not allow that detail to enter a recap, handoff packet, history note, or reusable automation prompt.

Phased adoption checklist

1. Inventory current use. Identify where teams already rely on long Codex sessions, manual /recap, automatic recap, transcript sharing, and handoff notes. Record which repositories, incident processes, and audit workflows are in scope.
2. Set the default recap policy. Decide whether automatic recap remains enabled for ordinary development. For sensitive teams, evaluate tui.auto_recap = false and require reviewed manual summaries when continuity is needed.
3. Define eligibility gates. For experimental context management, document that it is disabled by default and limited to explicitly configured eligible ChatGPT Plus, Pro, and Pro Lite sessions using the Codex backend. State the exclusions: API-key sessions, custom providers, provider credentials, non-Codex endpoints, and temporary structured threads.
4. Select pilot workloads. Start with low-risk long refactors or exploratory maintenance tasks. Avoid live incidents, sensitive data, regulated audits, and production-change automation until the organization has evidence from safer pilots.
5. Create continuity templates. Standardize handoff packets, decision logs, freshness checks, and recap review prompts. Templates reduce the chance that each operator invents a different continuity style.
6. Measure quality qualitatively. Review whether recaps preserve objectives, constraints, file state, commands run, rejected approaches, and open questions. Do not invent numeric success rates unless your team measures them with a defined method.
7. Train rollback behavior. Make it easy to turn off experiments, restart with manual /recap, copy critical state into external documentation, and continue work without relying on experimental history notes.
8. Revisit after source changes. Because OpenAI describes the experimental mode as under development, recheck changelog and implementation notes before expanding access or updating internal guidance.

Useful Links

• OpenAI ChatGPT and Codex changelog for Codex CLI 0.153.0
• OpenAI Codex PR #42385: experimental context management
• OpenAI Codex PR #42101