Centralized Asynchronous Isolated Delegation

• Centralized Asynchronous Isolated Delegation (CAID) is a multi-agent coordination paradigm that employs a centralized manager, asynchronous execution, and isolated workspaces to address long-horizon, dependency-rich tasks in software engineering.
• The system uses a global dependency graph with branch-and-merge protocols to delegate and integrate work, ensuring conflict-free and scalable task decomposition.
• Empirical evaluations demonstrate that CAID enhances performance on software engineering benchmarks, improving pass rates by up to 8.1 percentage points compared to single-agent approaches.

Centralized Asynchronous Isolated Delegation (CAID) is a multi-agent coordination paradigm designed to address the challenges of long-horizon, dependency-rich software engineering (SWE) and code-as-action (CAA) tasks. CAID is founded on three key software engineering primitives—centralized task delegation, asynchronous execution, and isolated workspaces—enabling scalable and robust decomposition, concurrent implementation, and reliable integration of complex tasks. Originally developed to mitigate accuracy and coordination problems in collaborative AI agent workflows, CAID has shown substantial empirical improvements over single-agent and naive multi-agent baselines across a range of SWE and CAA benchmarks (Geng et al., 23 Mar 2026, Fei et al., 21 Jan 2026).

1. Formal Definition and Core Principles

CAID implements a multi-agent control protocol featuring a single persistent Manager (or Delegator) agent and a dynamically managed pool of ephemeral Engineer (or Coder) agents. The overall task is represented formally by a dependency graph $G = (V, E)$, with $V$ as atomic units of work (e.g., modules, functions, or sub-tasks) and $E$ encoding dependency relations.

Core Operational Primitives:

• Centralized Task Delegation: A single Manager/Delegator maintains a global view of the entire dependency graph and makes all decisions concerning decomposition, sub-task allocation, and scheduling, thereby preventing conflicting decompositions.
• Asynchronous Execution: Engineer/Coder agents work at their own pace, receiving tasks as soon as their dependencies are satisfied and producing results independently. The Manager operates via an asynchronous event loop, awaiting completion signals before integrating outcomes.
• Isolated Workspaces: Each Engineer/Coder executes within a physically or logically separated context—optionally realized as a private Git worktree or sandboxed Python environment—thereby eliminating silent interference and context pollution.

Mathematically, at each round $t$, completed units are $\mathcal{C}_t \subseteq V$, and a node $v_j$ is ready for delegation precisely if all its parents have been integrated: $$\mathrm{Ready}_t(v_j) \iff \forall (v_i \rightarrow v_j) \in E,\, v_i \in \mathcal{C}_t.$$ The Manager assigns up to $N$ concurrent Engineers to independent ready units and controls advancement to maintain dependency soundness (Geng et al., 23 Mar 2026).

2. System Architecture and Algorithms

CAID comprises the following primary roles and control flows:

Manager/Delegator

• Maintains the global dependency graph, decomposes the user-requested task $\mathcal{T}$ into verified atomic subtasks $S = \{s_1, ..., s_n\}$, and for each produces a structured specification $V$0 (NL directive, typed inputs, return schema).
• Runs an asynchronous event loop using constructs such as Python's asyncio, identifying ready units, spawning engineers, and integrating results via structured signaling and version control operations.

Engineer/Coder Agents

• Are instantiated per assigned sub-task, operating in isolated ephemeral execution environments.
• Work in an inner loop: receive specification $V$1; generate and execute code cells to fulfill requirements; self-verify outputs against schema; signal success, diagnostics, or failure along with structured outputs.
• On merge or return, all intermediate states, error logs, and traces are purged, preventing any context pollution in the global workspace (Fei et al., 21 Jan 2026).

Representative Workflow (SWE Context)

1. Branch Creation: Manager runs git worktree add ... -b agentX main for each Engineer to ensure workspace isolation.
2. Concurrent Editing, Testing, and Commit: Engineers edit only assigned files and complete assigned tests, signaling readiness for integration with structured JSON.
3. Merge-based Integration: Manager executes git merge --no-ff agentX; on conflict, the Engineer is tasked with rebasing and resolving their branch, then re-committing.
4. Post-Merge Synchronization: All idle worktrees are synchronized to latest main to ensure consistent integration states (Geng et al., 23 Mar 2026).

A corresponding abstraction is realized in CAA using ephemeral sandboxes with explicit Ephemeral-Persistent State Separation (EPSS), where the persistent Orchestration Layer holds all high-level state, and the ephemeral Execution Layer is wiped after every coding attempt (Fei et al., 21 Jan 2026).

3. Isolation Mechanisms and Integration Protocols

Isolation in CAID is both physical and logical:

• Physical isolation (SWE): Each Engineer works within a separate Git worktree/branch; no two Engineers write to the same file in the same workspace. Integration occurs only through explicit merge-and-test cycles.
• Logical (contextual) isolation (CAA): Each Coder receives only the sub-task specification and required input artifacts. All code, traceback, and debugging artifacts remain invisible to the Delegator, preventing context pollution and the cascading degradation observed in monolithic agents (Fei et al., 21 Jan 2026).

Integration is test-gated and conflict-aware:

