Codex needs a workflow/performance doctor — GPT-5.6 Sol feels like a completely different product after tuning

What variant of Codex are you using?

Codex CLI, currently v0.149.1, using GPT-5.6 Sol on long-running real-world engineering and research projects.

What feature would you like to see?

I would like Codex to have a built-in workflow/performance diagnostic command, something like:

codex doctor --optimize

### Additional information

The most important thing I want to emphasize is the **before/after difference**.

This was not a comparison between two different models.

It was:

**the same GPT-5.6 Sol, the same Codex CLI, the same account, and the same real project.**

The main thing that changed was the workflow configuration and instructions.

And the subjective difference was so large that it genuinely felt like I had switched to a different product.

## Before tuning

Codex was clearly intelligent and hardworking, but using it often felt frustrating.

A typical workflow looked like this:

```text
I provide a task
→ Codex disappears into the task
→ reads files
→ investigates
→ spawns agents
→ waits for agents
→ checks something
→ checks it again
→ runs tests
→ continues investigating
→ remains mostly silent
→ eventually returns with a large result

On difficult work, I often had to act as its supervisor.

I would discover that an implementation detail had silently become an architectural assumption.

Then I would challenge it.

Codex would reconsider.

I would find another conceptual problem.

It would reconsider again.

The interaction often looked like:

User finds conceptual problem
→ Codex explains current behavior
→ User challenges the assumption
→ Codex rethinks it
→ User finds another problem
→ Codex rethinks again

It also had a tendency to spend too much effort proving that it was being careful:

• more investigation;
• more verification;
• more subagents;
• more waiting;
• more full tests;
• more discussion of what had gone wrong.

At one point I literally had to tell it:

Your job is not to keep admitting mistakes. Your job is to solve the requirement.

The model was capable, but the experience often felt:

slow, stiff, hesitant, opaque.

And the silence was particularly frustrating.

Codex could work for a very long time while I had no idea whether it had:

• found the root cause;
• changed its hypothesis;
• discovered a blocker;
• rejected an approach;
• made major progress;
• or simply entered another long investigation loop.

After tuning

I changed the workflow rather than the model.

The important changes were things like:

• report meaningful discoveries while continuing to work;
• report when evidence changes the current hypothesis;
• briefly tell me what was found, what it means, and what comes next;
• default to single-agent work;
• only use subagents when parallelism actually helps;
• stop investigating once there is sufficient evidence to act;
• avoid repeated verification of already-established facts;
• avoid unnecessary full-validation cycles during iteration;
• preserve important architectural facts in durable project memory;
• distinguish user intent, architectural invariants, current implementation, and hypotheses;
• give Codex responsibility for discovery, falsification, prioritization, and next-step generation.

Then the behavior changed dramatically.

Instead of silently grinding through a direction until I questioned it, Codex began giving updates with this kind of structure:

The current direction passed the first screening, but the evidence is not especially strong.

There may still be an advantage for another reason, so I'm testing the full economics next.

If even the optimistic upper bound is negative, I'll eliminate this direction rather than continue tuning its parameters and move on to candidates with stronger structural advantages.

That is not just better communication.

It reflects a different working posture.

Codex is now:

• interpreting evidence;
• defining falsification criteria;
• deciding when a hypothesis should die;
• resisting pointless parameter tuning;
• deciding what experiment comes next;
• and keeping me informed without asking me to manage every step.

Another example of the new behavior is essentially:

You provide the objective and useful domain intuition.

Discovery, falsification, combination, and prioritization are my responsibility.

I will maintain multiple candidate directions, evaluate them consistently, eliminate weak ones, and generate the next experiments without waiting for you to prompt me one by one.

This is much closer to how I want an advanced coding/research agent to behave.

The workflow now looks like:

User provides objective
→ Codex generates hypotheses
→ Codex tests them
→ Codex interprets evidence
→ Codex reports meaningful findings
→ Codex falsifies weak directions
→ Codex chooses the next useful experiment
→ Codex continues autonomously

Compare that with the old workflow:

User provides task
→ Codex investigates silently
→ User discovers conceptual problem
→ User challenges Codex
→ Codex corrects itself
→ User provides the next intellectual push

That is a major difference.

The subjective comparison

Before tuning:

Slow.
Stiff.
Hesitant.
Opaque.
Overthinking.
Hardworking, but requiring supervision.

After tuning:

Confident.
Agile.
Fast.
Clear.
Decisive.
Autonomous, while still observable.

Again:

Same model. Same Codex. Same project.

That is the part I think is important.

I did not discover that GPT-5.6 Sol suddenly became smarter.

I discovered that a large amount of its capability was being hidden behind inefficient default agent behavior.

Why I think this deserves product-level attention

Users should not need to manually discover all of these interactions between:

• reasoning level;
• subagent behavior;
• progress communication;
• context size;
• context compaction;
• AGENTS instructions;
• durable project memory;
• MCP/tools;
• repeated verification;
• testing strategy;
• and agent autonomy.

A built-in workflow diagnostic could identify these patterns automatically.

For example:

Workflow Health

Reasoning
⚠ Highest reasoning mode appears to be used for routine work
Recommendation: reserve it for genuinely difficult tasks

Agents
⚠ High subagent usage with significant duplicated investigation
Recommendation: single-agent-first; parallelize only independent work

Progress
⚠ Long periods of user-visible silence
Recommendation: surface material findings and hypothesis changes while continuing execution

Tool Usage
⚠ Large number of sequential inspection calls
Recommendation: batch related inspection where possible

Testing
⚠ Full validation repeatedly executed during intermediate iterations
Recommendation: targeted validation during iteration, full validation at milestones

Instructions
⚠ Duplicate or conflicting global/project instructions detected

Context
⚠ Multiple compactions in a long-running session
Recommendation: persist durable state and consider a clean session at an appropriate milestone

MCP / Skills
⚠ Several always-loaded capabilities are rarely used
Recommendation: load them on demand

Then let the user review and apply appropriate recommendations.

My final conclusion

My biggest takeaway is:

The model is already good enough. The default workflow is leaving a lot of that capability on the table.

Not long ago, I personally felt that I needed both Claude and Codex.

After the recent model improvements and after tuning this workflow, I stopped subscribing to Claude.

For my own workflow, Codex and Claude have reached the point where they are genuinely an either/or choice.

That is a huge change.

But it also makes the remaining problem much more obvious:

Codex should not require an experienced user to spend hours manually tuning its behavior before discovering how good it can actually be.

The difference I experienced was not subtle.

It went from:

"This model is powerful, but using it is exhausting."

to:

"Just give it the objective and let it work."

That feels like a product-level opportunity, not merely a prompt-engineering trick.

If Codex can automatically diagnose and correct these workflow problems, I believe many developers who currently prefer Claude could seriously reconsider that choice.

Users should not have to suffer through the slow, silent, overthinking Codex first before discovering the confident, agile, fast, clear Codex that was already there.

Start with the proposed codex doctor --optimize entry point and review how Codex CLI currently handles reasoning, agents, progress communication, context, tools, and testing. Done would mean a product-level diagnostic that identifies the listed workflow patterns and lets users review or apply recommendations; the issue names no files or tests to run.