Iterated Task-Delegation Map

• Iterated task-delegation maps are formal representations of repeated delegation processes that enable recursive routing, subtask decomposition, and state-dependent utility computation.
• They encompass diverse formulations such as recursive MAB, dynamic orchestration DAGs, continuous delegation-control maps, and operator-theoretic approaches for adaptive task allocation.
• Empirical studies show that recursive delegation enhances performance metrics, reduces costs, and raises important challenges in safety, accountability, and strategic coordination.

An iterated task-delegation map is a formal or operational representation of repeated task transfer in which a task may be delegated onward, decomposed into subtasks, re-routed after feedback, or re-evaluated across rounds rather than assigned once and executed immediately. In the literature, the term itself is not universally canonical, but closely related constructs recur across recursive delegation, multi-armed-bandit routing, orchestration DAGs, bilevel delegation policies, and fixed-point delegation operators. The 2018 paper "Delegating via Quitting Games" studies policies for choosing whom to delegate to when recursive interactions are possible and reports that quitting-game-based policies outperform policies that do not explicitly account for the recursive nature of delegation (Afanador et al., 2018). Later work makes the same underlying object more explicit as a directed delegation graph with recursively computed utilities (Oren, 2023), a query-adaptive multi-round orchestration graph (Cui et al., 6 May 2026), or an iterated delegation operator on a task space (Alpay et al., 2 Aug 2025).

1. Conceptual scope and related formulations

Across the cited work, the closest equivalents to an iterated task-delegation map differ in surface formalism but share a common structure: delegation is treated as a repeated decision process whose current action changes the downstream space of future actions. Some papers emphasize recursive agent-to-agent delegation, some emphasize repeated routing over time, and some treat delegation as a global allocation operator. This suggests that the term denotes a family of related mathematical and systems objects rather than a single standardized definition.

Source	Closest construct	Iterative form
(Oren, 2023)	directed delegation graph with recursively computed path utilities and repeatedly updated success/failure statistics	recursive delegation path
(Cui et al., 6 May 2026)	query-adaptive, turn-by-turn, dynamically generated dependency graph	sequence of per-turn DAGs
(Sun, 30 Apr 2026)	context-conditioned delegation policy over sub-agent and delegation degree	runtime recomputation as state changes
(Gu, 11 Mar 2026)	task-to-policy map from task cluster to routing and safeguards	closed-loop delegation protocol
(Alpay et al., 2 Aug 2025)	iterated delegation operator on a task space	repeated application of $F$

A common misconception is that delegation is inherently one-shot. Multiple papers reject that assumption directly. "Revisiting MAB based approaches to recursive delegation" states that a task delegated to one agent can be delegated onwards, with further delegation possible until some agent finally executes the task (Oren, 2023). "Uno-Orchestra" similarly treats orchestration as a multi-turn decision process in which the controller may continue, stop, or repair after each round of subtask execution (Cui et al., 6 May 2026). Even when within-task delegation is only one-step, as in "MetaCogAgent," the iterative element persists across repeated tasks because capability profiles are updated after each task and change future routing behavior (Wang et al., 17 May 2026).

2. Core mathematical forms

One recurring representation is the recursive delegation chain. In the recursive MAB formulation, a task starts at a delegator such as $a$, traverses a path such as $a \to b \to d$ or $a \to c \to f$, and terminates at an execution node; the available delegatees at a step are computed as

$$poss\_del \gets \text{neighbors}(a)\setminus chain,$$

with stopping when $poss\_del=\emptyset$ (Oren, 2023). The corresponding policy map can be reconstructed as

$$\pi(a,chain) = \arg\max_{c\in \text{neighbors}(a)\setminus chain} U(c\mid chain+[a]),$$

where the utility is recursively induced by the downstream subgraph rather than by the immediate neighbor alone (Oren, 2023). This makes the map path-sensitive and anti-cyclic within a task episode.

A second form is the dynamic orchestration DAG. "Uno-Orchestra" makes the within-round structure explicit by defining the plan at turn $t$ as a DAG

$P_t=(\mathcal{V}_t,\mathcal{E}_t),$

where each node is a subtask with a natural-language description, a routing pair $p_{t,k}=(m_{t,k},s_{t,k})\in\mathcal{P}$, and dependency edges indicating which earlier subtasks provide inputs to later ones (Cui et al., 6 May 2026). The global map is then sequential across turns and DAG-structured within a turn. The action factorization,

$a$0

shows that decomposition and worker assignment are jointly generated by one policy rather than by separate modules (Cui et al., 6 May 2026).

A third form is the continuous delegation-control map. In Safe Bilevel Delegation, the policy is

