🤖 AI

Uno-Orchestra: Parsimonious Agent Routing via Selective Delegation

Uno-Orchestra introduces a unified, reinforcement learning-based orchestration policy that jointly optimizes task decomposition depth, worker selection, and inference budget to achieve significantly higher accuracy and lower costs compared to rigid multi-agent systems across diverse benchmarks.

Original 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

Published 2026-05-07

📖 4 min read☕ Coffee break read

CC BY 4.0

Original 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

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a massive, complex problem to solve, like planning a cross-country road trip that involves finding hotels, booking flights, checking traffic, and cooking meals.

In the world of Artificial Intelligence, most systems today handle this in one of two clumsy ways:

The "One-Size-Fits-All" Boss: They hire the most expensive, super-smart CEO (a massive AI model) to do everything, from booking the flight to chopping the vegetables. This works, but it's incredibly expensive and slow, even for simple tasks like just checking the weather.
The "Rigid Assembly Line": They have a pre-written script that says, "First, ask the CEO for a flight. Then, ask the CEO for a hotel." This is inflexible. If the CEO is busy or the task changes, the whole line breaks.

Uno-Orchestra is a new, smarter way to run this show. Think of it as a brilliant, cost-conscious Tour Manager who doesn't do the work themselves but knows exactly who to hire for every tiny part of the job.

The Core Idea: "Selective Delegation"

The Tour Manager (Uno-Orchestra) looks at your request and asks two questions simultaneously:

"Do I need to break this down?" (Decomposition)
"Who is the best person for this specific piece?" (Routing)

If the task is simple (e.g., "What's 2+2?"), the Manager says, "I don't need to call anyone. I'll just answer it myself instantly." This saves money and time.
If the task is complex (e.g., "Write a Python script to analyze stock data and visualize it"), the Manager breaks it into sub-tasks: "Find the data," "Write the code," "Run the code," "Make the chart."
The Magic Trick: For each sub-task, the Manager picks the perfect worker. They might send the "Find data" task to a fast, cheap intern (a smaller, cheaper AI model). But they send the "Make the chart" task to a specialized, expensive artist (a powerful, expensive AI model).

How It Learned to Be So Good

The paper describes a two-step training process, like training a new employee:

The Internship (Supervised Fine-Tuning): The system watched 61,000 examples of a "Master Manager" solving problems. The Master Manager used real tools and real code execution (not just guessing). The system learned to copy these successful patterns: when to break things down, and which worker to pick for which job.
The Simulation League (Reinforcement Learning): The system was then put in a "training arena" where it had to solve hard problems on its own.
- If it solved the problem correctly and cheaply, it got a high score.
- If it solved it correctly but wasted money, it got a lower score.
- If it failed, it got a zero.
- Crucially, the system learned to give credit (or blame) to specific steps. If it picked the wrong worker for step 3, it learned that specific mistake, rather than just getting a generic "you failed" at the end.

The Results: Fast, Cheap, and Smart

The researchers tested this new Tour Manager against 22 other systems (including other "routers" and "assembly lines") across 13 different types of challenges, from math and coding to long-document reading.

The Score: Uno-Orchestra got a 77% success rate, which was about 16% better than the next best system.
The Cost: Even more impressively, it did this while costing 10 times less per query than the heavy-duty workflow systems.

Why It Works Better

The paper claims the secret is flexibility.

Old systems either tried to do everything with one giant brain (too expensive) or followed a rigid script (too dumb).
Uno-Orchestra is like a jazz musician. It knows when to play a simple, single note (a direct answer) and when to call in a whole band (decompose the task), and it knows exactly which instrument (AI model) is needed for each note.

In Summary

Uno-Orchestra is a system that learns to be a smart project manager. It doesn't just route questions; it decides how to break them down and who to assign them to, all while keeping a tight budget. It proves that you don't need the most expensive AI to solve the hardest problems; you just need the right AI for the right job at the right time.

Technical Summary: Uno-Orchestra

Problem Statement

Current Large Language Model (LLM) multi-agent systems typically rely on rigid orchestration patterns that fail to jointly optimize task decomposition, worker selection, and inference budget. Existing approaches generally fall into two parallel but limited threads:

Model Routing: Single-call routers dispatch an entire query to a single expert model. This approach misses the parallel structure of complex tasks and cannot trade decomposition depth against execution budget.
Hierarchical Orchestration: Planners decompose tasks into sub-agents, but the assignment of subtasks to specific executors is often hand-engineered, prompt-driven, or tied to a single proprietary frontier model.

Consequently, the two critical decisions—whether/how deeply to decompose a task and which expert to route each subtask to—are not optimized under a unified objective. This leads to inefficiencies where simple queries are over-orchestrated, or complex tasks are routed to suboptimal models.

