Uno-Orchestra: Selective Delegation for LLM Agent Routing — Efficiency and Accuracy Analysis

Forum topic · 小凯 · 2026-05-07

Summary

Uno-Orchestra, a technical report from Nanjing University of Information Science and Technology (arXiv:2605.05007), proposes a unified policy for LLM multi-agent orchestration that jointly optimizes whether to decompose a query, how to decompose it, and which model executes each subtask. A single backbone generates both plan and routing tokens in one forward pass, and a five-stage training pipeline (base, verifier-gated SFT, GRPO, tree-GRPO, and Agentic-GRPO with turn-level credit) yields monotonically increasing pass@1 across all 13 benchmarks. The system reportedly reaches 77.0% macro pass@1 versus roughly 61% for the strongest baselines across 13 benchmarks and 22 baselines, while costing about an order of magnitude less than workflow baselines. Emergent behavior modes include lazy answering (15.6%), oneshot parallel dispatch (49.5%), multi-turn continuation (30.4%), and decomposition-repair (4.4%), meaning about two-thirds of tasks need no multi-turn serial orchestration. Noted limitations include dependence on verifier quality, potentially unfair comparisons with domain-tuned AgentOrchestra on GAIA and SWE-bench, and undisclosed per-query cost details.

Uno-Orchestra: Parsimonious Agent Routing via Selective Delegation

> Paper: Uno-Orchestra: Parsimonious Agent Routing via Selective Delegation > Authors: Zhiqing Cui, Haotong Xie, Jiahao Yuan, Cheng Yang, Hanqing Wang, Yuxin Wu, Yifan Wu, Siru Zhong, Tao Yu, Yifu Guo, Siyu Zhang, Xinlei Yu, Qibing Ren, Usman Naseem > Institution: Nanjing University of Information Science and Technology > arXiv: 2605.05007 > Published: 2026-05-06

Key points

Unified policy claim: decomposition depth, worker selection, and reasoning budget should be jointly optimized under one policy; knowing *when not to decompose* matters as much as decomposition ability itself.
Single-pass plan + routing: plan tokens and (model, primitive) routing pairs are produced by the same causal backbone in one forward pass — no auxiliary heads or staged losses.
Results: 77.0% macro pass@1 vs ~61% for the strongest baseline across 13 benchmarks and 22 baselines, at roughly an order of magnitude lower per-query cost than all workflow baselines.
Domain gains: AIME ~80%, LiveCodeBench >50%, GPQA >25% (relative domain-level gains).
Monotonic training: performance increases at every stage — Uno-base → SFT → GRPO → tree-GRPO → Agentic-GRPO — across all 13 benchmarks.
Counterintuitive finding: Agentic-GRPO improves accuracy while *reducing* cost, attributed to turn-level credit attribution.

Formalizing three orchestration paradigms

| Paradigm | Decision space | Decomposition | Selectivity | Examples | |---|---|---|---|---| | Flat routing | $m \in \mathcal{M}$ | None | None | RouteLLM, FrugalGPT | | Rigid decomposition | Predefined sub-agent sequence | Yes | None | AgentOrchestra, MetaGPT | | Selective delegation | $(m, s) \in \mathcal{P}$ + decomposition graph | Yes | Yes | Uno-Orchestra |

Selective delegation strictly subsumes the other two: it can degrade to flat routing (lazy mode, $$K_t = 0$$ ), dispatch multiple independent subtasks in parallel in one round (oneshot), or run multi-turn dependency-aware continuation.

The routing factorization follows:

\pi_{\theta}(a_t \mid h_t) = \pi_{\theta}(\mathrm{plan}_t \mid h_t) \cdot \prod_{k=1}^{K_t} \pi_{\theta}(p_{t,k} \mid h_t, \mathrm{plan}_t, p_{t,<k})

Emergent behavior modes (61,201 SFT trajectories)

| Mode | Frequency | Structure | Cost implication | |---|---|---|---| | Lazy | 15.6% | Zero dispatch | Lowest | | Oneshot | 49.5% | One round, K parallel subtasks | Second lowest | | Continuation | 30.4% | Multi-turn homogeneous subtasks | Medium | | Decomp-repair | 4.4% | Replanning after verification failure | Only on failure |

65.1% of tasks (lazy + oneshot) need no multi-turn serial orchestration — a system forcing continuation mode for all queries pays unnecessary coordination overhead for ~2/3 of queries.

Agentic-GRPO reward structure

Turn-level advantage estimation:

\hat{A}_{i}^{(t)} = \frac{R_i^{(t)} - \bar{R}_G}{\sigma_G}

where $R_i^{(t)}$ is the cumulative reward contribution of round $$t$$ in trajectory $$i$$ . This lets the policy distinguish useful rounds from redundant ones, explaining the joint accuracy-up / cost-down behavior.

Cost structure vs AgentOrchestra

| Overhead source | AgentOrchestra | Uno-Orchestra | |---|---|---| | Central planner calls | 1 per query | 0 in lazy mode | | Sub-agent calls | Predefined count | Dynamic $$K_t$$ , fewer on average | | Intermediate result passing | Serial | Parallel (oneshot) | | Context accumulation | Global | Localized via dependency graph |

Limitations and open questions

1. Verifier dependence: both teacher distillation (SFT) and RL rewards rely on verifiers; the paper does not report verifier accuracy, so the performance ceiling is unquantified. 2. Fairness: AgentOrchestra was specifically tuned on GAIA (89.04%) and SWE-bench; cross-domain macro averages may underestimate it in those domains — Uno-Orchestra shows smaller relative gains there. 3. Cost granularity: "about an order of magnitude" savings lack per-model, per-query cost breakdowns, hindering independent verification. 4. Model scale: specific orchestrator/worker model sizes are not clearly stated, limiting reproducibility assessment.

Open directions: robustness under varying verifier quality; extending selective delegation to longer-horizon (>10 turns) and open-ended tasks; human-in-the-loop effects; and how delegation quality varies with orchestrator scale.

Relation to prior work

RouteLLM / FrugalGPT: query-level model selection; Uno routes at subtask granularity and adds decomposition decisions.
AgentOrchestra: hierarchical predefined workflows; Uno replaces rigidity with learned selectivity.
Router-R1: RL-trained multi-turn routing; Uno adds decomposition and turn-level credit.
LLMRouterBench: found most routing methods perform similarly; Uno claims to break past that ceiling.
Graph-GRPO: GRPO for multi-agent topology learning; Uno extends GRPO to agentic orchestration with turn-level credit.

*All data and citations are drawn from the arXiv:2605.05007 technical report.*