$a$1

so the action is a pair $a$2 consisting of a chosen sub-agent and a continuous delegation degree $a$3 (Sun, 30 Apr 2026). The continuous parameter interpolates between recommendation-only and full autonomous execution, and the outer network $a$4 produces a context-sensitive safety weight $a$5 that changes the inner delegation policy as runtime state changes (Sun, 30 Apr 2026). This yields an iterated map over authority allocation rather than only over task routing.

A fourth form is the operator-theoretic delegation map. "Idempotent Equilibrium Analysis of Hybrid Workflow Allocation" defines

$a$6

with iteration

$a$7

so the map acts on the set of automated tasks rather than on an explicit agent graph (Alpay et al., 2 Aug 2025). Here the iterated task-delegation map is a task-allocation endomap, and the limiting allocation $a$8 is called an idempotent equilibrium (Alpay et al., 2 Aug 2025).

3. Decision rules, updating mechanisms, and stopping conditions

The earliest paper in the set, "Delegating via Quitting Games," gives the basic problem statement: delegation may recurse through multiple agents, and policies should explicitly account for that recursive structure. Its main reported result is comparative rather than formulaic: quitting-game-based policies outperform those which do not explicitly account for the recursive nature of delegation (Afanador et al., 2018). A plausible implication is that the stop/continue structure is not a superficial modeling choice; it changes action quality in measurable ways.

Recursive MAB work makes that structure explicit through utility recursions. For $a$9-greedy, the recursively defined utility is

$a \to b \to d$0

For UCB, the leaf-level value is

$a \to b \to d$1

and the internal-node value is the maximum downstream child UCB (Oren, 2023). The essential change from non-recursive MAB is that the value of delegating to $a \to b \to d$2 is the recursively reachable utility through the subgraph rooted at $a \to b \to d$3, not merely the empirical success rate of direct delegation to $a \to b \to d$4 (Oren, 2023).

In confidence-gated delegation, the controlling state variable is not downstream graph utility but calibrated self-assessment. "MetaCogAgent" defines the combined confidence

$a \to b \to d$5

the conflict indicator

$a \to b \to d$6

and the profile update

$a \to b \to d$7

If $a \to b \to d$8 is below a conflict-adjusted threshold, the task is broadcast for peer confidence evaluation and delegated to

$a \to b \to d$9

or else solved by confidence-weighted collaborative voting (Wang et al., 17 May 2026). The paper explicitly notes that the protocol specifies a single delegation stage within a task, so its iterative aspect is primarily across repeated tasks rather than through multi-hop within-task chains (Wang et al., 17 May 2026).

A different update mechanism appears in repeated human-AI reliance. "Belief Updating and Delegation in Multi-Task Human-AI Interaction" models delegation as accepting the AI’s output versus acting independently, and the main empirical state variable is subjective belief about AI accuracy. Within tasks, observed belief changes follow the Bayesian direction but only at roughly half the normative rate, with $a \to c \to f$0 around $a \to c \to f$1–$a \to c \to f$2; across tasks, priors are not reset, and a 10-point increase in previous-task posterior predicts a 3–4 point higher subsequent prior (Biswas et al., 2 Feb 2026). The delegation rule is belief-dominant: reliance is driven primarily by subjective beliefs about AI accuracy rather than self-confidence, though confidence independently reduces reliance when beliefs are held constant (Biswas et al., 2 Feb 2026). This yields an iterated map whose state is history-dependent and psychologically mediated rather than purely environment-defined.

Task-aware delegation cues define yet another update layer. In "Task-Aware Delegation Cues for LLM Agents," each task cluster $a \to c \to f$3 has a capability profile

$a \to c \to f$4

and a coordination-risk cue

$a \to c \to f$5

which together drive routing to a primary model

$a \to c \to f$6

and, when $a \to c \to f$7, to a primary-plus-auditor mode rather than direct execution (Gu, 11 Mar 2026). This is still an iterated map, but the iteration is over a closed-loop protocol of task typing, routing, rationale disclosure, and logging rather than over explicit multi-hop subdelegation.

4. Architectural realizations in contemporary multi-agent systems

Modern LLM orchestration systems instantiate iterated task-delegation maps as executable control structures. "Uno-Orchestra" is the clearest example of a dynamic multi-round graph: the controller sees history

$a \to c \to f$8

