GPT-6 Astra repeatedly enters repair and replanning cycles instead of completing a bounded task

What version of the Codex App are you using (From “About Codex” dialog)?

Version 26.901.51231

What subscription do you have?

ChatGPT Pro / 200

What platform is your computer?

Microsoft Windows NT 10.0.26200.0 x64, Win 11, Shell: PowerShell

What issue are you seeing?

I am experiencing a recurring failure to converge on task completion while using GPT-6 Astra in the Codex desktop app.

A bounded software task repeatedly turned into a cycle of:
audit → repair → additional validation and bookkeeping → resource-limit problem → revised plan → another repair.

Individual steps made progress, but completing the overall workflow kept requiring another preparation or repair cycle. The agent increasingly worked on supporting mechanisms—execution histories, recovery handling, resource reservations, manifests, and handoff instructions—while the intended working outcome remained unverified.

Observed problems:

1. Local success did not translate into overall completion. One correction passed 22/22 tests, but packaging and remaining verification still could not proceed within the planned artifact limits.

2. Resource estimates did not consistently cover the entire remaining workflow, including temporary files, failure output, permitted recovery, and final bookkeeping. Later fixes changed those costs again.

3. The proposed recovery mechanism contained concrete partial-state bugs:

   • A saved initial execution identity without a summary was treated as an empty history. The code then tried to create the initial attempt again and failed because its immutable directory already existed.
   • The result inspector checked the initial attempt's terminal record and failed to read a successful recovery attempt's terminal record.

4. Passing preparation tests did not cover these integration boundaries. Some checks used filesystem/ownership models and schema stubs, which needed to be distinguished from native execution evidence.

5. Cross-task status information was inconsistent in freshness: the app reported a task as active while the retrieved latest turn still described an older interrupted run. Newer local artifacts reflected a later state.

6. Repeated audits, expanded instructions, and additional approval coordination consumed substantial usage. A recent technical prompt was approximately 32 KB of UTF-8 text; the delivered message with context was approximately 38 KB. These are byte sizes, not token counts.

At the time of reporting, the account usage tool showed 91% of the seven-day Codex allowance consumed. This is an account-wide measurement, not proof that this task or model alone consumed that amount.

A later focused preparation package reported 12/12 passing checks, including eight using actual schemas. This is meaningful progress, but it came after repeated repair cycles. At that checkpoint, native execution of the remaining stage had not started.

Please investigate task convergence, cost awareness, context continuity, and task-status/approval coordination. I cannot determine whether the primary cause is the model, orchestration, local-instruction handling, or their interaction.

What steps can reproduce the bug?

This is a repeated multi-turn workflow failure. I do not yet have a deterministic minimal reproduction.

The following describes the conditions of the observed workflow and a suggested internal reproduction setup:

1. Use Codex desktop on Windows with GPT-6 Astra and a local software repository.

2. Give the agent a bounded task with an explicit completion condition, required tests, and a staged activation step.

3. Include legitimate constraints:

   • preserve previous execution evidence;
   • do not retry completed failures without authorization;
   • respect fixed artifact/file limits;
   • keep preparation separate from activation.

4. Continue the work across a long conversation history and separate planning/execution tasks.

5. Interrupt an execution before all completion metadata has been persisted. In my actual workflow, a laptop power interruption occurred.

6. Ask the agent to inspect the saved state, make the smallest necessary repair, reuse unchanged evidence, and complete the remaining work.

7. Observe whether the agent converges on one complete package or repeatedly adds another audit, control mechanism, budget revision, and approval request.

Specific generated-code states to test:

A. Initial-attempt identity exists, but summary and terminal do not.
Expected: recognize the existing attempt and follow the valid recovery policy.
Observed in the proposed implementation: empty history followed by an immutable-directory collision.

B. The initial attempt has no terminal; an authorized recovery attempt has its own identity and successful terminal/receipt.
Expected: validate and inspect the recovery attempt.
Observed in the proposed implementation: the inspector only checked the initial terminal path.

These two defects were reproduced using exact proposed functions with isolated filesystem/ownership lookups. Those probes were not native end-to-end recovery tests.

Also inspect cross-task retrieval: compare the timestamp of the returned latest turn with the task's current activity status and newer local completion artifacts.

Exact per-session token usage and context-window consumption are unavailable in this report. Session identifiers and repository contents are omitted from this public issue for confidentiality.

What is the expected behavior?

The agent should preserve a stable definition of completion and choose the smallest complete path to it.

Expected behavior:

• Plan the full remaining dependency chain and its resource requirements before starting expensive work.
• Reuse valid evidence for unchanged dependencies. Repeat checks when changes or unresolved concerns justify them.
• Detect repeated repair/replanning cycles and stop expanding the supporting infrastructure.
• When completion is blocked, preserve the work and present one precise blocker with a minimal, costed solution.
• Respect legitimate approval boundaries while consolidating missing approvals into one concrete, reviewable request.
• Interpret partial execution state correctly without duplicating completed work, inventing execution identities, or granting additional retries.
• Clearly distinguish defect reproduction, proposed fixes, tests of the corrected code, native acceptance, activation, and a working user workflow.
• Expose the freshness and provenance of task-status information. A current activity flag must not make an older retrieved turn appear current.
• Adapt the amount of analysis and reporting when remaining usage is low.
• Treat delivery of a prompt as delivery, not evidence that the requested work has executed.

The expected outcome is either a verified deliverable or a specific actionable blocker, with a reasonable cost to reach that outcome.

Additional information

Model under discussion: GPT-6 Astra.

The workflow includes historical work from earlier sessions. Please verify the actual model used for each relevant turn rather than attributing every historical defect to Astra.

Some audits, preservation rules, artifact limits, and approval requirements were explicitly requested. I am not asking Codex to bypass them. The concern is its failure to consistently consolidate those constraints into a bounded plan that reaches completion.

The latest focused repair package reported 12/12 passing preparation checks. This does not invalidate the complaint about the repeated cycles and usage consumed before reaching that point.

Usage observed through the Codex account tool:

• Plan: Pro
• Seven-day Codex allowance used: 91%
• Attribution: account-wide; per-task and per-model breakdown not established

The project is confidential. Its purpose, business domain, names, paths, source code, proprietary logic, and data are intentionally omitted.

If additional diagnostics are needed, please specify the minimum sanitized excerpts or metadata required and provide a private support route. Please do not request that the full repository or conversation history be posted publicly.

Suggested evaluation criteria:

• completed user outcomes;
• total usage and time to completion;
• number of repeated repair/planning cycles;
• reuse of unchanged evidence;
• correctness after interruption;
• freshness of cross-task status;
• number and clarity of approval requests.

Please indicate whether this is a known issue and what mitigations or fixes are available.

No repository files, tests, or code entry points are named; start by reducing the described Windows/GPT-6 Astra workflow to a deterministic reproduction and compare task status, persisted execution state, and recovery inspection. Done means the cause is isolated with a reproducible case and a verified completion or actionable blocker.