Codex multi-agent orchestration sucks #23608

Activity

1. OpEnD17

   added

   enhancementNew feature or requestNew feature or request

   on May 20, 2026
2. github-actions

   added

   appIssues related to the Codex desktop appIssues related to the Codex desktop app

   subagentIssues involving subagents or multi-agent featuresIssues involving subagents or multi-agent features

   on May 20, 2026
3. github-actions commented on May 20, 2026

   

   github-actionsBot

   on May 20, 2026 – with GitHub Actions

   Contributor

   More actions

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

   • Main agent needs subagent capacity/status preflight before spawn_agent attempts #23479
   • Skill instructions to use subagents are ignored unless repeated in the prompt #23496

   Powered by Codex Action
4. etraut-openai

   added

   bugSomething isn't workingSomething isn't working

   and removed

   enhancementNew feature or requestNew feature or request

   on May 20, 2026
5. etraut-openai commented on May 20, 2026

   

   etraut-openai

   on May 20, 2026

   Contributor

   More actions

   If you have a specific example of this, please use /feedback to upload and post the session ID here.
6. jshaofa-ui commented on May 20, 2026

   

   jshaofa-ui

   on May 20, 2026

   More actions

   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
7. dcominottim commented on May 26, 2026

   

   dcominottim

   on May 26, 2026

   More actions

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

   See #23496, for instance.
8. zimodai commented on Jun 16, 2026

   

   zimodai

   on Jun 16, 2026

   More actions

   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.