Feature request: scoped context summarization for side investigations

Problem

During long-running agent tasks, Codex often performs side investigations that are useful only as supporting checks.

Examples:

• researching an API or library detail during implementation
• checking whether a Git branch or worktree may conflict
• inspecting CI logs to understand a narrow failure
• verifying deployment state before continuing
• searching across files to confirm one assumption

In many cases, the full exploration process is not needed in the main conversation context. What the user and agent actually need afterward is only the conclusion, evidence, and any remaining risk.

However, today these side investigations remain mixed into the main context, which can make long tasks noisier and consume context budget unnecessarily.

Why side chats are not enough

Side chats partially address this by allowing users to branch off from the main conversation.

However, they do not fully solve the problem:

• A side chat is separate from the main task, but there is no first-class way to return a structured conclusion back into the main context.
• If a side chat is dismissed or removed, its useful findings can effectively disappear from the working session.
• The user still has to manually copy or restate the conclusion into the main conversation.
• Side chats are useful for temporary exploration, but they are not a durable research capsule or scoped memory artifact.
• For long-running coding tasks, what is needed is not just a separate chat, but a way to preserve only the useful result of that side investigation.

The desired behavior is closer to:

1. Branch into a temporary investigation.
2. Do the necessary exploration.
3. Compress that investigation into a structured summary.
4. Attach that summary back to the main task context.
5. Optionally discard the raw intermediate details.

In short:

Side chats are useful for branching, but not for durable context compression.

Proposal

Add a scoped investigation / context capsule feature that lets users or Codex mark a portion of work as temporary exploration, then intentionally summarize and attach the result back to the main task.

This could work alongside side chats, or as an enhancement to them.

For example, a side chat could have actions such as:

• Summarize back to main thread
• Attach conclusion to current task
• Convert to scoped summary
• Keep result, discard details

The attached summary should preserve:

• purpose
• conclusion
• key evidence
• risks / unknowns
• follow-up actions, if any

Example

A user might ask:

Treat this check as a scoped investigation.
Check whether the current feature branch may conflict with workspace.

After the investigation, Codex could preserve only:

Scoped summary:
- Purpose: Check whether the feature branch may conflict with workspace.
- Conclusion: No likely conflict found.
- Evidence: Compared changed files against workspace; no overlap in implementation files.
- Risk: Docs changed on workspace but do not affect this task.

The detailed intermediate logs, file listings, and exploratory reasoning would not need to remain in the primary working context.

Use Cases

• Keep implementation context focused while still allowing research and verification.
• Avoid polluting long-running tasks with temporary exploration.
• Preserve only decision-relevant conclusions from side investigations.
• Make agent handoffs and resumed sessions cleaner.
• Let users explicitly request topic-specific summaries such as:
• "Only summarize the deployment verification result."
• "Only keep the Git conflict conclusion."
• "Summarize the research findings and discard the exploration details."

Possible Interface

Commands or conversational triggers such as:

Start scoped investigation: [topic]
End and summarize this scoped investigation.
Keep only a scoped summary of this check.

Why This Matters

Long-running coding agents frequently need to branch into temporary checks. These checks are important, but their raw details are often not important after the conclusion is known.

A first-class scoped summarization feature would help Codex manage context more intentionally, reduce noise, and make complex work sessions easier to continue.