• Only when all tests pass and merge conflicts are resolved does a contribution become part of the canonical, always-valid main state.
• State synchronization ensures all idle workers are reset to the latest integrated artifact, mitigating divergent updates and silent errors (Geng et al., 23 Mar 2026).

4. Empirical Evaluation and Performance

Comprehensive benchmark evaluations have demonstrated the effectiveness of CAID in SWE and CAA domains.

Software Engineering Benchmarks (Commit0-Lite, PaperBench)

• On Commit0-Lite (Python library generation), CAID with 4 Engineers increased average pass rate from 46.1% (Single-Agent) to 54.2%, an absolute improvement of 8.1 points, with notable improvements in more modular repositories.
• On PaperBench (code reproduction), CAID (2 Engineers) achieved an average lift of 13.3 points over Single-Agent baselines (Geng et al., 23 Mar 2026).

Detailed Results Table (Commit0-Lite Example)

Model	Single-Agent Pass %	CAID Pass %	Δ Pass %
Claude 4.5	53.1	59.1	+6.0
GLM 4.7	42.8	46.5	+3.7
MiniMax 2.5	42.3	57.0	+14.7
Average	46.1	54.2	+8.1

Statistical analysis using paired $V$2-tests confirmed significance for several model/benchmark pairs (e.g., Claude 4.5 on Commit0: $V$3).

Code-as-Action Benchmarks (τ²-Bench, MCPMark)

• On τ²-Bench (DeepSeekV3.2, pass@1), CAID achieved 82.0% on retail tasks and 63.5% on airline tasks, outperforming both CodeAct (monolithic) and ReAct (text-actions). At pass@4, CAID’s performance degraded less steeply (17.5%) than CodeAct’s (27.0%).
• On MCPMark, CAID yielded 38.4% (vs. 25.8–26.4%), with the largest absolute improvements on platforms involving complex, multi-step scenarios (Fei et al., 21 Jan 2026).

Ablation studies revealed that both isolated workspaces and structured role separation are essential for robust gains; removing either sharply degrades task success, especially as complexity rises.

5. Mechanistic Analysis: Branch-and-Merge and EPSS

The branch-and-merge protocol in SWE, and EPSS in CAA, provide the central coordination mechanisms:

• Branch-and-merge creates a clear barrier between concurrent implementation and global integration. It exposes merge conflicts and failed tests at integration time, binding coordination failure to concrete, actionable feedback. Empirical analysis demonstrated that replacing hard isolation with "soft isolation" (e.g., instructing agents not to touch the same files in a shared workspace) led to degraded outcomes, emphasizing the necessity of physical separation (Geng et al., 23 Mar 2026).
• Ephemeral-Persistent State Separation (EPSS) in CAA cleanly partitions orchestrator and executor states, ensuring that debugging traces, intermediate failures, and code context never pollute the planner’s memory. Only structured success/error summaries and valid outputs are retained.

Optimal parallelism is bounded by task modularity; excessive concurrent Engineers increase the risk of integration collisions, reducing net pass rate (e.g., 4 Engineers: 59.1% pass, 8 Engineers: 44.3% pass in Commit0-Lite).

6. Recommendations, Limitations, and Future Directions

Recommendations based on empirical findings include:

• Early adoption: Initiate projects under CAID; fallback strategies (Single→CAID) are ineffective, incurring higher cost/time without better final accuracy.
• Adaptive merge policies: Current merge-after-every-commit regime can be tuned to batch compatible changes, reducing overhead and API cost.
• Learned delegation: Future versions could employ reinforcement learning or imitation-based policies to improve the dependency-aware delegation process beyond simple heuristics.
• Domain generalization: Extensions to non-SWE long-horizon artifacts will require analogous mechanisms for isolation and verification, e.g., sandboxed directories and objective test suites for document workflows.
• Cost-accuracy trade-off: Gains in accuracy come at the expense of increased wall-clock time and API utilization. Systematic optimizations are needed to further improve the cost/performance frontier (Geng et al., 23 Mar 2026).

A plausible implication is that grounding AI-centric project management in mature software engineering primitives—such as branch-based isolation, event-driven orchestration, and schema-driven result integration—is critical for achieving scalable, reliable multi-agent systems in real-world productivity applications.

7. Comparison: Monolithic Agents vs. CAID Architectures

Conventional monolithic agents employing code-as-action suffer “context pollution,” where planning and implementation occur within the same growing conversational and execution space. This causes planning tokens and implementation traces to compete for limited context, impairing both strategic reasoning and robust execution. CAID, by separating roles (planner vs. coder) and maintaining strict context boundaries, ensures that each agent focuses only on relevant sub-task details, discarding ephemeral traces and exposing only structured outcome summaries at the orchestration layer (Fei et al., 21 Jan 2026).

Empirical results consistently indicate that CAID’s architectural principles realize stronger scalability as task difficulty and required agent coordination grow, confirming the cost of context collapse and the necessity of strict isolation.

---

References:

• "Effective Strategies for Asynchronous Software Engineering Agents" (Geng et al., 23 Mar 2026)
• "CodeDelegator: Mitigating Context Pollution via Role Separation in Code-as-Action Agents" (Fei et al., 21 Jan 2026)