Summary
I would like Codex App to support a visual, hierarchical multi-agent workflow where agents can be organized as a tree of parent and child agents.
The goal is not simply to display multiple Codex threads. The goal is to make the agent hierarchy itself a first-class workspace concept.
For example:
Project Manager Agent
│
├── Architecture Agent
│ ├── Database Agent
│ └── IPC Agent
│
├── Backend Agent
│ ├── User Service Agent
│ └── Order Service Agent
│
├── UI Agent
│ ├── WinUI Agent
│ └── UX Agent
│
└── QA Agent
├── Integration Test Agent
└── E2E Test Agent
Each node would represent an agent/task/thread, and each node could have its own context, worktree, status, and output.
Why this matters
With modern coding agents, the bottleneck is increasingly shifting from code generation to agent orchestration.
A single agent can already implement substantial features and write unit tests. However, larger projects require multiple agents working on different modules simultaneously.
Codex App already provides important building blocks for this workflow, such as multiple agent threads and worktrees. However, users currently have to mentally manage the relationships between these agents.
A hierarchical visual workspace would make these relationships explicit.
Proposed workflow
A user could create a root agent for a project.
The root agent could delegate tasks to child agents.
Child agents could optionally create their own sub-agents.
Each node could have:
-
Agent/thread context
-
Git worktree
-
Current task
-
Status
-
Dependencies
-
Parent/child relationships
-
Changed files
-
Test results
-
Messages/results returned to the parent agent
For example:
Project Agent
│
┌──────────────┼──────────────┐
│ │ │
Architecture Backend UI
│ │ │
┌──┴──┐ ┌───┴───┐ ┌──┴──┐
DB IPC User Order View State
│ │ │
└──────────────┼──────────────┘
↓
QA / Testing
│
┌──────┴──────┐
↓ ↓
Integration E2E
The visual tree should be interactive rather than merely informational.
Users should be able to:
-
Create a child agent from any node.
-
Open an agent’s thread directly from its node.
-
Assign or change a worktree.
-
Pause/resume an agent.
-
Inspect its context and progress.
-
See which agents are waiting, running, blocked, or completed.
-
Pass results from child agents back to the parent agent.
-
Allow a parent agent to delegate additional work to child agents.
-
Collapse/expand branches of the tree.
-
View dependencies between agents.
Worktree integration
This would be especially powerful when combined with Codex’s existing worktree support.
For example:
Root Agent
│
├── Backend Agent → Worktree A
├── Frontend Agent → Worktree B
├── Native Agent → Worktree C
└── QA Agent → Test Worktree
This would turn Codex App into a real multi-agent development environment rather than a collection of independent coding conversations.
Testing and integration
I also think the hierarchy could eventually support dedicated testing agents.
For example, after several implementation agents complete their tasks:
Implementation Agents
↓
Integration Test Agent
↓
Build / Run
↓
Test Failure
↓
Root Agent identifies responsible branch
↓
Relevant Agent receives fix task
↓
Integration Test Agent runs again
This would provide a much more complete development loop for large projects.
Important distinction
I am not primarily asking for a visual diagram.
I am asking for the underlying hierarchical agent relationship to become a first-class concept in Codex, with the visualization acting as the interface for managing that hierarchy.
The ideal experience would be similar to a node-based workflow editor, but where each node represents a real Codex agent/thread rather than a static workflow step.
Codex already has many of the necessary primitives — agents, threads, worktrees, parallel execution, and delegation. A hierarchical visual orchestration layer would connect these capabilities into a much more powerful development workflow.
Example use case
For a large monorepo containing multiple services and modules, I would like to be able to create:
Project
│
├── Core
├── Windows Native
├── UI
├── Storage
├── Networking
└── Testing
and then allow each branch to independently decompose into additional agents.
This would let the developer supervise the entire project from one visual workspace while still allowing agents to work independently in isolated worktrees.
Expected benefit
This could make Codex App much more effective for large-scale software engineering, where the primary challenge is no longer asking one AI to write code, but coordinating many capable agents while preserving context, isolation, dependencies, and verification.
I believe this would be a natural next step for the multi-agent direction of Codex App.
