Resource-Aware Coordination of Persistent Agent Teams

Dependency structure and coordination overhead

Unstructured multi-agent execution admits redundant computation, unresolved dependencies, write contention, and incompatible intermediate representations. Published evaluations and failure taxonomies report breakdowns in task specification, inter-agent alignment, and verification or termination. Parallelism can amplify these failures because an error in decomposition fans out across several workers.

The coordination substrate must represent authoritative work identity, dependency constraints, ownership, lifecycle state, and termination criteria. It also needs to represent execution attempts separately from the work itself. Otherwise a process restart either loses task identity or makes one failed attempt appear to be the task’s final state.

For a schedulable decomposition, let G = (W,D) be a directed acyclic dependency graph for planned work, where W is a set of work items and D contains prerequisite edges. Let P be the set of accepted canonical work packages, and let R contain runtime slots and attempts. These sets have different purposes: G explains decomposition, P defines accepted obligations, and R records execution. No one-to-one mapping is required between planning nodes and agents, and no agent tree should be treated as the work graph.

Related sources: [1], [2]

Supervisory control plane and execution topology

Planning and execution use different structures. A mission can contain a work-breakdown hierarchy and dependency edges. An accepted package candidate becomes a canonical work package that states a bounded execution obligation. The planning graph is a model of how the outcome is decomposed; the package is the accepted work contract used by downstream lifecycle operations. A planning node is not automatically a package, and a package is not an agent identity.

At runtime, a run contains explicit slots for responsibilities such as coordination, execution, verification, or closeout. A slot is a stable place in the run; an attempt is one worker instance assigned to that place. Agent workers and deterministic workers have distinct kinds. Replacing a process creates another attempt in the same slot rather than redefining the task. This is a product runtime contract. It preserves the work boundary and attempt history, but does not dictate how an organization assigns supervisors or sizes a team.

Our operating method places a persistent supervisor above bounded transient workers. The supervisor retains responsibility for outcome, priority, scope, synthesis, and the next action. It delegates a bounded question or change, receives a result, and decides whether that result satisfies the assigned obligation. A fresh process can restore the supervisory role from standing instructions and external work state. Persistence belongs to the role and its records, not to continuous execution of one model context.

This creates a decomposition loop: select an unresolved obligation, estimate whether it can be separated from current work, delegate it with inputs and an acceptance condition, then reconcile the returned result against that condition. A worker’s completion is evidence about one assignment; the supervisor still decides whether the parent outcome is complete. This distinction prevents a successful subtask from being mistaken for whole-task completion.

Parallelism is justified when subtasks can proceed with limited shared mutable state or when independent evidence reduces uncertainty. If workers all edit the same artifact, depend on each other’s changing results, or query a constrained service, parallelism may add coordination cost and contention. The supervisor chooses concurrency for the current outcome. Agent count follows from that decision rather than serving as a quality objective.

Related sources: [3], [1]

Admission, backpressure, and fairness

A second decision concerns whether a ready assignment can start now. Local tools consume CPU, memory, I/O, and disk, so model quota alone is an incomplete capacity signal. Our operational admission controller evaluates host load, memory and I/O pressure, per-worker-pool pressure, and disk capacity. It returns an admit-or-wait decision under a configured soft load threshold, per-worker-pool fairness floor, and hard load ceiling.

The small-pool floor relaxes the load threshold only when load is the sole wait reason for a worker pool with little active work. It does not waive the hard load ceiling, memory pressure, I/O pressure, per-worker-pool limits, or disk checks. This rule gives a lightly used worker pool a chance to proceed under moderate load while retaining independent safety limits. It is a policy choice, not a proof of fairness: the implementation makes no claim that every worker pool receives equal throughput, that starvation is impossible, or that the queue is optimal.

Capacity and dependency readiness are orthogonal. Write ready(w) for dependency readiness and admit(w,t) for the capacity decision at time t. A task starts only when ready(w) ∧ admit(w,t). A ready package can wait because the host is pressured; an idle host cannot satisfy a missing dependency. Keeping these predicates separate lets operators diagnose whether to change the plan or wait for resources.

Admission is an internal operating mechanism. Product work packages and runtime slots express accepted work and execution state, but this gate is not a product-wide tenant scheduler. The policy does not predict model cost or promise customer throughput. That boundary matters when interpreting the architecture: the product state model can support coordination without claiming the internal host policy applies across customer fleets.

Execution trace: fan-out, backpressure, and fan-in

Consider a mission to prepare a release brief from a change list, a support summary, and a security review. The mission graph contains three source-investigation nodes with no dependency edges between them, followed by a synthesis node whose incoming edges name all three prerequisites, then a verification node. The planning graph records that synthesis cannot be ready until the required inputs exist.

The supervisor maps these obligations to accepted work packages and assigns bounded execution slots. Two source investigations may start immediately. The third is otherwise ready but waits because memory pressure violates admission policy. Separately, synthesis remains blocked by its dependency edges even if the host becomes idle. The dependency relation and admission decision point to different remedies.

A transient worker that completes an investigation returns its sources, conclusions, and any unresolved uncertainty. If the worker fails before finishing, a later attempt uses the same runtime slot and the recorded work obligation. The supervisor reconciles the result against the requested audience and required brief sections. If the security review lacks a source, it delegates that specific gap; it does not reopen unrelated investigations merely to increase the agent count.

Completion occurs when the parent outcome’s criteria are met, not when every worker has reported success in isolation. This example illustrates bounded work, stable execution identity, and separate capacity admission. It does not imply that three parallel agents outperform one worker or that the internal admission gate optimizes end-to-end latency.

Evaluation and limits

Evaluate a coordination design against the same task set using a single-worker baseline and alternatives with bounded teams. Hold model family, tools, prompt budget, and compute budget constant where possible. Report task success and completion time alongside tool calls, duplicated work, dependency-blocked time, capacity-wait time, and incomplete or conflicting outputs. Separate task classes: independent research, shared-artifact editing, and sequential tasks have different dependency and contention profiles.

Scaling studies report both gains and regressions as the number of agents and coordination structure vary. Failure taxonomies show that role labels alone do not remove specification, alignment, or termination errors. These results motivate measuring the work pattern rather than assuming a monotonic benefit from additional workers. The mechanisms in this paper describe state and admission boundaries; they do not report a benchmark or measured improvement.

A canonical work package cannot repair a weak decomposition, prove that a returned result is truthful, or eliminate shared-resource contention. The operating admission rule is neither an optimal scheduler nor a tenant policy. High-impact decisions may still need human judgment. The product records dependency-blocked work as a queue state; capacity waiting comes from the operating admission practice, not from a product state, and the two remain separate coordination signals. Its effectiveness requires workload-specific evaluation of decomposition quality, communication overhead, and contention.

Related sources: [1], [2]