Modern developers are increasingly finding themselves in a frustrating waiting game. Even with the advent of powerful coding assistants, the workflow remains stubbornly linear: an agent writes a block of code, the developer triggers a test, the agent analyzes the error, and the cycle repeats. When scaling this to multi-agent systems, the bottleneck intensifies. A sub-agent might be ready to optimize a database schema, but it remains idle because a primary agent is still struggling to resolve a syntax error in a separate module. This sequential dependency creates a latency gap that undermines the theoretical speed of AI-driven development.

Constellation: Breaking the Agent Hierarchy

To solve the communication bottleneck, EstreGenesis introduces Constellation, an A2A (Agent-to-Agent) WebSocket live-board. Traditionally, AI agent interaction follows a rigid parent-child hierarchy. If a developer wants a specialized reviewer agent to check code written by a coder agent, the data must either be manually copied by the human or passed back up to a parent orchestrator and then pushed down to the reviewer. This unidirectional flow creates immense overhead and limits the autonomy of the agents involved.

Constellation replaces this hierarchy with a Peer-to-Peer (P2P) model. By implementing a WebSocket bridge, agents like Claude Code or Cursor can maintain their own independent IDE sessions while a separate daemon process connects them to a shared live-board. This allows agents to send messages directly to one another's dialogue windows without needing a central mediator. To manage this ecosystem, EstreGenesis divides agent roles into four distinct categories: main, local, upstream, and collab. The main agent acts as the orchestrator or PM, designing the overall process. Local agents handle the actual implementation. Upstream agents function as autonomous peers, such as the Hermes Agent, and collab agents serve as external collaborators.

When the main agent sends a Delegate message to a local worker, that worker executes the code within its own IDE environment and returns the result via a WorkerReport. To ensure this flow remains uninterrupted, the system utilizes an AutoMode for automatic approval, removing the need for constant human intervention. Because most agents operate on a turn-based runtime that terminates after a response, EstreGenesis employs a self-wake watcher pattern. A bridge daemon monitors file-based inboxes and outboxes; when a new message arrives, the watcher detects the I/O change and triggers the agent to start its next turn. This detached operation allows agents to remain responsive to external signals even while in a standby state. The entire collaboration flow is visualized through a unified dashboard that tracks messages and states in real-time. Detailed specifications for this system are documented in the Constellation.md file and the `constellation/*.eux` component specs, and the full source code is available via the EstreGenesis GitHub repository.

Superscalar: Porting CPU Architecture to AI Scheduling

While Constellation solves the communication problem, the challenge of execution efficiency remains. Running multiple agents simultaneously often leads to dependency conflicts and stalls during user approval phases. To address this, EstreGenesis 2.3 introduces the Superscalar module, which ports hardware-level concepts like Out-of-Order (OoO) execution and branch speculation from CPU design into the realm of software agents.

The core of the Superscalar module is the issue_width 5-dimensional formula. Rather than blindly launching agents, the system calculates the optimal number of concurrent sub-agents by taking the minimum value of five specific constraints: the effort band (based on Anthropic's task difficulty metrics), the pace_mode cap, throughput limits derived from Little's Law, Kanban WIP (Work-in-Progress) limits, and the number of available workers with AutoMode enabled. This filtering is critical because workers requiring manual approval act as synchronization barriers that kill throughput. By isolating autonomous execution zones from user-intervention zones, the scheduler maximizes the volume of work processed per second.

To manage the actual execution flow, EstreGenesis implements the Tomasulo algorithm and a Reorder Buffer (ROB). In a standard sequential pipeline, if Task A is blocked, Task B must wait. In the Superscalar model, any task whose dependencies are satisfied is dispatched to a worker immediately, regardless of its original position in the queue. However, to prevent the final output from becoming a chaotic jumble, the ROB ensures that results are retired and merged in the original declared order. This allows the developer to see a logically consistent progression of work while the underlying engine executes tasks in the most efficient order possible.

Furthermore, the system employs a two-stage Speculation technique to reduce idle time. The agent first enters a consider X phase to seek user approval; once granted, it moves to execute X. If the speculation is found to be incorrect or the path becomes invalid, the system immediately discards the associated worktree to save resources. To balance the overhead of spawning new agents against the gains of parallelism, a Cost-benefit gate monitors token usage. For tasks in the 30k to 60k token range, the system evaluates whether the cost of spawning a new agent outweighs the speed gain; small tasks are handled inline, while only substantial tasks are distributed in parallel. This logic is reflected in the following decision-making structure:

python

Superscalar scheduler's decision logic example

def calculate_issue_width(task_queue):

constraints = [

effort_band_limit(task_queue),

pace_mode_cap(),

littles_law_throughput(),

kanban_wip_limit(),

autonomy_available_workers()

]

return min(constraints)

Immediate execution upon dependency satisfaction (OoO) and guaranteed result order (ROB)

if dependency_satisfied(task) and rob_slot_available():

dispatch_to_worker(task)

This architecture has been validated through internal dogfooding and incorporates the Toyota Andon principle, providing visual signals and emergency stop functions to prevent runaway agent loops. By treating AI agents as instructions in a processor, EstreGenesis shifts the focus from the raw power of the underlying LLM to the efficiency of the system that orchestrates them.

This transition from model-centric to scheduler-centric design marks a pivotal shift in how autonomous coding environments are built.