Codex multi-agent orchestration sucks

Potential duplicates detected. Please review them and close your issue if it is a duplicate.

• #23479
• #23496

Powered by Codex Action

If you have a specific example of this, please use /feedback to upload and post the session ID here.

Proposed Solution: Complexity-Based Multi-Agent Delegation

Root Cause

Main agent's delegation heuristic is too conservative, favoring self-execution. No task complexity analysis, missing delegation cost model, and sub-agent context windows are underutilized.

Proposed Fix

Implement complexity-based delegation with metrics: file count, trace lines, parallelizable chunks, estimated tokens.

impl TaskComplexity {
    pub fn should_delegate(&self) -> bool {
        self.file_count > 3 || self.trace_lines > 500
            || self.parallelizable_chunks > 2 || self.estimated_tokens > 30_000
    }
    
    pub fn delegation_strategy(&self) -> DelegationStrategy {
        if self.parallelizable_chunks > 3 { DelegationStrategy::Parallel }
        else if self.file_count > 5 { DelegationStrategy::ByFile }
        else { DelegationStrategy::Sequential }
    }
}

Testing Strategy

• Unit test: Complexity analysis correctly identifies delegation candidates
• Unit test: Task splitting produces correct sub-task distribution
• Integration test: Large trace analysis uses sub-agents
• Benchmark test: Measure execution time improvement

Impact

• Before: Main agent overloaded on large tasks, sequential execution
• After: Work distributed across sub-agents, parallel execution

Estimated service fee: $1,200-$2,100
Full solution: ~/.hermes/solutions/openai-codex-23608-multi-agent-orchestration-fix.md

If you have a specific example of this, please use /feedback to upload and post the session ID here.

See https://github.com/openai/codex/issues/23496, for instance.

Adding another current regression report for this area.

Environment:

• Codex Desktop App: 26.609.71450
• macOS: 26.5.1
• Surface: Codex Desktop / tool-backed local workspace session

Observed behavior:
After the recent Codex update, Codex appears noticeably less willing to create subagents for parallel work than before. In a repository where the project instructions explicitly authorize and prefer parallel subagent use for non-trivial tasks, Codex now more often continues in the parent/main agent and handles work serially.

This is not a case where spawned subagents fail after creation. The regression I am reporting is earlier in the decision path: the parent agent often does not spawn them in the first place, even when the task has independent lanes and the local instructions define role-specific subagents for review, build/static checks, implementation, commit/push, research, etc.

Expected behavior:

• If active project/workflow instructions explicitly authorize or require bounded subagent use, Codex should treat that as a valid trigger for dispatching appropriate subagents when the task has independent parallelizable lanes.
• If the current policy requires a fresh prompt-level authorization despite those project instructions, Codex should say so deterministically instead of silently degrading to single-agent serial execution.
• For tasks that combine independent responsibilities, such as implementation + review, or diff/static checks + compilation, the role separation should remain reliable.

Why this matters:
The change makes long or multi-domain coding tasks slower and less robust. It also weakens project-level workflows that intentionally separate implementation, review, build verification, and git operations into different subagent roles so the main agent does not self-review or collapse all checks into one path.

Example reproduction shape:

1. Use a project with AGENTS.md or equivalent instructions that explicitly authorize default subagent use and define when to dispatch role-specific subagents.
2. Ask for a non-trivial task with two or more independent lanes, for example implementation plus independent review, or static/build checks plus code review.
3. Observe that recent Codex versions more often proceed only in the parent agent instead of dispatching the configured subagents, even though older behavior in the same project was more parallel.

I do not have a /feedback upload ID from this reporting path, but this is a user-observed regression after upgrading to Codex Desktop 26.609.71450.