chooses either a direct answer or a decompose-and-route action, emits a plan whose subtasks form a small dependency graph, dispatches independent subtasks in parallel, receives observations, verifies progress, and either replans, repairs, or emits the final answer (Cui et al., 6 May 2026). The paper explicitly identifies four trajectory motifs in its SFT corpus—lazy, oneshot, continuation, and decomp_repair—and operationally caps rollout depth at $a \to c \to f$9 turns (Cui et al., 6 May 2026). The resulting map is not a fixed workflow but a query-adaptive sequence of DAGs.

"SearchSwarm" implements a different but related pattern for long-horizon research. The main trajectory is

$$poss\_del \gets \text{neighbors}(a)\setminus chain,$$0

and delegation occurs through

$$poss\_del \gets \text{neighbors}(a)\setminus chain,$$1

which launches an independent subtrajectory conditioned only on the brief $$poss\_del \gets \text{neighbors}(a)\setminus chain,$$2 and returns only a final report $$poss\_del \gets \text{neighbors}(a)\setminus chain,$$3 to the main agent (Ning et al., 8 Jun 2026). The main agent may delegate repeatedly over time, but subagents do not have access to call_sub_agent, so the architecture is iterative single-level delegation rather than unrestricted recursive depth (Ning et al., 8 Jun 2026). The paper frames this explicitly as delegation intelligence: the ability to decide when and what to delegate, and how to integrate returned reports into the ongoing workflow (Ning et al., 8 Jun 2026).

DecisionBench operationalizes the same general object as a benchmark substrate rather than a single method. Its orchestrator runs a multi-step task loop, may invoke call_model(name, subtask, budget_usd) and optionally read_profile(model), and may make up to 10 peer calls per task (Gao et al., 18 May 2026). The visible structure is therefore a central orchestrator repeatedly calling peers while accumulating context, peer responses, and profile information over time. The substrate is explicitly agnostic to how peer information is generated or delivered, so learned routers, richer peer memories, adaptive profile construction, and multi-step delegation can all be evaluated against it (Gao et al., 18 May 2026).

Governance-oriented work broadens the map beyond routing. "Authenticated Delegation and Authorized AI Agents" extends OAuth 2.0 and OpenID Connect with an Agent-ID token and a Delegation Token, enabling authenticated, authorized, and auditable delegation of authority from a human principal to a specific AI agent under explicit scope restrictions (South et al., 16 Jan 2025). "Intelligent AI Delegation" describes delegation as a sequence of decisions involving task allocation together with transfer of authority, responsibility, accountability, clear specifications regarding roles and boundaries, clarity of intent, and mechanisms for establishing trust (Tomašev et al., 12 Feb 2026). In those formulations, the map includes identity, permissions, audit, and policy propagation edges, not only task-routing edges.

5. Empirical evaluation and characteristic findings

Empirical work converges on the claim that recursive or context-aware delegation changes behavior measurably. "Delegating via Quitting Games" reports that quitting-game-based policies outperform policies that do not explicitly account for the recursive nature of delegation (Afanador et al., 2018). "Revisiting MAB based approaches to recursive delegation" evaluates $$poss\_del \gets \text{neighbors}(a)\setminus chain,$$4-greedy, UCB, Beta-UCB, and Thompson sampling in simulation using average resultant cumulative regret, with settings that include 100 different binomial graphs, 20 agents in the baseline figure, and 20,000 iterations; delegation-aware variants generally outperform standard counterparts, except that standard UCB often remains better, and recursive Thompson sampling performs especially well in recursive delegation settings (Oren, 2023).

In LLM multi-agent systems, the main empirical pattern is that better delegation is often visible first in routing structure, not only in final accuracy. "Uno-Orchestra" reaches $$poss\_del \gets \text{neighbors}(a)\setminus chain,$$5 macro pass@1 at about $$poss\_del \gets \text{neighbors}(a)\setminus chain,$$6 per query, roughly $$poss\_del \gets \text{neighbors}(a)\setminus chain,$$7 above the strongest workflow baseline and at roughly an order of magnitude lower per-query cost (Cui et al., 6 May 2026). "SearchSwarm-30B-A3B" achieves 68.1 on BrowseComp and 73.3 on BrowseComp-ZH, and its behavioral analysis reports that call_sub_agent is the most frequent tool, accounting for over 70% of tool use on BrowseComp and BrowseComp-ZH (Ning et al., 8 Jun 2026). "MetaCogAgent" reports 82.4% task accuracy, 8.7% above the best routing baseline, with 5% fewer API calls than AutoGen and 34% fewer than ensemble voting; its delegation precision is 0.841, and cross-domain tasks have the highest delegation rate at 63.0% (Wang et al., 17 May 2026).

