Support parent/child task workflows with summarized handoffs

What problem are you trying to solve?

For long-running engineering projects, a single Codex task can become too large even when the work is conceptually one project. In practice, the project often has one stable main thread that owns the overall direction, decisions, and final outputs, plus multiple complex subtasks that each require their own multi-turn discussion and iteration.

Today, there are a few partial workarounds:

• Keep everything in one task, which preserves continuity but eventually creates a very large session with lots of stale detail.
• Start separate tasks manually, which keeps each subtask cleaner but loses an explicit parent/child relationship and requires the user to manually summarize results back into the main task.
• Use subagents, which are helpful for bounded parallel work, but feel closer to delegated one-off work than a durable child task where the user can have a rich multi-turn conversation.

Proposed solution

Add first-class support for a parent/child task workflow in Codex:

1. A parent task can create or link child tasks for specific subprojects or experiments.
2. Each child task has its own transcript, workspace state, and possibly worktree, so it can support a full multi-turn discussion without polluting the parent context.
3. When a child task reaches a checkpoint or completion, Codex generates a structured handoff summary back to the parent task.
4. The parent task can see child task status, key decisions, changed files, outputs, risks, and next actions without ingesting the entire child transcript.
5. The user can reopen a child task for further iteration, while the parent continues to hold the project-level state.

Why this matters

This would fit workflows like:

• A large data-mining or evaluation pipeline where each filter experiment needs several rounds of discussion and review.
• Product/engineering planning where the main task owns the roadmap, while child tasks explore implementation, prompt design, evaluation, or data quality.
• Larger refactors where independent modules can be investigated separately, then summarized back into an architecture-level thread.

The key distinction is that these subtasks are not always one-shot agent delegations. They may require real user-agent collaboration over multiple turns, but the parent task should not have to carry every exploratory detail forever.

Suggested handoff shape

A child-to-parent handoff could include:

• Objective and final status.
• Decisions made.
• Important assumptions.
• Files changed or artifacts produced.
• Verification performed.
• Known risks or open questions.
• Recommended next step.

Alternatives considered

Manual context files and summaries can work, but they rely on user discipline and are easy to forget during active investigation. Subagents are useful for parallel bounded tasks, but they do not fully replace a durable child conversation that can be reviewed, resumed, and summarized into the main project thread.