Methodology: Uno-Orchestra

The authors introduce UNO-ORCHESTRA, a unified orchestration policy that treats selective delegation as a single causal language model (LM) task. The system learns to jointly emit a task decomposition plan and a specific (model, primitive) routing decision for every subtask within a single assistant turn.

Core Architecture

Unified Policy: Instead of separate planner and dispatcher modules, a single causal-LM backbone emits the decomposition graph and the routing pairs simultaneously.
Action Space: The policy selects from a sparse set of admissible pairs $P \subseteq \mathcal{M} \times \mathcal{S}$ , where $\mathcal{M}$ is a pool of heterogeneous worker models and $\mathcal{S}$ is a closed vocabulary of "primitives" (atomic actions like direct answering, chain-of-thought reasoning, tool invocation, or code execution).
Selective Delegation: The policy can collapse simple queries into a single direct answer (zero dispatch cost) or decompose complex queries into a Directed Acyclic Graph (DAG) of subtasks. Independent subtasks are dispatched in parallel.

Training Pipeline

The policy is trained in two stages using real worker interactions:

Verifier-Gated Supervised Fine-Tuning (SFT):
- A curriculum of 61,201 teacher-distilled trajectories is constructed from 38 public datasets.
- A "verifier-gated" mechanism filters trajectories: tasks solved by a cold-start router are discarded; tasks solved by a strong teacher orchestrator are retained for SFT; tasks where the teacher fails are reserved for RL.
- Crucially, code and tool subtasks are executed in real sandboxes, ensuring observations are runtime outputs rather than simulated traces.
Agentic-GRPO (Reinforcement Learning):
- The policy is refined on the "residual hard pool" (tasks where the teacher failed) using Agentic-GRPO, a multi-turn extension of Group Relative Policy Optimization (GRPO).
- Intermediate Credit Assignment: Unlike vanilla GRPO which assigns a single reward to an entire trajectory, Agentic-GRPO attributes credit at the granularity of individual turns. It augments the terminal reward with bounded per-turn shaping signals (e.g., schema validity, repair indicators) to resolve the long-horizon credit-assignment problem.
- Objective: The controller maximizes a utility function $J(\theta)$ that trades off correctness (verified by source-specific verifiers) against token-level cost, penalizing redundant dispatches.

Key Contributions

Unified Selective Delegation: The formulation of task decomposition and per-subtask routing as a single causal-LM policy, eliminating redundant context passes between separate modules.
Agentic-GRPO: The introduction of an agent-adaptive RL objective that enables structured credit assignment for multi-turn orchestration, allowing the model to learn when to repair, decompose, or aggregate based on intermediate observations.
Verifier-Gated Curriculum: A training pipeline that leverages real-world sandbox execution and strict verification to generate high-quality, cost-aware trajectories, ensuring the policy learns from actual runtime outcomes.

Experimental Results

The authors evaluated UNO-ORCHESTRA on a suite of 13 benchmarks spanning five capability domains: mathematical reasoning, code/software engineering, knowledge retrieval, long-context reading, and agentic tool use.

Performance: UNO-ORCHESTRA achieved a 77.0% macro pass@1, approximately 16% higher than the strongest workflow baseline (AgentOrchestra).
Efficiency: The system operates at roughly one order of magnitude lower per-query cost (approx. $0.10 vs. $1.20 for baselines) while maintaining higher accuracy.
Cost-Accuracy Frontier: The method occupies a favorable corner of the accuracy-efficiency trade-off, outperforming both flat routers (which cannot decompose) and hierarchical orchestrators (which cannot abstain from decomposition).
Generalization: The performance gains hold across in-domain, near-domain, and out-of-domain regimes. Ablation studies confirm that the improvements stem from the learned routing policy rather than reliance on specific frontier models, as the system outperforms baselines even when restricted to a "weaker" pool of open-weight models.

Significance and Claims

The paper posits that selective delegation—the ability to both decompose and abstain from decomposing under a single objective—is a critical organizing principle for advancing cost-aware multi-agent systems.

Structural Efficiency: By collapsing decomposition and dispatch into a single shared backbone, Uno-Orchestra avoids the coordination overhead inherent in modular systems.
Dynamic Adaptation: The system learns to "abstain" from decomposition for simple queries (collapsing to a single cheap worker) while reserving multi-call orchestration strictly for genuinely composite tasks.
Scalability: The approach demonstrates that high accuracy does not require expensive, monolithic workflows; rather, it emerges from a learned controller that dynamically allocates heterogeneous resources based on task complexity.

The authors conclude that Uno-Orchestra advances the accuracy-efficiency frontier, offering a scalable paradigm where the controller allocates capacity to selecting the right worker rather than simply invoking more workers.