Goal/subagent workflows can spend hours expanding process scaffolding without production progress

What version of Codex are you using?

• Codex/ChatGPT desktop app: 26.803.41515 (build 6321)
• Bundled Codex CLI: 0.147.0-alpha.6.5
• Model used for the workflow: gpt-5.6-sol, with high/xhigh/max reasoning depending on the agent role

What platform are you using?

• macOS 26.6 (build 25G72)
• x86_64

What issue are you seeing?

A long-running Goal/subagent workflow spent several hours expanding process and governance scaffolding without making proportional progress on the requested production implementation.

The user explicitly asked the root conversation to coordinate implementation and acceptance while subagents handled bounded code, test, and review work. The request also explicitly warned against empty process work and said that actual production behavior—not documentation volume, test counts, or workflow completion—was the success criterion.

Instead, the workflow progressively expanded into:

• increasingly detailed implementation plans and governance documents;
• claim schemas, checkpoint registries, evidence receipts, provenance abstractions, mutation infrastructure, and formal-runner designs;
• repeated read-only audits of the same design/code boundary;
• repeated status and acceptance discussions;
• high/max-reasoning subagent reviews of process artifacts that had not yet produced the requested vertical production capability.

The anti-empty-process system itself became the dominant work product. After the user explicitly instructed Codex to stop expanding the governance framework and move immediately to production code, substantial additional time was spent reconciling and removing the unnecessary framework before implementation could resume.

During this period the UI continued to show active work. Codex did not automatically detect or report that measurable production progress had stalled.

This is not only a prompt-quality problem. The workflow had a clear product outcome, an explicit instruction to avoid process-only work, and later an explicit correction to stop governance expansion. Goal/subagent orchestration still amplified the model's tendency to turn uncertainty into more planning, documentation, auditing, and meta-infrastructure.

Approximate reproduction

1. Start a long but concrete repository implementation task with several authoritative design documents.
2. Ask a root conversation to coordinate a sequential Goal.
3. Delegate bounded investigation, implementation, verification, and adversarial review to subagents.
4. State explicitly that production code and a runnable vertical path are the success criteria, and that process artifacts alone do not count.
5. Use high or max reasoning for several agents.
6. Observe that findings from reviewers cause the root workflow to create more governance requirements and abstractions.
7. Each new governance artifact creates additional review and consistency work.
8. Production implementation is repeatedly postponed while the system remains visibly busy.
9. Tell the workflow to stop expanding governance and start production implementation.
10. Observe that it can still spend a long time unwinding or reconciling the process framework, with no automatic no-progress stop.

Expected behavior

Codex should distinguish measurable implementation progress from process expansion.

For implementation Goals, it should detect when a task is active but has not produced any meaningful production delta, new executable call path, resolved blocker, or materially new evidence within a bounded interval.

After a threshold, Codex should pause and surface a warning such as:

No production progress has been made in the last N minutes/tool calls. Work has consisted primarily of repeated reading, planning, documentation, or governance expansion. Continue, reduce scope, or switch directly to implementation?

A user correction such as “stop expanding the framework and implement the production path” should immediately invalidate queued process work instead of requiring another lengthy reconciliation phase.

Suggested safeguards

• A per-task no-progress circuit breaker based on semantic progress, not merely tool activity.
• Visible counters for repeated file reads, repeated audits, compactions, subagent restarts, and time since the last meaningful code/test/blocker delta.
• Separate progress categories in the UI: production code, tests, documentation, investigation, and process/governance scaffolding.
• User-configurable budgets for planning time, review rounds, subagent turns, and high/max reasoning.
• Automatic pause after repeated cycles with no change in code, contract, environment, or blocker.
• Limit parallel agents to read-heavy investigation by default; serialize implementation ownership.
• Treat repeated status reports without a new artifact or changed conclusion as no progress.
• Preserve the latest steering instruction as a hard priority across compaction and Goal continuation.
• Provide a “production-first” mode that allows only the minimum planning required to edit and validate the requested runtime path.

Impact

• Hours of developer time can be lost while Codex appears productive.
• High/max reasoning and multiple subagents can consume substantial resources while reinforcing the same planning loop.
• The user cannot easily tell whether the system is advancing the product or merely elaborating its own process.
• Attempts to prevent false completion can paradoxically create a larger, self-sustaining form of non-delivery.
• Trust is damaged because the system reports activity but not whether activity changes the requested product.

Related reports

This overlaps with, but is not identical to:

• #27588 — repeated pre-write preparation/compaction without reaching edits
• #8481 — compaction loop
• #37090 — repeated compaction/status activity and lack of circuit breakers

The distinguishing issue here is semantic no-progress under Goal/subagent orchestration: even without proving a compaction bug, Codex can recursively expand its own process despite explicit production-first instructions and explicit user steering to stop.