DecisionBench is especially important for evaluation methodology. On its full-pool reference sweep with $$poss\_del \gets \text{neighbors}(a)\setminus chain,$$8 task instances, mean end-task quality is statistically indistinguishable across the four awareness conditions, with $$poss\_del \gets \text{neighbors}(a)\setminus chain,$$9 and $poss\_del=\emptyset$0, but routing fidelity-at-1 ranges from 7.5% to 29.5%, and a counterfactual ceiling places perfect delegation 15–31 percentage points above measured performance on every suite (Gao et al., 18 May 2026). The central implication is explicit: quality-only evaluation would miss the orchestration signal entirely (Gao et al., 18 May 2026). A related point appears in task-aware cueing: global rankings are too coarse, and cluster-conditioned capability profiles and tie-rate priors improve winner prediction accuracy and reduce difficulty prediction error under stratified 5-fold cross-validation (Gu, 11 Mar 2026).

A second misconception is that delegation maps should be evaluated only by end-task correctness. The benchmark evidence contradicts that directly. Routing fidelity-at-$poss\_del=\emptyset$1, delegation rate, vendor self-preference, latency, cost, and counterfactual ceiling are all process-level properties of the map, and they vary even when mean quality does not (Gao et al., 18 May 2026). For iterated delegation, that distinction is structural: a map can be poorly calibrated yet hidden behind flat final-task averages.

6. Safety, accountability, and open problems

Safety-oriented work treats iterated delegation as an authority-allocation problem. In Safe Bilevel Delegation, the outer network $poss\_del=\emptyset$2 produces a context-sensitive trade-off coefficient $poss\_del=\emptyset$3, the inner policy chooses both sub-agent and delegation degree $poss\_del=\emptyset$4, and the optimization is subject to the probabilistic safety constraint

$poss\_del=\emptyset$5

or equivalently $poss\_del=\emptyset$6 for all $poss\_del=\emptyset$7 (Sun, 30 Apr 2026). The accountability chain for a delegation path $poss\_del=\emptyset$8 is defined by

$poss\_del=\emptyset$9

with

$$\pi(a,chain) = \arg\max_{c\in \text{neighbors}(a)\setminus chain} U(c\mid chain+[a]),$$0

This provides an explicit compositional rule for responsibility propagation across multi-hop chains (Sun, 30 Apr 2026). The same paper states three theoretical results—Safety Monotonicity, Inner Policy Convergence, and Accountability Propagation—but notes that empirical validation is planned for a forthcoming revision (Sun, 30 Apr 2026).

Governance-rich delegation architectures push further by embedding monitoring, verification, permissions, and resilience into the map itself. "Intelligent AI Delegation" organizes the framework around Dynamic Assessment, Adaptive Execution, Structural Transparency, Scalable Market Coordination, and Systemic Resilience, and operationalizes them through task decomposition, task assignment, multi-objective optimization, adaptive coordination, monitoring, trust and reputation, permission handling, verifiable task completion, and security (Tomašev et al., 12 Feb 2026). "Authenticated Delegation and Authorized AI Agents" similarly insists that delegation edges be authenticated, scope-constrained, and auditable through identity-provider-backed tokens and revocation or audit metadata (South et al., 16 Jan 2025). These formulations imply that an iterated task-delegation map is incomplete if it contains only routing edges without identity, scope, provenance, and enforcement semantics.

The open problems are recurrent and concrete. Recursive delegation work highlights partial information about graph topology, hidden execution identity, strategic credit-claiming and blame assignment, agents entering and exiting the system, busy agents, delegation costs, and richer trust or reputation mechanisms (Oren, 2023). SearchSwarm limits delegation to a single level because subagents cannot spawn subagents (Ning et al., 8 Jun 2026). MetaCogAgent explicitly assumes stationary competence distributions in its capability-profile learning (Wang et al., 17 May 2026). DecisionBench’s counterfactual ceiling is only a perfect single-step delegation ceiling, so a true multi-step oracle is left open (Gao et al., 18 May 2026). Safe Bilevel Delegation does not yet define a full recursive policy semantics for all agents in a hierarchy or a closed transition law over arbitrary delegation graphs (Sun, 30 Apr 2026).

Taken together, these works support a precise but plural understanding of the iterated task-delegation map. It may appear as a recursive utility graph, a turn-by-turn DAG sequence, a confidence-gated routing policy, a belief-driven human reliance process, a bilevel safety policy over authority degree, or a fixed-point allocation operator. What unifies them is not a single notation but a shared structural claim: delegation is a repeated state-dependent transformation in which current routing, stopping, or authority-transfer choices alter the future delegation landscape, and accurate modeling therefore requires recursion, memory, or both (Afanador et al., 2018).