GraphPlanner: Graph Memory-Augmented Agentic Routing for Multi-Agent LLMs
Authors: Tao Feng
Haozhen Zhang
Zijie Lei
Peixuan Han
Jiaxuan You
Venue: ICLR 2026 Poster (2026)
Keywords: Multi-agent LLMs
Memory utilization
Heterogeneous agents
Graph
Primary area: learning on graphs and other geometries & topologies
TL;DR: GraphPlanner is a graph memory-augmented framework that enables multi-agent LLM routing by modeling cooperation and memory with reinforcement learning, achieving scalable, efficient, and generalizable routing.

Abstract: LLM routing has achieved promising results in integrating the strengths of di-
verse models while balancing efficiency and performance. However, to support
more realistic and challenging applications, routing must extend into agentic LLM
settings—where task planning, multi-round cooperation among heterogeneous
agents, and memory utilization are indispensable. To address this gap, we pro-
pose GraphPlanner, a heterogeneous graph memory-augmented agentic router
for multi-agent LLMs that generates routing workflows for each query and sup-
ports both inductive and transductive inference. GraphPlanner formulates
workflow generation as a Markov Decision Process (MDP), where at each step
it selects both the LLM backbone and the agent role (Planner, Executor, Sum-
marizer). By leveraging a heterogeneous graph, denoted as GARNet, to capture
interaction memories among queries, agents, and responses, GraphPlanner
integrates historical memory and workflow memory into richer state represen-
tations. The entire pipeline is optimized with reinforcement learning, jointly
improving task-specific performance and computational efficiency. We evalu-
ate GraphPlanner across 14 diverse LLM tasks and demonstrate that: (1)
GraphPlanner outperforms strong single- and multi-round routers, improv-
ing accuracy by up to 9.3% while reducing GPU cost from 186.26 GiB to
1.04 GiB; (2) GraphPlanner generalizes robustly to unseen tasks and LLMs,
exhibiting strong zero-shot capabilities; and (3) GraphPlanner effectively
leverages historical memories, supporting both inductive and transductive infer-
ence for more adaptive routing. Our code for GraphPlanner is released at
https://github.com/ulab-uiuc/GraphPlanner.

Published as a conference paper at ICLR 2026
GRAPHPLANNER: GRAPH MEMORY-AUGMENTED AGENTIC ROUTING FOR MULTI-AGENT LLMs
Tao Feng, Haozhen Zhang, Zijie Lei, Peixuan Han, Jiaxuan You
Department of Computer Science University of Illinois Urhana Champaign Urbana, II., USA ftaofeng2, jiaxuan] @ meilliinooii eduu
ABSTRACT
LLM routing has achieved promising results in integrating the strengths of di- verse models while balancing efficiency and performance. However, to support more realistic and challenging applications, routing must extend into agentic LLM settings-where where task planning, multi-round cooperation among heterogeneous agents, and memory utilization indispensable. To address this gap, we pro- pose GraphP lanner, a heterogeneous graph memory-augmented agentic router for multi-agent LLMs that generates routing workflows for each query and sup- ports both inductive and transductive inference. GraphP lanner formulates workflow generation as Markov Decision Process (MDP), where each step it selects both the LLM backbone and the agent role (Planner, Executor, Sum- marizer). By leveraging a heterogeneous graph, denoted as GARNet, to capture interaction memories among queries, agents, and responses, GraphPlannes integrates historical memory and workflow memory into richer state represen- tations. The entire pipeline is optimized with reinforcement learning, jointly improving task-specific performance and computational efficiency. We evalu- ate GraphP hauphhlanneer across 14 diverse LLM tasks and demonstrate that: (1) GraphP annnr outperforms strong single- and multi-round routers, improv- ing accuracy by up 9.3% while reducing GPU cost from 186.26 GiB 1.04 GiB; (2) GraphP MonpPlamn lanner generalizes robustly to unseen tasks and LLMs, exhibiting strong zero-shot capabilities; and (3) GraphP lanner effectively leverages historical memories, supporting both inductive and transductive infer- ence for more adaptive routing. Our code for GraphPlanner is released https: / /ttp://gtttt///// com http:/llaabuuuu/rraaaaaa anner.
INTRODUCTION
Routing among multi-agent large language models (LLMs) has become key approach for integrating the strengths of diverse models while balancing efficiency and performance (Shnitzer et al., 2023; Hu al., 2024a; Chen al., 2024a; Feng et al., 2024; 2025). Despite this importance, most existing routing methods remain confined to simplified or static settings, which limits their applicability in solving complex real-world tasks (Feng al., 2025). In contrast, the recent rise of agentic LLMs has shown how multi-agent collaboration can enhance plamning, strengthen reasoning, and boost overall performance on complex tasks (Wang al., 2024a; Qian al., 2024; Guo et al., 2024; Wu et al., 2024; Barachini & Stary, 2022; Tran et al., 2025). These agentic capabilities highlight the need revisit routing in more realistic and challenging scenarios, where heterogeneous LLMs differ in capability, cost, and reliability. In such contexts, effective routing is not only beneficial but necessary to fully unlock the potential of agentic L.M systems. Therefore, our paper aims to raise attention to this pressing research question: How can extend routers to agentic LLM settings?
Existing routing approaches fall into single-round and multi-round routers as shown in Table 1. Single-round routers (Shnitzer et al., 2023; Hu al., 2024a; Chen et al., 2024a; Feng et al., 2024) make one-shot assignments based on query embeddings or classifiers. While simple and efficient, multiple steps, decompose tasks, coordinate across
this paradigm lacks the ability reason different LLMs, which limits its effectiveness on complex queries. Multi-round routers (Zhang et al., 2025; Shao et al., 2025) extend flexibility by interleaving reasoning and routing over multiple calls.

---

Published as a conference paper at ICLR 2026
Table 1: Comparison of GraphPlanner with existing LLM routers across four dimensions: workflow type, historical memory usage, graph utilization, and model size. Unlike existing routers, GraphP1 anner is a lightweight LLM router based an agentic workflow, which leverages heterogeneous graphs to handle historical memories and thereby facilitate better routing.
LLM Router
Workflow type
Historical memory usage
Graph utilization
Model size
RouterDC (Chen al., 2024a)
Single-round
Medium
GraphRouter (Feng et al., 2024)
Single-ruudd
Small
R2. Reasoner (Shao et al., 2025)
Multi-round
X
Medium
Router-RI RI (Zhang et al., 2025)
Multi-roand
Large
Grapap Janner
aulti-agent
Small
However, they do not explicitly model collaboration between LLMs, treating each call as independent rather than part of cooperative workflow, which leads to redundant calls, context conflicts, and limited use of complementary strengths. Additional related works can be found in Appendix A.
To address these limitations, we generalize routing as multi-agent coordination problem, where the router must decide not only which LLM backbone to invoke but also which agent role to activate at each step. This shift is crucial because agentic LLM routers can explicitly model specialization and cooperation across multiple agents, turning independent calls into structured workflows. Yet, building an effective agentic LLM router is far from trivial and comes with several challenges. First, the relations among queries, responses, and LLM candidates are highly diverse and complex in agentic settings. Unlike single-step assignments, agentic workflows require reasoning over evolving contexts where queries may branch, responses interact, and different models contribute complementary but sometimes conflicting information. Designing a router that can capture and leverage these heterogeneous dependencies is non-trivial task. Second, agentic rouling involves deferred rewards. Early routing decisions often have long-term effects on the overall outcome, meaning that immediate feedback is insufficient. For example, early misallocation may cascade into redundant calls or degraded reasoning quality downstream. This creates a challenging credit assignment problem. requiring the router to balance short-term efficiency with long-teri performance. Third, it remains an open question how to fully exploit abundant historical memories from agentic L.M systems. Rich traces of past multi-agent workflows contain valuable insights into successful collaboration patterns, error modes, and efficient division of labor. Yet, existing routers rarely make systematic use of this information, leaving a gap in leveraging historical data for improving future coordination.
To tackle the above challenges, we propose GraphP 1 laner,, a heterogeneous graph memory- augmented agentic router for multi-agent LLMs that generates multi-agent routing workflows for each query and supports both inductive and transductive inference. Specifically, GraphP lanner casts the generation of agentic routing workflows as graph generation within a Markov Decision Process (MDP) (Garcia & Rachelson, 2013). At each step of graph generation, GraphP lanner must decide not only which LLM backbone invoke but also which agent role to activate based on the current state. Without loss of generality, we define the agent profiles as Planner, Executor, and Summarizer, which capture the essential roles in agentic workflows (Barachini & Stary, 2022: Tran et al., 2025). Further, GraphP lanner utilizes heterogeneous graph, denoted GARNet, to model the memories among LLM agents, queries, and responses. By capturing such heterogencous information, it can fully exploit abundant historical memories as well the current workflow memories, thereby constructing richer and more informative state representations. Finally, we introduce deep reinforcement learning algorithm named Proximal Policy Optimization (PPO) (Schulman et al., 2017) into the entire pipeline to jointly optimize task-specific performance of the final answers well as the associated computational cost.
We evaluate GraphP lanner in two phases across 14 tasks spanning 6 domains. In Phase 1, agentic routing is optimized within existing workflows, while Phase 2 focuses on generating workflows for complex agentic tasks. Across both phases, GraphP lanner consistently outperforms single- round and multi-round routers, improving average accuracy by +3.8% Phase and +9.3% in Phase 2, while reducing GPU cost from 186.26 GiB to 1.04 GiB and remaining on the Pareto frontier. Furthermore, GraphP lanner demonstrates strong generalization, achieving 78% average accuracy on unseen tasks (20-40% higher than previous routers) and robustly handling unseen LLMs without additional fine-tuning. Finally, by modeling historical memories alongside current workflow memories through GARNet, Graph Pooohllannee significantly enhances routing decisions and supports both inductive and transductive inference: the inductive mode offers greater efficiency, while the transductive mode yields stronger performance at higher cost.
2

---

Published as a conference paper at ICLR 2026
Queryg
Router
Rainale Selent
Final response
Queryq Select
Rmalti
Final response
Solect
ruugd Router,
Sequence
Multi-round Router
Executors
Planner
Rugentic
Summarizer
og
Query
Executor
response
Decompose
flon
Agentic Router
Figure 1: Comparison between the agentic router, the single-round router, and the multi-round router. Specifically, the single-round router selects model based only on the query, the multi-round router makes sequential selections using accumulated context, and the agentic router leverages workflow graph to jointly choose agent roles and models for collaborative reasoning. The agentic router enables explicit collaboration and task decomposition by leveraging a workflow memory graph, allowing multiple LLMs with different roles to coordinate more effectively than single/multi-round routers.
PRELIMINARIES
Routing among multiple large language models (LLMs) has emerged as crucial paradigm for balancing performance and efficiency. Existing approaches can be broadly categorized into single- round routers and multi-round routers. Before presenting our formulation of agentic routing, we first review these two settings and highlight their inherent limitations.
Single-round routers. In the standard setting, a router takes text query q E Q and directly assigns to one model from backbone pool M {M...... Mx Formally, single-round router (Shnitzer al., 2023; Hu et al., 2024a; Chen al., 2024a; Feng al., 2024) Rsingle as shown in the top-left part of Figure is defined as:
m Rsingle(q). 0 Mm (g),
(I)
where m denotes the selected model and is the output generated by Mn This paradigm is simple and efficient, but it lacks the ability to reason, decompose tasks, coordinate multiple LLMs. As result, it struggles when facing complex queries that require collaboration across specialized models.
Multi-round routers. To improve flexibility, the multi-round router (Zhang et al., 2025; Shao et al., 2025) as shown in the top-right part of Figure 1 considers routing decisions that take into account historical context information. Given a query 9t. the router adaptively chooses a backbone model based on both the current query and the context ez, where contains all previous queries, model selections, and outputs from the interaction history:
m Remuti q(), Mm (9:)-
This contextual design enables the router make more informed decisions by learning from past interactions and model performances. However, this sequential design may still incur redundant calls, risk semantic conflicts in accumulated context, and lack explicit mechanisms for coordinating complementary strengths of different models.
Agentic routers. To overcome these limitations, generalize routing multi-agent coordination problem. Instead of only selecting a backbone model, the router must also decide which agent role (e.g., Planner, Executor, Summarizer) activate. Given the query qe and the evolving workflow memory graph Gworkflow- the agentic router Ragentic as shown in the bottom part of Figure selects:
(at, m&) = Ragentic (qe, Sworkflow),
(3)
where a, indexes the chosen agent role Aa, and m; indexes the backbone Mn,- The pair (Aa,s M executes on the sub-query, producing intermediate output oz. These outputs are integrated through the workflow and summarized at the final stage to produce the answer. By explicitly modeling agent roles and workflows, agentic routers enable structured collaboration between LLMs, supporting decomposition, multi-role cooperation, and more adaptive decision-mann maccii.nnmmakng.....
3 GRAPHPLANNER GRAPH-BASEI AGENTIC LLM ROUTING
As shown in Figure 2, GraphP GraphPlanner lanner formulates LLM routing as a sequential decision-makinn process agentic workflows. At each step, the router selects both agent role (planner, executor,
3

---

Published as a conference paper at ICLR 2026
Quork flow
Legend
Shistory
Query node
LLM-rrol node Response node
Acc-Cost Edge
Query node
LLM-role node Response node
Acc-Cost Edge
GARNet
Query
LLM
Rale
Respense
Acc
Cost
adga
Query
LLM
Role
Respoase
Ace
Cost
ULaidd-Paever node
Responze
Decorppont..
11 (7ER)
Pianser
The-qerry
node
Bioerpues
Ponner
Tou prekime
bo
Germa Executor
Quurry
LLM-vol
Anserr
Gerna (9))
Ranancr
Thrne prinary
8677
embedding
embedding
Geteracc
Exeeskes
Insten
Step
$1
Action
8++1
Episode
update
update
Transition
Semrortne
Qwee7.5
Samvorbov
Contine 130
2553
Anoum
Queen (Th)
Toook mad b4 2353
Chistory
Overview of GraphPlanner, In GraphP Paanp,,lanner, lanner, each decision step is guided by GARNet, which integrates fworkflow and Ghistory produce an action that specifies both the LLM and the agent role. The resulting trajectories are incrementally incorporated into Sworkflow at each step. while the complete episode trajectory is consolidated into Iiistory at the end of the episode. Note that boxes and circles sharing the same color denote a direct mapping relationship.
Figure 2:
summarizer) and LLM backbone, guided by GARNet which integrates the current workflow memory graph Swork flow and the historical memory graph Ghistory- This graph-based formulation enables context-aware routing and supports end-to-end optimization through RL.
3.1 AGENTIC ROUTING WORKFLOW GENERATION AS MARKOV DECISION PROCESS
We cast the agentic routing workflow generation a Markov Decision Process (MDP), (8, A, 7), where S is the state space, AA the action space, T the transition dynamics, r the reward, and the discount factor.
At step t, the state is defined as the current query under resolution, denoted by s, = q. This formulation emphasizes that the environment is always centered on the query being processed at step 1, while contextual signals are implicitly captured through the evolving workflow structure.
State:
Without loss of generality, we define the agent role set as (planner, executor, summarizer). following prior multi-agent designs (Wu et al., 2024; Chen et al., 2023a; Barachini & Stary, 2022; Tran et al., 2025). Each action is pair a, (at, m²), where a specifies the role and m, indexes one of the candidate LLM backbones, yielding [A = 3K possible actions. In brief, the planner decomposes complex query into atomic sub-queries; the executor generates responses with without contextual grounding; and the summarizer condenses multiple outputs into a coherent and concise answer. To ensure semantic validity, we impose dynamic mask M, C A restricting available actions:
Action:
(1) At the first step, My ((lannnr, m), (executor, m) m 1,...,, K), prohibiting summa- rizer choices.
(2) At the final step, Mr [[xxecutor, m) [ I...., K}. enforcing workflow termination
only by execution.
(3) During the episode, planner actions are constrained by a hyperparameter Pmax E N such that if Ef 1(a; = planner) 2 Pmax. all planner actions removed from Mr+1.
Thus, the effective policy म S + M, always selects semantically valid actions.
Transition: The transition dynamics update the workflow memory by determining both the next query to resolve and the observable response step Formally, the environment outputs (s141.0,) = T(s,, at), where denotes the response generated by action on the current query 8t. Concretely:
(1) If a; = planner, the current query is decomposed into sub-queries, is the set of newly created sub-queries, and $111 set to the first child query.
(2) If 04 executor, the current query is resolved, or is the generated answer, and 8141 moves to the next pending query (or terminates if = T*).
(3) If a; = summarizer, the system aggregates completed responses, o, is the generated summary, and 8++1 is set the summary query.
4

---

Published as a conference paper at ICLR 2026
Thus, the state always denotes the query under resolution, while the sequence of responses {o:) provides the observable outputs that accumulate along the trajectory to form the final answer. Thus, the state always denotes the query under resolution, while the sequence of responses {ot} provides the observable outputs that accumulate along the trajectory form the final answer.
Reward: The reward balances task utility and routing cost:
(G. v²) - a C(a),, if = T (terminal),
C(aa);
if T (intermediate),
where ý is the predicted output, y² the ground-truth label, U(g. y²) task-specific utility (e.g.. accuracy, BLEU, or MRR), C(a+) the computational cost of action de, and > 0 a cost-utility trade-off coefficient.
Episode and Objective: An episode terminates once the root query is resolved, i... ST E Seeminal for some finite T. The router seeks policy maximizing the expected discounted return:
max 31
E
(r(ss at)
at ~ T(:)),
(5)
where Q is the query distribution and 7 E (0, 1] the discount factor.
3.2 HETEROGENEOUS GRAPH-BASER POLICY NETWORK
We parameterize the policy x x(a 9t) using a heterogeneous graph neural network, denoted as GARNet. At each step t, the environment is represented the union of workflow memory graph and a historical memory graph: Ge- = Sworkflow U Ghistory: Gt Ev),
Node initialization. We distinguish two types of graphs. For the workflow memory graph G Sworkflow. the nodes are: Iq E Rd,, Ir E Rd., Im [eroto: UC E Rdm, where 2g is the Longformer embedding of the current query, Iy, is the embedding of the response, and I' is the role hub node, constructed by concatenating the LLM-role textual embedding with task utility U and cost C. For the historical memory graph Ghistory. the nodes are: Thg E Rd,, The E Rdd, I' E R where Thg and Zhr are embeddings of past queries and responses, and Im is the same role hub node shared across workflow memory and historical memory, providing a bridge for information exchange between the two graphs. To make this design explicit, GraphPlanner shown in Figure 2 maintains a fixed set of role hub nodes, one for each (LLM, role) pair, which are reused across all routing steps and across both Gworkflow and Ghsstorg- Every query and response node, regardless of which round they are generated in, connects to these same role hub nodes. This architecture aggregates three sources of information through single interface: (i) the current workflow, (ii) accumulated historical interaction signals, and (iii) role-specific utility-cost profiles. By serving as the structural and semantic anchor between the two graphs, the shared role hub nodes enable consistent message passing, facilitate multi-round reasoning, and prevent the creation of redundant role nodes at each routing step.
Graph construction. In Swork flow. queries are connected to roles through edges eg enriched with task performance and cost information. Responses are linked the roles that generate them, and query-response edges preserve semantic alignment. In Ghistory historical queries The and responses 2hr are connected to role hub nodes 2m. through edges Cly-m and ehr-m These encode accumulated experience about how roles performed in past interactions, which can influence the current workflow. The shared role hub nodes I,m act as the anchor between Swork flom and Gnistory- ensuring that decision-making at the current step benefits from both local memory and historical memory. Multi-round routing does not introduce additional role nodes. Each newly generated sub-query response in later rounds is simply appended to the workflow graph and connected to the same shared role hub nodes. This implicitly connects different rounds through shared neighbors rather than explicit temporal edges, enabling GARNet reuse accumulated knowledge throughout multi-step routing.
Message passing. Each node embedding is projected into hidden space: h Wrr V V V., where T(v) denotes the node type. Messages are aggregated from neighbors: m. = AGG(M (v)), and node states are updated via residual connection: h, [0] my-
5

---

Published as a conference paper at ICLR 2026
Table 2: Phase 1 Evaluation: Model performance comparison with router baselines across five scenarios. Phase focuses on optimizing agentic routing within existing LLM workflows. We report results under two settings: Depth 1, Width 3 (left) and Depth 2, Width = (right). Bold and underline indicate the best and second-best results. Note that (*) indicates each single-round router is applied to select the LLM backbone for every agent in the Phase-1 workflow.
(a) Depth=1, 3idth=3
(b) Depth=2, Width=2
Router
Math
Code
Popular
Anerass
Router
Populac
Average
KNN
50.11%
81.7%
27.00%
KNN
63.0%
75.33%
33.50%
36205
2739.96
1740
Rost
39425
47.40%
Rostor
18.756
51390
RoutesSVMM
29.259
57.00%
77415
16.00%
57265
0.00
Routn-VVM
50.549
64.249
06005
11.35
(E71S
861
0.0
Roaterte
41.5%%
52.09%
85.85%
250055
100075
50,055
1689.25
-3.70
Rousixx"
36.799
50.00%
64.05
21025
35007
48.7%%
2687.11
-1105
Greg&Boate""
41.51%
48/009
29.33G
29.536
64. 149
45,809
797.35
0.50
Gegt
37.74%
57.33%
79633
37656
34 34.66%
40.20%
1215.32
+0.59
GraphF anner 55.00%
72,00% 76.07% 30.0%
47.00%
550,00%
500.5
+12.00
GraphP anner 06.50'
70,005
77/005
37.505
45.00%
(00.0%%
1500.37
+11,9
Table 3: Phase 2 Evaluation: Model performance comparison with router baselines across five scenarios. Phase 2 focuses on generating optimal workflows by jointly determining agent selection and LLM backbones. Bold and underline indicate the best and second-best results.
Setting
Math
Code
CS
WK
Popular
Average
Acc
Cost
Acc
Cost
Acc
Cost
Acc
Cost
Acc
Cost
Acc
Cost
Avg. LLM Calls AAcc (%)
Single-round Router
Router-KND
40.4%
183.5
66.0%
236.8
82.0%
105.8
27.0%
119.5
17.0%
232.3
49.7%
169.2
+9.3
Router-MI.P
43.3%
183.4
67.0%
240.6
82.0%
103.9
25.0%
120.7
7.0%
225.5
48.2%
168.4
+7.8
Bouter-SVM
38.6%
185.0
58.0%
254.0
78.0%
104.0
23.0%
136.0
13.0%
220.0
45.4%
179.8
+5.0
RouterDC
57.6%
186.7
51.0%
79.3%
39.4
32.0%
142.1
39.0%
272.7
54.3%
138.7
113.99
Graphikouter
53.2%
203.0
59.0%
280.0
82.7%
97.0
28.0%
60.0
21.0%
252.0
51.9%
178.4
+11.5
Multi-round Router
Prompt L.M
37.7%
1154.8
56.0%
954.3
76.2%
1215.6
24.0%
798.1
10.0%
1238.4
40.8%
1070.4
12.5
+0.4
Kouter-KNN-MR
39.6%
407.2
53.0%
432.6
73.5%
266.4
24.0%
327.9
12.0%
303.7
40.4%
347.6
7.2
0.0
R2-Reasoner
52.7%
760.0
49.6%
1200.0
72.8%
380.0
27.1%
270.0
37.4%
740,0
50.1%
643.6
5.4
+9.8
Router-R1
45.3%
46.4
52.0%
74.5
81.2%
27.9
28 69%
57.7
37.2%
199.0
51.8%
76.3
1.8
+11.4
GraphP Lanner
67.0%
682.2
76.0%
1130.9
78.0%
361.7
38.0%
252.8
52.0%
719.3
63.6%
605.0
8.1
+23,2
Nested dual-graph encoding. We employ a dual-graph encoding scheme. First, the historical memory graph is encoded: (hia)) GARNet (gnistory); producing updated embeddings of the role hub nodes summarizing past query-response interactions. These are then injected into the workflow memory graph encoder: ((ooo)) = GARNet gioe (wworkflow: H((hs)), yielding local- contextualized representations of queries, roles, and responses.
This shared-node mechanism ensures that the role hub nodes encode both the accumulated historical interaction patterns and the evolving workflow state. Because every query and response, across all routing rounds, attaches to the same set of role hubs, GARNet can naturally integrate multi-round contextual information without requiring an explicit temporal graph structure.
State fusion and action scoring. The global state representation is obtained by fusing the current query embedding St. 2 = (s)) Rd.. Each candidate action corresponds to a LLM--role node embedding fin.j E H (loc). Compatibility scores are computed as score, 2, hm..j. masked by Mr, exp( (o, and normalized into probability distribution: Ta, = j st) Σ exp(scores) (o.
GraphP SraphPlanner Training. We optimize the heterogeneous graph-based based policy network using Proximal Policy Optimization (PPO) (Schulman et al., 2017), a widely used actor-critic reinforcement learning algorithm. More details can be found in Appendix B.
4 EXPERIMENTS
In this section, we conduct comprehensive evaluation of GraphP lanner across a wide range of tasks spanning multiple domains, comparing its performance against both single-round and multi- round routers. We begin by briefly outlining the experimental settings. More implementation details can be found in Appendix C.
Dataset. We evaluate router models on 14 tasks across 6 domains (including in-domain and out-of- domain evaluation), selected from recent influential reports on LLM evaluation (Anthropic, 2024; Yang et al., 2025; Gunter et al., 2024). Following prior work (Chen et al., 2023a; Feng et al., 2025), we curated training and test splits for each task (details in Appendix D). The in-domain evaluation datasets include: (1) Math: GSM8K (Cobbe et al., 2021) and MATH (Hendrycks et al., 2021b).
(2) Code: MBPP (Austin et al., 2021) and HumanEval (Chen et al., 2021). (3) Commonsense Reasoning: CommonsenseQA (Talmor et al., 2019), ARC (Clark et al., 201 8), and OpenBookQA

---

Published as a conference paper at ICLR 2026
Depth =
Planner,
Planner O
e o
Final response
Query
Summarizer
Executor
Width
Decompose
Executor
Response
Figure 3: Detailed illustration of Phase 1 Evaluation. In the Phase 1 evaluation, primarily assess how well GraphP lanner optimizes user-defined LLM workflows. Without loss of generality, we construct the graph-based LLM workflow shown above and set hyperparameters: Depth and Width. Here, Depth refers to the number of planners, and Width denotes the maximum number of sub-queries that each planner is allowed to decompose.
NaturalQuestions (Kwiatkowski al., 2019) and TriviaQA (Joshi et al., 2017). (5) Popular: MMLU (Hendrycks et al., 2021a) and GPQA (Rein al., 2023). We further include (6) Out-of-domain evaluation, including LogicGrid (Mitra & Baral, 2015), MGSM (Shi et al., 2022), and CommonCien (Lin et al., 2019), which target reasoning, multilingual generalization, and commonsense generation, and used only for evaluation, ensuring the router is tested on genuinely unseen domains to rigorously assess generalization.
(Mihaylov et al., 2018). (4) World Knowledge:
LLM backbone. Following previous work (Feng et al., 2025), employed 12 representative LLMs grouped into three scales: small, medium, and large, including (1) Small scale LLMs: Qwen2.5 (7b) (Qwen al., 2025), CodeGemma (7b) (Team et al., 2024a), Mistral (7b) (Jiang al., 2023), LLaMA-3.1 (8b) (Grattafiori et al., 2024), LLaMA-3 ChatQA (8b) (Liu et al., 2024), and Gemma-2
(9b) (Team et al., 2024b); (2) Medium scale L.MSs: I.L.MA-3.3 Nemotron Super (49b) (Wang et al., 2024b), I.aMM-3.1 Nemotron (51b) (Wang et al., 2024b), and LLaMA- ChatQA (70b) (Liu et al., 2024); (3) Large scale LLMs: Mixtral (8 22b) (Jiang et al., 2024). We further summarize the corresponding scales, imput price, and output price of each LLM in Table 10 in the Appendix. Notably, besides the above LLMs that are involved in training, three
(12b) (Mistral AI, 2024), Mixtral (b) (Jiang et al., 2024), and Mixtral (8x 22b) (Jiang al., 2024) deliberately withheld. These underlined models are reserved exclusively for evaluation, ensuring that the assessment rigorously reflects the router's generalization ability previously unseen LLMs across different scales. More details can be found in Table 7 in the Appendix.
Task description.
We designed
two-phase evaluation. focuses on
As
shown in Figure 3. Phase 1 agentic routing within the pser-prrdefined LLM work- flows. In this phase, we specify different widths and depths for agentic workflows. The task is: given a query, different routers are expected to optimize the choice of L.LM backbones for different agents. In particular, we conduct experiments mainly under two Width = and Depth = 2, Width 22. Here, depth refers to the number of planners, and width denotes the maximum number of sub-queries that each planner is allowed decompose. Phase 2 Evaluation focuses on generating optimal workflows. Here, given query, different routers are expected to simultaneously optimize both the agent selections and the corresponding LLM backbones. Baselines and metrics. We evaluate a variety of baseline meth- ods across scenarios. The baselines are categorized into two groups: (a) Single-round routers that route a query by calling an LLM once, and (b) Multi-round routers that solve query by calling multiple LLMs. For all routers, following previous work (Feng et al., Acc and Cost to evaluate routing per- formance. Here, Ace refers to the task-specific evalu- ation metric introduced in Table 9 of the Appendix. Cost is calculated with the number of input tokens
Evaluation
optimizing
GraphPlanner Pareto Curve
0-0.0
GraphRouter (Single)
RouterDC (Single)
Router-R1 (Multi)
R2-Reasoner (Multl)
400
settings: Depth
0.33
300
100
50
52
64
Figure 4: Compared to baseline routers, GraphPlanner consistently forms the Pareto frontier, offering more efficient trade-offs between (with
Acc and Cost. GraphPlannes a E {0.0, 0.1, 0.3, 0.5, 0.9)) is compared against two single-roud round routers and two multiple-round routers.
2025),
7

---

Published as a conference paper at ICLR 2026
Table 4: Comparison of tokens used, GPU com- pute, and average LLM calls in Phase-2 train- ing. We observe that, compared with other routers, GraphP anner not only reduces token con- sumption during training but also lowers GPU compute requirements.
Table 5: Performance unseen datasets LogieGrid, MGSM, and CommonGen in Phase-2. We report both the individual results on each dataset and the averaged performance across them to evaluate the router's zero-shot
generalization ability on unseen datasets.
Router
Used Tokens GPU Compute Arg. LLM Train Calls
Roufer
LogicGrid
MGSM
CommonGen Aug. Acc
GruphRouter 6487M
1.54Gi8
1
GuaphRouter
12%
68%
57%
46%
RouterDC 64877M
10.56GBB
1
RouserXXC
82%
58%
Router-RI
150.36k
186.26GBB
1.18
Roater-R1
24%
40%
48%
38%
Graph:lannee
182.45K
100GBB
4.25
GraghPlaanes
92%
78%
and output tokens and the cost of different LLMs in Table 10 of the Appendix. Here we utilize GPT-2 as in (Feng et al., 2024) to calculate the number of tokens. Specifically, we have: (a) Single-round routers. We consider five representative single-round routers: 1) RouterKNN (Shnitzer et al., 2023), non-parametric baseline that assigns a query the nearest neighbors in embedding space and predicts the majority LLM label; 2) RouterMLP (Shnitzer et al., 2023), a multi-layer perceptron that leverages query embeddings and task context for routing; 3) RouterSVM (Hu et al., 2024a), a support vector machine trained on query features and task labels; 4) RoulerDC (Chen et al., 2024a), a query-based router trained with dual contrastive learning over encoder and L.LM embeddings, designed to distinguish among multiple LLMs even when several perform well; 5) GraphRouter (Feng et al., 2024), a graph-based model that formulates routing as node classification over a het- erogeneous graph of queries, tasks, and LLMs with learned edge interactions.
(b) Multi-round routers. We consider four representative multi-round routers: 1) Prompt LLM (Zhang et al., 2025), baseline that directly prompts an LLM to select LLMs without explicit routing modules, serving as a simple multi-round strategy; 2) Router-KNNY KNN-MR (Zhang et al., 2025), an iterative extension of Router- KNNN that repeatedly queries nearest neighbors in embedding space refine routing decisions; 3) R2- 22-Reasoner (Shao et al., 2025), veasoning-orienteed oriented router that conducts multi-step internal deliberation before invoking experts, improving decision quality through structured reasoning; 4) Router-RI RI (Zhang et al., 2025), the proposed reinforcement learning framework that interleaves think and route actions, aggregates expert outputs across rounds, and optimizes routing with a reward function balancing accuracy and cost.
4.1 GRAPEPLANNE. OUTPERFORMS SINGLE B-RUND AND MUT.TI-OUUND ROUTERS
For each setting in Phase I and Phase 2, we train and test a unified GraphP Panner across all scenarios. We compare GraphPlanner with five single-round routers and four multi-round routers, and report the results of Phase 1 and Phase 2 in Table 2 and Table 3, respectively. We have the following observations.
Specifically, for Phase-1, since there are no existing baselines, we extend the aforementioned single- round routers to the Phase-l setting for comparison. Specifically, we first train these single-round routers on the dataset reported in Table 6. During inference, each router is applied to select the LLM backbone for every agent within the Phase-1 workflow. To distinguish them from their original usage, append asterisk (+) to the single-round routers when they are adapted to the Phase- I setting.
GraphPlanner attains SOTA results across diverse scenarios. Across both phases, Graphpl anner demonstrates clear superiority over competitive baselines. In Phase 1, it achieves SOTA results in four out of five tasks while maintaining the highest overall average accuracy, yielding minimum improvement of +3.8% compared to the strongest baseline. In Phase 2, GraphPlanner lanner again secures SOTA in four out of five tasks and remains highly competitive in the remaining one, with an overall accuracy gain of +9.3% over the best baseline. These findings underscore GraphP anner 's robustness and effectiveness across diverse routing scenarios. We can also observe that Phase further amplifies SraphPlannee 's advantage: its average accuracy surpasses the best Phase-1 results by about 5%, showing that the ability to construct query-specific optimal agentic workflows yields stronger performance than optimizing within fixed workflows. The improve- ments are especially pronounced in cessoning-orientee tasks such as Math and Code, with gains of 5.0% and 4.0%, because these domains demand multi-step planning and benefit substantially from adaptive agent structures. By contrast, recognition-focuse tasks show only modest increases of around 1.0%, since they rely more on straightforward pattern matching, where flexible workflow exploration provides limited additional benefit.
GraphPlanne achieves superior routing performance with reduced training compute and lower token cost. We further analyzed the training overhead of GraphP1 I anner compared with
8

---

Published as a conference paper at ICLR 2026
Math
Math
Math
Popular
Code Popular
.045
Code
Popular
0.5
Oode
0.25
Wkk
WK
wk
Hlltory
Patero Graph
Figure 5: Comparison of GraphPlannes against baselines across different experimental settings in five scenarios under Phase-2. (a) Unseen LLMs generalization: We add the unseen LLMs-not introduced in the training in Table 7-into the LLM pool, and then evaluate the zero- shot generalization ability of GraphP anner, compared with GraphRouter and Router-R1. (b) Historical memories utilization ablations: We ablate historical memories utilization, contrasting GraphPlannes with variants w/o History, Homo-Graph, and Petter-GGraph encodings. (c) Trans- ductive vs. Inductive routing inference: We analyze GraphP 1 annee under transductive vs. induc- tive settings, where GraphP araphPlanner lanner consistently outperforms best multi-roun router Router-R1.
other routers. the Phase-2 training, we compared GraphP lanner with several representative routers in terms of tokens used, GPU compute, and average LLM calls, as shown in Table 4. We observe that GraphP Panner achieves the smallest GPU compute among all routers, demonstrating the efficiency of its lightweight design. Moreover, although GraphPlanner lanner consumes slightly more tokens than Router-RI, the results on average LLM training calls indicate that this due to GraphP lanner performing more extensive multi-step planning for different queries during training, which in turn leads to better routing performance.
GraphPlanner effectively balances trade-off' between performance and cost. As shown in Figure 4, GraphP Panner consistently forms the Pareto frontier, surpassing both single-round and multi-round routers. By adjusting a, it flexibly shifts between high-Ace, high-Cost, and low-Cost, lightweight settings. Compared with baselines, Graphp anner achieves either higher Acc under the same Cost or lower Cost at the same Acc, demonstrating more efficient and controllable trade-offs.
4.2 GRAPEPLANNER NICELY GENERALIZES ACROSS UNSEEN TASKS AND LLMS
A key challenge for router design is whether the learned strategy can generalize beyond the training distribution, adapting to entirely new tasks or unseen LLM backbones. To this end, we evalu- ate GraphP lanner in zero-shot setting on both novel tasks and unseen LLMs, analyzing its robustness and adaptability under Phase-2.
GraphPlanner generalizes robustly to unseen tasks. As shown in Table 5, GraphP lanner demonstrates strong zero-shot generalization, achieving an average Ace 78% across LogicGrid, MGSM, and CommonGen. This significantly outperforms both single-round routers (GraphRouter 46%, RC 58%) and the multi-round router Router-RI (38%). Notably, GraphP Pannee achieves the highest performance each dataset (60% on LogieGrid, 92% MGSM, and 82% on CommonGen), underscoring its robustness in handling diverse unseen tasks without additional tuning.
GraphPlannes effectively adapts to unseen LLMs in a zero-shot setting. As illustrated in Figure 5(a), Graphp1 hamphplannerr not introduced during training. Compared with GraphRouter and Router-RI, GraphP lanner consistently achieves superior performance across all task domains, indicating that its routing strategy generalizes effectively to new backbone models without additional fine-tuning This highlights the robustness of GraphP lanner handling zero-shot scenarios where the underlying LLMs differ from those seen in training.
anner demonstrates strong adaptability when evaluated with unseen L.MMs
4.3
ABLATION STUDIES VALIDATE GRAP PPPPPPINN PAANNPRS 'S KEY COMPONENTS
To better understand the contributions of individual design choices within PraphPlanner, we conduct ablation studies by systematically removing modifying key components. These experi- ments allow us to isolate the impact of historical interaction modeling and different routing inference strategies, thereby validating the necessity and effectiveness of each module.

---

Published as a conference paper at ICLR 2026
GARNet leverages historical agentic LLM interactions and current agent workflow states to enhance GraphPlanner decision-making. To assess the role of historical memories in GraphPlanner, we design three ablation variants:
w/o History: Removes all historical states, forcing GraphPlanme lanner to rely solely on the current input without accumulated interaction context.
Homo-Graph: Replaces CARNet with a homogeneous graph neural network' that treats all nodes and edges are treated as the same type, capturing structural relations but discarding role-specific heterogeneity.
Hetero-Graph: Replaces GARNet with heterogeneous graph neural network2 where nodes and edges are assigned different types, which distinguishes among roles but does not incorporate workflow dynamics.
As shown in Figure 5(b), removing historical memories (w/o History) leads to a substantial perfor- mance drop, demonstrating that accumulated interactions provide indispensable contextual signals beyond single-step reasoning. Introducing graph structures partially mitigates this degradation: the Homo-Graph variant captures basic relational structure but lacks role differentiation, yielding only limited gains. The Hetero-Gran Graph variant consistently outperforms Homo- Homo-Graph by distinguishing among agent roles, confirming that heterogeneity carries richer relational cues. Nevertheless. both graph-based variants remain clearly inferior to the full GARNet design. Beyond heterogeneous modeling, GARNet provides an efficient and lightweight mechanism to capture workflow dynamies, enabling it to model not only who interacts but also how these interactions evolve over time. This dynamic perspective equips GraphP 1 Lanner with stronger contextual awareness and adaptability, allowing it to leverage historical interactions far more effectively than generic GNN-based encoders.
GraphP GraphPlanner Lanner generates routing decisions under both inductive and transductive ways. To evaluate the effect of different routing inference strategies, compare two settings:
During inference, GraphPlan lnnner directly generates routing decisions without holding out or reusing any historical interactions from the training phase. This design is lightweight and avoids additional storage or retrieval overhead.
Inductive:
Transductive: During inference, GraphP 1 lanner leverages preserved historical interactions collected during training, enabling richer context utilization at the cost of higher computational and memory overhead.
As shown in Figure 5(c), the transductive strategy achieves slightly better overall performance, demonstrating that leveraging stored historical interactions provides additional contextual cues that enhance routing quality. However, this improvement comes with increased inference cost, as the model must maintain and query interaction histories. The inductive strategy, while more lightweight, still maintains strong performance and consistently outperforms the best multi-round router baseline, Rou In summary, both inference strategies are valuable: the transductive setting delivers the highest accuracy when efficiency is less critical, whereas the inductive setting provides more resource -ffircceeefffiinnttttee solution with competitive performance. This flexibility allows GraphP 1 lanner to adapt to different user priorities, offering either maximum effectiveness efficient deployment without significant performance sacrifice.
5 CONCLUSION
We introduced GraphPlannnn lanner, a heterogeneous workflow generation within an MDP, leveraging the heterogeneous graph GARNet to integrate historical and workflow memories and training the policy via reinforcement learning. Extensive experiments across 14 tasks and 6 domains show that GraphP lanner delivers state-of-the-ar performance, robust generalization to unseen tasks and LLMs, and favorable trade-offs between accuracy and computational cost. These results underscore the potential of extending LLM routing into agentic settings and open new directions for scalable, cooperative multi-agent LLM systems. In future work, we plan to incorporate richer agent profiles beyond Planner, Executor, and Summarizer to further enhance agentic routing.
multi-agent router that casts routing
'https: httr:::s//pyttcch-geee wwwp:/terrchgmmerrriiiee c. readthedocs...... httpthhhoss..oee////a////eeerete geomet c. nn. conv, GCNConV html
Phtpps: / httttp://pyttoccheeeee http:/yytttrcc--mmmrrriii.. readthedocs 9//p://2...//ggeeaaee///rror
geomet c. nn. conv, HeteroConv. html
10

---

Published as a conference paper at ICLR 2026
ETHICS STATEMENT
All authors of this paper have read and adhered to the ICLR Code of Ethics. Our work does not involve human subjects, personal data, or sensitive attributes. We followed best practices for data usage, ensured compliance with licensing terms, and considered potential risks of bias misuse.
REPRODUCIBILITY STATEMENT
We have made every effort to ensure the reproducibility of our results. Details of the model archi- tecture, training settings, and hyperparameters are described in Section 4. All datasets we used are publicly available. The training scripts and evaluation code will be released upon publication to facilitate replication.
REFERENCES
AI Anthropic. Claude 3.5 sonnet model card addendum. Claude-3.5 Model Card, 3(6), 2024.
Jacob Austin, Augustus Odena, Maxwell Nye. Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, and Charles Sutton. Program synthesis with large language models, 2021. URL https:: /war/aa.vvorrr/ee org. abs 2108 07732.
Franz Barachini and Christian Stary. From digital twins to digital selves and beyond: Engineering and social models for a trans-humanist world. Springer Nature, 2022.
Edward Y Chang. Maci: Multi-agent collaborative intelligence for adaptive reasoning and temporal planning. arXiv preprint arXiv:2501.16689 2025.
Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Ka- plan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger. Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, Nick Ryder, Mikhail Pavlov, Alethea Power, Lukasz Kaiser, Mohammad Bavarian, Clemens Winter, Philippe Tillet, Felipe Petroski Such, Dave Cummings, Matthias Plappert, Fotios Chantzis, Elizabeth Barnes, Ariel Herbert-Voss, William Hebgen Guss, Alex Nichol. Alex Paino, Nikolas Tezak, Jie Tang, Igor Babuschkin, Suchir Balaji. Shantanu Jain, William Saunders, Christopher Hesse, Andrew N. Carr, Jan Leike, Josh Achiam, Vedant Misra, Evan Morikawa, Alec Radford, Matthew Knight, Miles Brundage, Mira Murati, Katie Mayer, Peter Welinder, Bob McGrew, Dario Amodei, Sam McCandlish, Ilya Sutskever, and Wojciech Zaremba. Evaluating large language models trained on code, 2021. URL https:://// /tt////axivvvi org/ abs/ 2207 C3374.
Shuhao Chen, Weisen Jiang, Baijiong Lin, James Kwok, and Yu Zhang. Routerde: Query-based router by dual contrastive learning for assembling large language models. Advances in Neural 2024a.
Information Processing Systems,
Weize Chen, Yusheng Su, Jingwei Zuo, Cheng Yang. Chenfei Yuan, Chen Qian, Chi-Min Chan, Yujia Qin, Yaxi Lu, Ruobing Xie, et al. Agentverse: Facilitating multi-agent collaboration and exploring emergent behaviors in agents. arXiv preprint arXiv:2308. 10848, 2(4):6, 2023a.
Weize Chen, Ziming You, Ran Li, Yitong Guan, Chen Qian, Chenyang Zhao, Cheng Yang, Ruobing Xie, Zhiyuan Liu, and Maosong Sun. Internet of agents: Weaving a web of heterogeneous agents for collaborative intelligence. arXiv preprint arXi::2407.07061, 2024b.
Xinyun Chen, Renat Aksitov, Uri Alon, Jie Ren, Kefan Xiao, Pengcheng Yin, Sushant Prakash, Charles Sutton, Xuezhi Wang, and Denny Zhou. Universal self-consistency for large language model generation. arXiv preprint arXiv:2311.173:: 2023b.
Peter Clark, Isaac Cowhey, Oren Etzioni, Tushar Khot, Ashish Sabharwal, Carissa Schoenick, and Oyvind Tafjord. Think you have solved question answering? try are, the ai2 reasoning challenge, 2018. URL httpt:://// arwia.aiiv...... org/ haabb//183..554 05457.
Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. Training verifiers to solve math word problems, 2021. URL https: httpppps:///ai....eee //arxiv.org/ abs/2110 14168.
11

---

Published as a conference paper at ICLR 2026
I De Zarzä, J De Curtò, Gemma Roig, Pietro Manzoni, and Carlos T Calafate. Emergent cooperation and strategy adaptation in multi-agent systems: An extended coevolutionary theory with llms. Electronics, 12(12):2722, 2023.
Yilun Du, Shuang Li, Antonio Torralba, Joshua B Tenenbaum, and Igor Mordatch. Improving factuality and reasoning in language models through multiagent debate. In Forty-first International Conference on Machine Learning, 2023.
Tao Feng, Yanzhen Shen, and Jiaxuan You. Graphrouter: A graph-based router for Ilm selections. arXiv preprint arXiv:2410.03833 2024.
Tao Feng, Haozhen Zhang. Zijie Lei, Pengrui Han, Mostofa Patwary, Mohammad Shoeybi. Bryan Catanzaro, and Jiaxuan You. Fusing IIm capabilities with routing data. arXiv preprint arXiv:2507. 10540, 2025.
Frédérick Garcia and Emmanuel Rachelson. Markov decision processes. Markov Decision Processes in Artificial Intelligence, pp. 1-38, 2013.
Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, Amy Yang. Angela Fan, Anirudh Goyal, Anthony Hartshorn, Aobo Yang, Archi Mitra, Archie Sravankumar, Artem Korenev, Arthur Hinsvark, Arun Rao, Aston Zhang, Aurelien Rodriguez, Austen Gregerson, Ava Spataru, Baptiste Roziere, Bethany Biron, Binh Tang. Bobbie Chern, Charlotte Caucheteux, Chaya Nayak, Chloe Bi, Chris Marra, Chris McConnell, Christian Keller, Christophe Touret, Chunyang Wu, Corinne Wong, Cristian Canton Ferrer, Cyrus Nikolaidis, Damien Allonsius, Daniel Song, Danielle Pintz, Danny Livshits, Danny Wyatt, David Esiobu, Dhruv Choudhary. Dhruv Mahajan, Diego Garcia- Olano, Diego Perino, Dieuwke Hupkes, Egor Lakomkin, Ehab AlBadawy, Elina Lobanova, Emily Dinan, Eric Michael Smith, Filip Radenovic, Francisco Guzmán, Frank Zhang, Gabriel Synnaeve, Gabrielle Lee, Georgia Lewis Anderson, Govind Thattai, Graeme Nail, Gregoire Mialon, Guan Pang, Guillem Cucurell, Hailey Nguyen, Hannah Korevaar, Hu Xu, Hugo Touvron, Iliyan Zarov, Imanol Arrieta Ibarra, Isabel Kloumann, Ishan Misra, Ivan Evtimov, Jack Zhang, Jade Copet, Jaewon Lee, Jan Geffert, Jana Vranes, Jason Park, Jay Mahadeokar, Jeet Shah, Jelmer van der Linde, Jennifer Billock, Jenny Hong, Jenya Lee, Jeremy Fu, Jianfeng Chi, Jianyu Huang, Jiawen Liu, Jie Wang, Jiecao Yu, Joanna Bitton, Joe Spisak, Jongsoo Park, Joseph Rocca, Joshua Johnstun, Joshua Saxe, Junteng Jia, Kalyan Vasuden Alwala, Karthik Prasad, Kartikeya Upasani, Kate Plawiak, Ke Li, Kenneth Heafield, Kevin Stone, Khalid El-Arini, Krithika Iyer, Kshitiz Malik, Kuenley Chiu, Kunal Bhalla, Kushal Lakhotia, Lauren Rantala-Yeary, Laurens van der Maaten, Lawrence Chen, Liang Tan, Liz Jenkins, Louis Martin, Lovish Madaan, Lubo Malo, Lukas Blecher, Lukas Landzaat, Luke de Oliveira, Madeline Muzzi, Mahesh Pasupuleti, Mannat Singh, Manohar Paluri, Marcin Kardas, Maria Tsimpoukelli, Mathew Oldham, Mathieu Rita, Maya Pavlova, Melanie Kambadur, Mike Lewis, Min Si, Mitesh Kumar Singh, Mona Hassan, Naman Goyal, Narjes Torabi, Nikolay Bashlykov, Nikolay Bogoychev, Niladri Chatterji, Ning Zhang, Olivier Duchenne, Onur Çelebi, Patrick Alrassy, Pengchuan Zhang. Pengwei Li, Petar Vasic, Peter Weng, Prajjwal Bhargava, Pratik Dubal, Praveen Krishnan, Punit Singh Koura, Puxin Xu, Qing Hc. Qingxiao Dong, Ragavan Srinivasan, Raj Ganapathy, Ramon Calderer, Ricardo Silveira Cabral, Robert Stojnic, Roberta Raileanu, Rohan Maheswari, Rohit Girdhar, Rohit Patel, Romain Sauvestre, Ronnie Polidoro, Roshan Sumbaly, Ross Taylor, Ruan Silva, Rui Hou, Rui Wang, Saghar Hosseini, Sahana Chennabasappa. Sanjay Singh, Sean Bell, Seohyun Sonia Kim, Sergey Edunov, Shaoliang Nie, Sharan Narang, Sharath Raparthy, Sheng Shen, Shengye Wan, Shruti Bhosale, Shun Zhang, Simon Vandenhende, Soumya Batra, Spencer Whitman, Sten Sootla, Stephane Collot, Suchin Gururangan, Sydney Borodinsky, Tamar Herman. Tara Fowler, Tarek Sheasha. Thomas Georgiou, Thomas Scialom, Tobias Speckbacher, Todor Mihaylov, Tong Xiao, Ujjwal Karn, Vedanuj Goswami, Vibhor Gupta, Vignesh Ramanathan, Viktor Kerkez, Vincent Gonguet, Virginie Do. Vish Vogeti, Vítor Albiero, Vladan Petrovic, Weiwei Chu, Wenhan Xiong, Wenyin Fu, Whitney Meers, Xavier Martinet, Xiaodong Wang. Xiaofang Wang. Xiaoqing Ellen Tan, Xide Xia, Xinfeng Xie, Xuchao Jia, Xuewei Wang. Yaelle Goldschlag, Yashesh Gaur, Yasmine Babaci, Yi Wen, Yiwen Song, Yuchen Zhang, Yue Li, Yuning Mao, Zacharie Delpierre Coudert, Zheng Yan, Zhengxing Chen, Zoe Papakipos, Aaditya Singh, Aayushi Srivastava, Abha Jain, Adam Kelsey, Adam Shajnfeld, Adithya Gangidi, Adolfo Victoria, Ahuva Goldstand, Ajay Menon, Ajay Sharma, Alex Boesenberg, Alexei Baevski, Allie Feinstein, Amanda Kallet, Amit Sangani, Amos Teo,
12

---

Published as a conference paper at ICLR 2026
Anam Yunus, Andrei Lupu, Andres Alvarado, Andrew Caples, Andrew Gu, Andrew Ho, Andrew Poulton, Andrew Ryan, Ankit Ramchandani, Annie Dong, Annie Franco, Anuj Goyal, Aparajita Saraf, Arkabandhu Chowdhury, Ashley Gabriel, Ashwin Bharambe, Assaf Eisenman, Azadeh Yazdan, Beau James, Ben Maurer, Benjamin Leonhardi, Bernie Huang, Beth I Loyd, Beto De Paola, Bhargavi Paranjape, Bing Liu, Bo Wu, Boyu Ni, Braden Hancock, Bram Wasti, Brandon Spence, Brani Stojkovic, Brian Gamido, Britt Montalvo, Carl Parker, Carly Burton, Catalina Mejia, Ce Liu, Changhan Wang, Changkyu Kim, Chao Zhou, Chester Hu, Ching-Hsiang Chu, Chris Cai, Chris Tindal, Christoph Feichtenhofer. Cynthia Gao, Damon Civin, Dana Beaty, Daniel Kreymer, Daniel Li, David Adkins, David Xu, Davide Testuggine, Delia David, Devi Parikh, Diana Liskovich, Didem Foss, Dingkang Wang, Duc Le. Dustin Holland, Edward Dowling, Eissa Jamil, Elaine Montgomery, Eleonora Presani, Emily Hahn, Emily Wood, Erie-Tuan Le, Erik Brinkman, Esteban Arcaute, Evan Dunbar, Evan Smothers, Fei Sun, Felix Kreuk, Feng Tian, Filippos Kokkinos, Firat Ozgenel, Francesco Caggioni, Frank Kanayet, Frank Seide, Gabriela Medina Florez, Gabriella Schwarz, Gada Badcer, Georgia Swee, Gil Halpem, Grant Herman, Grigory Sizow, Guangyi. Zhang, Guna Lakshminarayanan, Hakan Inan, Hamid Shojanazeri, Han Zou, Hannah Wang. Hanwen Zha, Haroun Habeeb, Harrison Rudolph, Helen Suk, Henry Aspegren, Hunter Goldman, Hongyuan Zhan, Ibrahim Damlaj, Igor Molybog, Igor Tufanov, Ilias Leontiadis, Irina-Elena Veliche, Itai Gat, Jake Weissman, James Geboski, James Kohli, Janice Lam, Japhet Asher, Jean-Baptiste Gaya, Jeff Marcus, Jeff Tang, Jennifer Chan, Jenny Zhen, Jeremy Reizenstein, Jeremy Teboul, Jessica Zhong, Jian Jin, Jingyi Yang. Joe Cummings, Jon Carvill, Jon Shepard, Jonathan McPhie, Jonathan Torres, Josh Ginsburg. Junjie Wang, Kai Wu, Kam Hou U, Karan Saxena, Kartikay Khandelwal, Katayoun Zand, Kathy Matosich, Kaushik Veeraraghavan, Kelly Michelena, Keqian Li, Kiran Jagadeesh, Kun Huang, Kunal Chawla, Kyle Huang, Lailin Chen, Lakshya Garg, Lavender A, Leandro Silva, Lee Bell, Lei Zhang. Liangpeng Guo, Licheng Yu, Liron Moshkovich, Luca Wehrstedt, Madian Khabsa, Manav Avalani, Manish Bhatt, Martynas Mankus, Matan Hasson, Matthew Lennie, Matthias Reso, Maxim Groshev, Maxim Naumov, Maya Lathi, Meghan Keneally, Miao Liu, Michael L. Seltzer, Michal Valko, Michelle Restrepo, Mihir Patel, Mik Vyatskov, Mikayel Samvelyan, Mike Clark, Mike Macey, Mike Wang, Miquel Jubert Hermoso, Mo Metanat, Mohammad Rastegari, Munish Bansal, Nandhini Santhanam, Natascha Parks, Natasha White, Navyata Bawa, Nayan Singhal, Nick Egebo, Nicolas Usunier, Nikhil Mehta, Nikolay Pavlovich Laptev, Ning Dong, Norman Cheng, Oleg Chernoguz, Olivia Hart, Omkar Salpekar, Ozlem Kalinli, Parkin Kent, Parth Parekh, Paul Saab, Pavan Balaji, Pedro Rittner, Philip Bontrager, Pierre Roux, Piotr Dollar, Polina Zvyagina. Prashant Ratanchandani, Pritish Yuvraj, Qian Liang, Rachad Alao, Rachel Rodriguez, Rañ Ayub, Raghotham Murthy, Raghu Nayani, Rahul Mitra, Rangaprabhu Parthasarathy, Raymond Li, Rebekkah Hogan, Robin Battey Rocky Wang, Russ Howes, Ruty Rinott, Sachin Mehta, Sachin Siby. Sai Jayesh Bondu, Samyak Datta, Sara Chugh, Sara Hunt, Sargun Dhillon, Sasha Sidorov, Satadru Pan, Saurabh Mahajan, Saurabh Verma, Seiji Yamamoto. Sharadh Ramaswamy, Shaun Lindsay, Shaun Lindsay, Sheng Feng, Shenghao Lin, Shengxin Cindy Zha, Shishir Patil, Shiva Shankar, Shuqiang Zhang. Shuqiang Zhang, Sinong Wang. Sneha Agarwal, Soji Sajuyigbe, Soumith Chintala, Stephanie Max, Stephen Chen, Steve Kehoe, Steve Satterfield, Sudarshan Govindaprasad, Sumit Gupta, Summer Deng, Sungmin Cho, Sunny Virk, Suraj Subramanian, Sy Choudhury, Sydney Goldman, Tal Remez, Tamar Glaser, Tamara Best, Thilo Koehler, Thomas Robinson, Tianhe Li, Tianjun Zhang, Tim Matthews, Timothy Chou, Tzook Shaked, Varun Vontimitta, Victoria Ajayi, Victoria Montanez, Vijai Mohan, Vinay Satish Kumar, Vishal Mangla, Vlad Ionescu, Vlad Poenaru, Vlad Tiberiu Mihailescu, Vladimir Ivanov, Wei Li. Wenchen Wang, Wenwen Jiang, Wes Bouaziz, Will Constable, Xiaocheng Tang. Xiaojian Wu, Xiaolan Wang, Xilun Wu, Xinbo Gao, Yaniv Kleinman, Yanjun Chen, Ye Hu, Ye Jia, Ye Qi, Yenda Li, Yilin Zhang, Ying Zhang, Yossi Adi, Youngjin Nam, Yu, Wang, Yu Zhao, Yuchen Hao, Yundi Qian, Yunlu Li, Yuzi He, Zach Rait, Zachary Vito, Zef Rosnbrick, Zhaoduo Wen, Zhenyu Yang, Zhiwei Zhao, and Zhiyu Ma. The laaa herd of models, 2024.
Tom Gunter, Zirui Wang, Chong Wang, Ruoming Pang. Andy Narayanan, Aoman Zhang, Bowen Zhang, Chen Chen, Chung-Cheng Chiu, David Qiu, et al. Apple intelligence foundation language models. arXiv preprint a0X1v:2407.21075, 2024.
Taicheng Guo, Xiuying Chen, Yaqi Wang, Ruidi Chang, Shichao Pei, Nitesh V Chawla, Olaf Wiest, and Xiangliang Zhang. Large language model based multi-agente A survey of progress and challenges. arXiv preprint arXiv:2402.01688) 2024.
13

---

Published as a conference paper at ICLR 2026
Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. Measuring massive multitask language understanding, 2021a. URL https:// arxiv.org/abee abs /tt.b///009... 200.b//0000000000....
Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Measuring mathematical problem solving with the math dataset, 2021b.
URL https::///// //axxvxvvvv..////aa//ee////aaall wwt.ooggg/////o////e../eee 20.0//2//... 03874.
Qitian Jason Hu, Jacob Bieker, Xiuyu Li, Nan Jiang, Benjamin Keigwin, Gaurav Ranganath, Kurt Keutzer, and Shriyash Kaustubh Upadhyay. Routerbench: A benchmark for multi-lIm routing system. arXiv preprint arXiv:2403. 2024a.
Shengran Hu, Cong Lu, and Jeff Clune. Automated design of agentic systems. arXiv preprint wwXiv2240.008433 2024b.
Albert Q. Jiang, Alexandre Sablayrolles, Arthur Mensch, Chris Bamford, Devendra Singh Chaplot, Diego de las Casas, Florian Bressand, Gianna Lengyel, Guillaume Lample, Lucile Saulnier, Lélio Renard Lavaud, Marie-Anne Lachaux, Pierre Stock, Teven Le Scao, Thibaut Lavril, Thomas Wang, Timothée Lacroix, and William El Sayed. Mistral 7b, 2023. URL https: //arxiv. exq/abs / 2310. 06825.
Albert Q Jiang, Alexandre Sablayrolles, Antoine Roux, Arthur Mensch, Blanche Savary, Chris Bamford, Devendra Singh Chaplot, Diego de las Casas, Emma Bou Hanna, Florian Bressand, et al. Mixtral of experts. arXiv preprint arXiv:2401.04005 2024.
Mandar Joshi, Eunsol Choi, Daniel Weld, and Luke Zettlemoyer. TriviaQA: A large scale distantly supervised challenge dataset for reading comprehension. In Regina Barzilay and Min-Yen Kan (eds.), Proceedings of the 55th Annual Meeting of the Association for Com- putational Linguistics (Volume 1: Long Papers), pp. 1601-1611, Vancouver, Canada, July 2017. Association for Computational Linguistics. doi: 10.18653/1//117-1147. URL https: // s/aclanthologgg www.rcoolooy.orro/11111113 org/p17-1147/.
Tom Kwiatkowski, Jennimaria Palomaki, Olivia Redfield, Michael Collins, Ankur Parikh, Chris Alberti, Danielle Epstein, Illia Polosukhin, Jacob Devlin, Kenton Lee, Kristina Toutanova, Llion Jones, Matthew Kelcey, Ming-We Wei Chang, Andrew M. Dai, Jakob Uszkoreit, Quoc Le, and Slav Petrov. Natural questions: A benchmark for question answering research. Transactions of the Association for Computational Linguistics, 7:452-466. 2019. doi: 10.1162/tacl 00276. URL
ht.tps:/ accl antho Machoology.. hww.hlllgy.ooogg///oooooo 9-066//
Hunter Lightman, Vineet Kosaraju, Yuri Burda, Harrison Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. Let's verify step by step. In The Twelfth International Conference on Learning Representations, 2023.
Bill Yuchen Lin, Wangchunshu Zhou, Ming Shen, Pei Zhou, Chandra Bhagavatula, Yejin Choi, and Xiang Ren. Commongen: constrained text generation challenge for generative commonsense 2019.
reasoning, arXiv preprint
Zihan Liu, Wei Ping, Rajarshi Roy, Peng Xu, Chankyu Lee, Mohammad Shoeybi, and Bryan Catan- zaro. Chatqa: Surpassing gpt-4 on conversational qa and rag. arXiv preprint 27X 2024.
Todor Mihaylov, Peter Clark, Tushar Khot, and Ashish Sabharwal. Can a suit of armor conduct electricity? new dataset for open book question answering, 2018. URL ht /arxiv. org/abs/ 110...00.... 02789.
Mistral AI. Introducing mistral nemo, May 2024. URL mist ra reeoo Accessed: 2025-05-16.
Arindam Mitra and Chitta Baral. Learning to automatically solve logic grid puzzles. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 1023-1033, 2015.
14

---

Published as a conference paper at ICLR 2026
Shishir G Patil, Tianjun Zhang. Xin Wang, and Joseph E Gonzalez. Gorilla: Large language model connected with massive apis. Advances in Neural Information Processing Systems, 37: 126544-126565, 2024.
Chen Qian, Zihao Xie, Yifei Wang, Wei Liu, Kunlun Zhu, Hanchen Xia, Yufan Dang, Zhuoyun Du, Weize Chen, Cheng Yang, et al. Scaling large language model-basee multi-agent collaboration. arXiv preprint vxXiv24406007155, 2024.
Qwen, An Yang, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang, Haoran Wei, Huan Lin, Jian Yang, Jianhong Tu, Jianwei Zhang, Jianxin Yang, Jiaxi Yang, Jingren Zhou, Junyang Lin, Kai Dang, Keming Lu, Keqin Bao, Kexin Yang. Le Yu, Mei Li, Mingfeng Xue, Pei Zhang, Qin Zhu, Rui Men, Runji Lin, Tianhao Li, Tianyi Tang, Tingyu Xia, Xingzhang Ren, Xuancheng Ren, Yang Fan, Yang Su, Yichang Zhang, Yu Wan, Yuqiong Liu, Zeyu Cui, Zhenru Zhang, and Zihan Qiu. Qwen2.5 technical report, 2025. URL https:/ arxiv..... org/ abs/
David Rein, Betty Li Hou, Asa Cooper Stickland, Jackson Petty, Richard Yuanzhe Pang, Julien Dirani, Julian Michael, and Samuel R. Bowman. Gpqa: A graduate-level google-proof q & benchmark, 2023. URL https::t////.. //axivv org/ abs /ttes/23110 2////311.1110 2112..202.......1
Timo Schick, Jane Dwivedi- Yu, Roberto Dessi, Roberta Raileanu, Maria Lomeli, Eric Hambro, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. Toolformer: Language models can teach themselves to tools. Advances in Neural Information Processing Systems, 36:68539-68551 2023.
John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
Amrith Setlur, Chirag Nagpal, Adam Fisch, Xinyang Geng, Jacob Eisenstein, Rishabh Agarwal, Alekh Agarwal, Jonathan Berant, and Aviral Kumar. Rewarding progress: Scaling automated process verifiers for Ilm reasoning. arXiv preprint arXiv:2410.08146, 2024.
Yu Shang, Yu Li, Keyu Zhao, Likai Ma, Jiahe Liu, Fengli Xu, and Yong Li. Agentsquare: Automatic Ilm agent search in modular design space. arXiv preprint arXiv:2410.06153, 2024.
Chenyang Shao, Xinyang Liu, Yutang Lin, Fengli Xu, and Yong Li. Route-and-reason Scaling large language model reasoning with reinforced model router. arXiv preprint arXiv:2506.0590 2025.
Freda Shi, Mirac Suzgun, Markus Freitag, Xuezhi Wang, Suraj Srivats, Soroush Vosoughi, Hyung Won Chung, Yi Tay, Sebastian Ruder, Denny Zhou, et al. Language models are mul- tilingual chain-of-thonn of-thought reasoners. arXiv preprint xrXiv:2110003057 2022.
Tal Shnitzer, Anthony Ou, Mírian Silva, Kate Soule, Yuekai Sun, Justin Solomon, Neil Thompson, and Mikhail Yurochkin. Large language model routing with benchmark datasets. arXiv preprint arXiv:2309.15789 2023.
Alon Talmor, Jonathan Herzig, Nicholas Lourie, and Jonathan Berant. Commonsenseqa: A question answering challenge targeting commonsense knowledge, 2019. URL abs/1811 00937.
CodeGemma Team, Heri Zhao, Jeffrey Hui, Joshua Howland, Nam Nguyen, Siqi Zuo, Andrea Hu, Christopher A Choquette-Choe Jingyue Shen, Joe Kelley, al. Codegemma: Open code models based on gemma. arXiv preprint arXiv:2406. 1409, 2024a.
Gemma Team, Morgane Riviere, Shreya Pathak, Pier Giuseppe Sessa, Cassidy Hardin, Surya Bhupatiraju, Léonard Hussenot, Thomas Mesnard, Bobak Shahriari, Alexandre Ramé, et al. Gemma 2: Improving open language models practical size. arXiv preprint arXiv:2408.000 2024b.
Khanh-Tung Tran, Dung Dao, Minh-Duong Nguyen, Quoc-Vie' Pham, Barry Ouulivva,, and Hoang D Nguyen. Multi-agent collaboration mechanisms: A survey of llms. arXiv preprint AXiv:2501.06322 2025.
15

---

Published as a conference paper at ICLR 2026
Lei Wang, Chen Ma, Xueyang Feng, Zeyu Zhang, Hao Yang, Jingsen Zhang, Zhiyuan Chen, Jiakai Tang, Xu Chen, Yankai Lin, et al. A survey on large language model based autonomous agents. Frontiers Computer Science, 18(6):183445, 2024a.
Yizhong Wang, Yeganeh Kordi, Swaroop Mishra, Alisa Liu, Noah A Smith, Daniel Khashabi, and Hannaneh Hajishirzi. Self-instruct: Aligning language models with self-generated instructions. arXiv preprint arXiv:2212.105000 2022.
Zhilin Wang, Alexander Bukharin, Olivier Delalleau, Daniel Egert, Gerald Shen, Jiaqi Zeng, Oleksii Kuchaiev, and Yi Dong. Helpsteer2-preefeencc: Complementing ratings with preferences, 2024b.
URL https::pp/// /arxiav......////// owt.oorg////... http//bb/2221.... 01257.
Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc Le, Denny Zhou, et al. Chain-of-thouggh prompting elicits reasoning in large language models. Advances in neural information processing systems, 35:24824-24837, 2022.
Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Beibin Li, Erkang Zhu, Li Jiang, Xiaoyun Zhang, Shaokun Zhang. Jiale Liu, et al. Autogen: Enabling next-gen Ilm applications via multi-agent conversations. In First Conference on Language Modeling, 2024.
An Yang, Anfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengen Huang, Chenxu Lv, et al. Qwen3 technical report. arXiv preprint arXiv:2505.0935. 2025.
Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. In The eleventh international conference on learning representations, 2022.
Haozhen Zhang, Tao Feng, and Jiaxuan You. Router-rl: Teaching llss multi-round routing and aggregation via reinforcement learning. arXiv preprint arXiv:2506609033, 2025.
Hongxin Zhang, Weihua Du, Jiaming Shan, Qinhong Zhou, Yilun Du, Joshua B Tenenbaum, Tianmin Shu, and Chuang Gan. Building cooperative embodied agents modularly with large language models. arXiv preprini arXiv:2307.02453 2023.
Jiayi Zhang, Jinyu Xiang, Zhaoyang Yu, Fengwei Teng, Xionghui Chen, Jiaqi Chen, Mingchen Zhuge, Xin Cheng, Sirui Hong. Jinlin Wang, et al. Aflow: Automating agentic workflow generation. arXiv preprint arXiv:2410. 10762, 2024a.
Lunjun Zhang, Arian Hosseini, Hritik Bansal, Mehran Kazemi, Aviral Kumar, and Rishabh Agarwal. Generative verifiers: Reward modeling as next-token prediction. arXiv preprint arXiv:2408.15240, 2024b.
Mingchen Zhuge, Wenyi Wang. Louis Kirsch, Francesco Faccio, Dmitrii Khizbullin, and Jürgen Schmidhuber. Language agents optimizable graphs. arXiv preprint arXiv:2402.16823, 2024.
16

---

Published as a conference paper at ICLR 2026
A ADDITIONAL RELATED WORK
LLM-Agents and Agentic Systems. Recent studies have shown that organizing LLM-based agents into multi-agent systems (MAS) can substantially enhance reasoning, adaptability, and overall performance beyond single-agent settings (Wang et al., 2024a; Qian et al., 2024; Guo et al., 2024). Early frameworks such as AutoGen (Wu et al., 2024), LLM-Debate (Du et al., 2023), and AgentVerse (Chen et al., 2023a) demonstrated gains in factuality. robustness, and efficiency, but relied on manually designed protocols that limited adaptability (Zhuge et al., 2024; De Zarzà et al., 2023). Moreover, most MAS assume agents share the same backbone, constraining heterogeneity where diverse models could provide complementary strengths. Inspired by human teamwork, later work explored autonomous cooperation, showing that agents can self-organize, exhibit emergent behaviors, and dynamically divide labor (Barachini & Stary, 2022; Tran et al., 2025). Studies further reported improved reasoning through social behaviors, negotiation, and role specialization (Zhang et al., 2023; Chen et al., 2024b; Chang, 2025). These advances highlight a shift toward automated agentic systems, yet current MAS research predominantly relies on identical LLM backbones across all agents, which fundamentally constrains the exploration of agent capability diversity and limits the potential for truly complementary collaboration. To address these limitations, a newer line of work focuses on automating the design of multi-agent workflows rather than relying on rigid, manually constructed systems such as ADAS (Hu et al., 2024b) adaptively schedule agents based on task complexity, AFlow (Zhang et al., 2024a) automatically searches action graphs to construct multi-step workflows, and AgentSquare (Shang et al., 2024) generates task-specific collaboration strategies from a library of roles, but all still assume largely homogeneous agent capabilities. Inspired by the potential of recent workflow- -eaeerttognnntiiinnn systems to better structure multi- step reasoning, introduce agentic routing framework that automatically selects heterogeneous LLM agents and composes workflows tailored to each query.
protocols. Recent workflow-generatee
Augl-nugee LLMs and deploying LLM agents in real-world tool ecosystems, where models interact with external APIs, knowledge bases, software environments. Early systems such as Toolformer (Schick al., 2023), Gorilla (Patil et al., 2024), and ReAct-based tool agents (Yao et al., 2022) enable LLMs to invoke functions or APIs for grounded decision-making. Production LangChain, Semantic Kernel, AutoGPT, and OpenAl's caallinnn agents agents-further demonstrate the importance of reliable tool integration, execution monitoring, and safety in practical deployments. These systems highlight that tool-use and API grounding are central to building real-world agentic pipelines. yet they typically rely on static or manually designed workflows, underscoring the need for more flexible, learned workflow generation and routing strategies.
Agent Ecosystems. A parallel line of work focuses on
caaneworks-incluee
LLM routers. Routing among multiple LLMS key paradigm for balancing efficiency and accuracy. Existing approaches fall into single-round and multi-round routers. Single-round routers make one-shot assignments using query embeddings or classifiers, such as RouterKNN (Shnitzer al., 2023) and RouterMLP (Shnitzer et al., 2023), RouterSVM (Hu et al., 2024a), RouterDC (Chen et al., 2024a), and GraphRouter (Feng et al., 2024). These methods are efficient but lack sequential reasoning. Multi-round routers enable iterative decisions, as in Prompt LLM (Zhang al., 2025), Router-KINN-MR (Zhang et al., 2025), R2-Reasoner (Shao et al., 2025). and Router-RI (Zhang et al., 2025), which combine deliberation and routing with reinforcement learning. While more flexible. they remain restricted to backbone selection without modeling agent roles or heterogencity. Current paradigms thus face two limitations: focusing only on backbone choice and assuming homogeneous models. Agentic routing researched by our paper addresses these by jointly deciding which agent and which backbone to invoke, combining routing efficiency with the adaptability, specialization, and heterogeneity of multi-agent systems.
B GRAPHPLANNER TRAINING DETAILS
We optimize the heterogeneous graph-based policy network using Proximal Policy Optimization (PPO) (Schulman et al., 2017). a widely used actor-critic reinforcement learning algorithm. PPO trains the policy by maximizing:
(0) = B. min (O), 1,, 1,
(6)
17

---

Published as a conference paper at ICLR 2026
where Te and Tyo denote the current and previous policies, respectivlyy and
Px To((a 8e, Sworktoww Gnistory)
Taua (at St, Sworktoww Stistory)
Here, A, is the estimated advantage at step t, c is a clipping threshold, & the current state, aj the chosen action, Wworktow is the workflow interaction graph, and Hustory is the historical interaction graph.
C IMPLEMENTATION DETAILS
We implement GraphPlanner with PPO backbone, where both policy and value functions are parameterized by GARNet to integrate local and historical state information. Local state graphs encode query embeddings, role-LLM embeddings, and memory updates, while historical graphs aggregate past interaction representations: each graph is projected via linear-normalization-Relll block and fused by meta-key aggregation. GARNet is implemented using the torch.scatter library for efficient graph-based message passing and sparse aggregation. The policy network computes action probabilities by matching fused state representations (query, task, and state tower outputs) against role-LLM embeddings with action masking. while the value network processes state, local, and historical features through multi-layer transformations to output scalar value estimates. Training follows PPO with clipped objectives (? 0.99, 0.2, k 4 epochs per update). We set hidden dimension to 32, candidate embedding dimension to 1536, and state embedding dimension to 768. Adam optimizer is used with learning rate 10 for policy and doubled for value, combined with gradient clipping (norm 0.5), BF16 training, and gradient checkpointing. To improve data collection efficiency, we adopt multi-threaded rollout design that processes multiple queries in parallel and generates routing interactions simultaneously. This design increases sample throughput, reduces wall-clock training time, and stabilizes PPO updates by providing more diverse experience iteration. Training is capped at 1000 episodes with early stopping once policy entropy drops below a threshold, indicating reduced exploration. During evaluation, greedy decoding is applied and the best model is selected by rumning reward. All experiments conducted single NVIDIA A6000 GPU.
D DATASET AND LLM BACKBONE DETAILS
Table 6: The domains and corresponding tasks of the dataset used in our experiment. Specifically, it spans representative domains and 14 tasks. Note that the scenarios and corre- sponding tasks marked with underline are held out from the training set and reserved solely for evaluating the router's generalization per- formance on unseen tasks.
Table 7: The scales and corresponding LLMs used our experiment. Specifically, the 12 LLMs are categorized into three scales based on model size. Note that the LLMs marked with underline are not involved in the training process, but are only included in experiments that evaluate the router's generalization to unseen LLMs.
Scale
LLMS
Tasks
Qwen2.5 (7b), CodeGemmns (7b), Mistral (7b)
GSM8K, MATH
Small
I.aMA-3.. (8h), a.M. ahaAAChhrrA (8h), Gemma-2 (9h)
Code
MBPP, HumanEval
Mistral-Nemo (12b)
CommonscnscQA. ARC. OpenBoookQA
Commonsense Ressoning
LLaMA-3.3 Nemotron Super (49b)
World Knowledge
NaturalQuestion, TriviaQA
Medium
LLaMA-3.J
(51b), Mixtral
Popular
MMLU, GPQA
LLaMA-3 ChaiQA (70b)
LogicGrid, MGSM.
Our-of-domain Testing
CommonGen
Large
Mixual (8x22b)
D.1 TASK DESCRIPTIONS
The benchmarks summarized in Tables 8 and 9 span math, code, commonsense reasoning, world knowledge, popular comprehensive tests, and out-of-domain evaluation. Below we provide brief descriptions for each task to orient the reader.
18

---

Published as a conference paper at ICLR 2026
Table 8: Sample counts in the training set and test across different tasks.
Domain
Tasks
Train Cases
Test Cases
GSM8K (Cobbe al., 2021)
500
50
Math
MATH (Hendrycks et al., 2021b)
500
50
MBPP (Austin et al., 2021)
374
50
Code
HumanEval (Chen et al., 2021)
120
44
CommonsenseQAA (Talmor et al., 2019)
500
50
Commonsense
ARC (Clark et al., 2018)
500
50
Reasoning
OpenBookQA (Mihaylov et al., 2018)
500
50
World
NaturalQuestions (Kwiatkowski et al., 2019)
500
50
Knowledge
TriviaQA (Joshi et al., 2017)
500
50
MMLU (Hendrycks et al., 2021a)
500
50
Popular
GPQA (Rein et al., 2023)
400
44
LogieGrid (Mitra & Baral, 2015)
50
Out-of-domail Testing
MGSM (Shi al., 2022)
50
CommonGen (Lin et al., 2019)
50
Table 9: The tasks and corresponding evaluation metrics of the dataset used in our experiment, organized by domain.
Domain
Tasks
Metrics
GSM8K (Cobbe al., 2021)
Accuracy
Math
MATH (Hendrycks et al., 2021b)
Accuracy
MBPP (Austin et al., 2021)
Pass@
Code
HumanEval (Chen et al., 2021)
Pass@I
CommonsenseeAA (Talmor et al., 2019)
Accuracy
Commonsense
ARC (Clark et al., 2018)
Accuracy
Reasoning
OpenBookQA (Mihaylov et al., 2018)
Accuracy
World Knowledge
NaturalQuestions (Kwiatkowski al.,
CEM
2019)
TriviaQA (Joshi al., 2017)
CEM
MMLU (Hendrycks et al., 2021a)
Accuracy
Popular
GPQA (Rein et al., 2023)
Accuracy
LogicGrid (Mitra & Baral, 2015)
Accuracy
Out-of-domain Testing
MGSM (Shi et al., 2022)
Accuracy
CommonGen (Lin et al., 2019)
Coverage
GSMSK. GSM8K is a grade- school math word-problem dataset designed to probe multi-step arith- metic reasoning with natural-language solutions (Cobbe et al., 2021). Problems typically require decomposing the question into several simple operations and tracking intermediate quantities. has become a standard testbed for chain-of-thought prompting and verifier-based solution selection. We report accuracy following the setup in Table 9.
MATH. The MATH benchmark consists of 12,500 competition-style problems spanning algebra, geometry, number theory, and more, each with step-by-step solutions (Hendrycks et al., 202 lb). evaluates symbolic reasoning and solution derivation beyond simple calculation. Because problems include full worked solutions, the dataset also supports training methods that supervise intermediate reasoning. We report accuracy in Table 9.
19

---

Published as a conference paper at ICLR 2026
Table 10: Language Models and estimated price (in per 1M tokens).
Size Type
Model
Size
Input Price
Output Price
Qwen2.5 (Qwen et al., 2025)
7B
0.20
0.20
CodeGemma (Team al., 2024a)
7B
0.20
0.20
Mistral (Jiang al., 2023)
7B
0.20
0.20
Small
LLaMA-3.1 (Grattafiori et al., 2024)
8B
0.20
0.20
LLaMA-3 ChatQA (Liu
2024)
8B
0.20
0.20
Gemma-2 (Team al., 2024b)
9B
0.20
0.20
Mistral-Nemo (Mistral 2024)
12B
0.30
0.30
LLaMA-3.3 Nemotron Super (Wang et al., 2024b)
49B
0,90
0.90
LLaMA-3.1 Nemotron (Wang et al., 2024b)
51B
0,90
0.90
Medium
Mixtral (Jiang et al., 2024)
56B (8x7B)
0.60
0.60
LLaMA-3 ChatQA (Liu et al., 2024)
70B
0,90
0.90
Large
Mixtral (Jiang al., 2024)
176B (8x22B)
1.20
1.20
MBPP. MBPP (Mostly Basic Python Problems) evaluates function-level code synthesis from short natural-language prompts (Austin et al., 2021). Tasks are designed to be solvable by entry-level programmers and include unit tests automatically check correctness. It emphasizes core Python fluency, standard library use, and simple algorithmic reasoning. We use pass @ as the principal metric (Table 9).
HumanEval measures functional correctness of generated Python code on hand- written problems with hidden unit tests (Chen et al., 2021). Prompts include function signatures and docstrings, and success requires passing all tests for a task. The benchmark introduced the widely used pass @ metric; we report pass Table stresses precise adherence to specifications and robust program synthesis.
HumanEval.
CommonsenseQA is a multiple-choice benchmark targeting commonsense reasoning via questions constructed from ConceptNet relations (Talmor et al., 2019). Distractors are chosen to be plausible, making surface cues insufficient. Models must draw on background knowledge and everyday plausibility. We report accuracy listed in Table 9.
Commonsense
ARC. The A12 Reasoning Challenge (ARC) comprises grade-school science questions split into Easy and Challenge subsets (Clark et al., 2018). The Challenge set contains items that defeat simple retrieval and co-occurrence methods, emphasizing multi-hop reasoning and science knowledge. Questions are multiple choice and text-only. Accuracy is reported per Table 9.
OpenBook QA. OpenBookQA evaluates the ability to apply small "open book" of elementary science facts to novel situations (Mihaylov al., 2018). Solving a question typically requires combining core fact with commonsense or auxiliary knowledge. The format is multiple choice, and retrieval-augiee augmentd methods are commonly explored. We report accuracy as Table
Natural Questions (NQ). NQ contains real, anonymized user queries paired with Wikipedia pages and annotated short and long answers (Kwiatkowski et al., 2019). is a challenging, realistic QA benchmark requiring document-level comprehension and answer span identification. In our setup we evaluate case-insee case-insensitive exact match (CEM) following Table The task stresses reading comprehension.
NaturalQuestions
TriviaQA. TriviaQA provides questions written by trivia enthusiasts along with evidence documents, encouraging multi-sentence reasoning and robust retrieval (Joshi et al., 2017). Compared to earlier compreeesoo datasets, it features more compositional and diverse questions. We report CEM in Table 9. The dataset probes broad world knowledge under noisy evidence.
MMLU, MMLU (Massive Multitask Language Understanding) is 57-subject multiple-choice exam spanning humanities, social sciences, STEM, and professional domains (Hendrycks et al., 2021a). evaluates breadth of knowledge and reasoning in a zero- or few-shot setting. The benchmark is widely used for holistic comparison across models. We report accuracy per Table 9.
GPQA. GPQA (Graduate-Level Google-Pros Q&A) consists of expert-authoree multiple-choie questions in biology, physics, and chemistry designed to resist simple web search (Rein et al., 2023).
20

---

Published as a conference paper at ICLR 2026
It targets deep, specialized scientific understanding and careful reasoning. The dataset is intentionally difficult for both non-experts and strong LMs. We report accuracy as summarized in Table 9.
LogicGrid. This benchmark comprises classic logic-grid (Zebra-style) puzzles expressed in natural language, requiring deduction over entities, attributes, and constraints (Mitra & Baral, 2015). Success demands translating textual clues into structured constraints and performing consistent reasoning. It stresses symbolic consistency and global constraint satisfaction. We evaluate accuracy as in Table 9.
MGSM. MGSM (Multilingual Grade School Math) is multilingual extension of GSM8K created by translating problems into diverse languages (Shi et al., 2022). It measures whether multi-step arithmetic reasoning ability transfers across scripts and linguistic structures. The benchmark is commonly used to assess chain-of-thought prompting in multilingual settings. We report accuracy per Table
CommonGen. CommonGen evaluates generative commonsense reasoning by asking models to compose a coherent sentence that must include given set of concepts (Lin et al., 2019). The task requires relational and compositional generalization beyond simple lexical co-occurrence. It is used to study controllable generation under semantic constraints. We report coverage per Table 9.
AIME The American Invitational Mathematics Examination (AIME)² is high-difficulty mathe- matical reasoning benchmark consisting of 15 integer-answe problems per year, designed assess advanced problem-solving skills among top performers in the AMC competitions. Unlike typical multiple-choice math datasets, AIME items require multi-step symbolic reasoning, numeric pre- cision, and long-horizon planning without external tools. The dataset evaluates models' abilities in algebra. geometry, number theory, and combinatorics, emphasizing deliberate reasoning over surface-level pattern matching. Following prior work, adopt accuracy the primary metric and report performance per Table 9.
D.2 MODEL DESCRIPTIONS
The language models in Table 10 cover small, medium, and large configurations, with prices and sizes reported there. Below are brief descriptions to contextualize each model family.
Qwen2.5 (7B). Qwen2.5 is a recent generation of the Qwen family, offering open-weight models optimized for purppse utility, instruction following, and strong reasoning/coding performance (Qwen et al., 2025). The 7B variant targets efficient deployment while retaining competitive capability across standard benchmarks. The family emphasizes multilingual coverage and long-context usability. We use the size and pricing shown in Table 10.
CodeGemma (7B). CodeGemma a code-specialized family derived from Gemma that supports code completion, generation, and conversational coding assistance (Team al., 2024a). It adds training signals for software tasks and is commonly used with "fil--n-thhemmidde" prompting. The 7B model balances latency with solid pass@k performance Python-centric benchmarks. Pricing details are given in Table 10.
Mistral (7B). Mistral 7B is open-weight, decoder-only transformer engineered for efficiency, featuring grouped-query attention and diding-windort attention for fast inference on long sequences (Jiang et al., 2023). Despite its compact size, it performs strongly on reasoning, math, and code tasks relative to larger predecessors. is frequently used as base for instruct-tuned and domain-specialized variants. See Table 10 for cost information.
LLaMA-3.1 (8B). LLaMA-3.1 denotes Meta's open- ween-weight models emphasizing improved instruction -fllowiin......oiing. multilinguality, and extended context capabilities (Grattafiori al., 2024). The 8B model provides a lightweight option suitable for on-prem or edge use while retaining strong general performance. It widely used as a base for fine-tuning and tool-using assistants. Pricing is listed in Table 10.
LLaMA-3 ChatQA (8B/ 70B). ChatQA refers to instruction-tuned QA/chat variants designed to excel at question answering and sarrival-auumented workflows (Liu et al., 2024). These models are adapted for dialogue-oriente reasoning and factuality under supervision and preference data. The 8B and 70B sizes provide options trading latency for accuracy. Refer to Table 10 for sizes and costs.
http//www.w/ maa. httpos///ww.......rrgtttthhh-
21

---

Published as a conference paper at ICLR 2026
Gemma-2 (9B). Gemma-2 is Google's second-generatee open family that introduces architectural refinements for practical-size models while advancing reasoning and multilingual performance (Team al., 2024b). The 9B variant is commonly adopted middle ground between capability and deployability. It serves as a base for domain-tuned and coding- spening-ee derivatives. Costs are summarized in Table 10.
Mistral-Nemo (12B). Mistral-Nemo is a collaboratively developed open-weight model emphasizing efficient inference and high-quality instruction following (Mistral AI, 2024). With 12B parameters, largets general-purpose chat, reasoning, and code assistance while remaining deployment-friendy often used on NVIDIA accelerators and associated toolchains. See Table 10 for pricing.
LLaMA-3.3 Nemotron Super (49B). Nemotron Super (49B) represents an instruction -unnee assistant model associated with NVIDIA's Nemotron lineup and geeference-opimmizaiee tooling (Wang et al., 2024b). It emphasizes helpfulness, safety, and strong reasoning via high-quality preference data. Positioned between lightweight and frontier models, seeks strong accuracy with manageable cost. Pricing appears in Table 10.
LLaMA-3.1 Nemotron (51B). The 51B Nemotron variant builds on the LLaMA-3.1 family with large-scale instruction tuning and preference modeling for chat and tool-use scenarios ( (Wang et al., 2024b). aims to combine robust knowledge with alignment for reliable multi-turn QA. This size targets improved quality over small/medium models while controlling inference cost. See Table 10.
Mixtral (8 7B). Mixtral 8x is sparse Mixture-of-Experts (MoB) model where a small subset of experts is activated token, delivering strong performance efficient compute (Jiang et al., 2024). inherits the Mistral architecture and uses routing to select experts dynamically. improving scaling characteristics. Widely adopted instruct variants make it strong all-around choice. Costs listed in Table 10. Mixtral (8x22B) Mixtral 8x22B scales the MoE design larger experts for higher accuracy while retaining the sparse-activation efficiency benefits (Jiang et al., 2024). It is frequently used for multilingual, reasoning, and coding workloads with long inputs. Instruct-tuned releases are popular for production chat systems. Pricing is shown in Table 10.
E EXPERIMENTS ON NEW AGENTIC ROLES
Table 11: Comparison on the setting of new agentic roles. This table compares GraphPlannes under three settings involving two newly added agentic roles (Thinker and Verifier). New-role-train evaluates whether GraphP lanner can learn use the new roles through RL training. New-role- zero-shot tests the zero-shot generalization ability of GraphP anner to new roles without any role-specific training. New-role-few fews-ff examines few-shot generalization by providing limited historical interactions involving the new roles during testing.
Setting
Math
Code
CS
WK
Popular
GraphPlanme
67.0%
76.0%
78.0%
38.0%
52.0%
New-role-zeroosshot
68.5%
77.0%
78.3%
38.5%
52.2%
New-role-few-shot
69.6%
77.8%
78.8%
39.0%
52.4%
New-role-train 70.5%
78.5%
79.0%
39.5%
52.5%
To explore whether GraphP anner can adapt and generalize to new agentic roles, we introduce two additional agent roles that are widely Sein-rhinke (Wei et al., 2022; Wang et al., 2022; Chen et al., 2023b) and Verifier (Lightman et al., 2023; Zhang et al., 2024b; Setlur et al., 2024) on top of the original three. The Thinker agent processes input queries through systematic reasoning to produce detailed draft analyses, with its prompt template and role description provided in Tables 22 and 27 of the Appendix, respectively. Similarly, the Verifier agent evaluates the accuracy and quality of the generated content before the final output, and its prompt template and role description are also detailed in Tables 23 and 28 of the Appendix. We further design three ablation variants to compare with GraphP lanner using only three agentic roles:
New-role-train: This setting is designed to evaluate whether GraphPlannes can learn to use new agentic roles through RL training. Specifically, this setting extends the original
22

---

Published as a conference paper at ICLR 2026
GraphP Lanner by adding two additional agentic roles, the Thinker and Verifier, and trains and tests the model on the tasks and LLMs used the Phase-2 setting.
New-role-zero-shot: This setup aims to examine the zero-shot generalization ability of GraphPlannes to new roles. Therefore, the training stage identical the current version of GraphPlannes whereas during testing the policy is allowed to choose among five agentic roles.
New-role-few-shot This setting also evaluates the few-shot generalization ability of GraphPlanna to new roles. this case, the training stage remains the same as the original GraphPlanner but during testing augment Ghistory with 50 historical interactions gener- ated by randomly selecting I % the training queries and pairing them with all five agentic roles. During testing, the policy again choose among all five agentic roles.
We report our results in Table 11. Comparing the New-role-train setting with the original GraphPlannes shows that incorporating additional agentic roles leads consistent performance improvements, indicating that GraphP anner is highly adaptable to different agent-role config- urations. Furthermore, the results from the New-role-zero-sho and New-role-few-sho settings reveal that GraphPlanne generalizes effectively to previously unseen agentic roles: even without role-specific training, it can quickly adapt to new agentic setups and achieve higher task performance. Overall, these findings demonstrate that GraphP lanner not only learns to leverage new roles when trained on them, but also possesses strong zero-shot and few-shot generalization capabilities across diverse agentic-role environments.
ADDITIONAL ABLATIONS ON OTHER GRAPH ENCODERS
Table 12: Ablation different graph encoders within the GraphPlanner architecture across five scenarios. We replace our proposed encoder GARNet with two commonly used alternatives: (1) GAT-based encoder and (2) Graph Transfrrrrommerbbbaaa encoder, as detailed in the footnotes below. This comparison evaluates whether the performance gains of GraphP lanner r stem from the design of our lightweight graph encoder.
Setting GAT
Math
Code
CS
WK
Popular
0.643
0.739
0.756
0.358
0.493
Graph Tranffrrrsr
0.647
0.743
0.759
0.353
0.491
GraphP lanner
0.670
0.760
0.780
0.380
0.520
In this section, we perform ablations on different graph encoders to verify the effectiveness of GARNet. We design two ablation variants to compare with GraphPlanner:
GAT: Replaces GARNet with a graph attention network".
Graph Transforrre Replaces GARNet with GraphTransffrmeet
We report our results in Table 12. Across all five scenarios, GraphP annner achieves the strongest overall performance compared with both GAT and Trashrrrasffommer. Relative GAT, it yields consistent gains ranging from 2.8% % to 6.1% % across domains, with the largest improvements observed in the WK and Popular scenarios. Compared with the heavier Granhrransformer, GraphP lanner still provides 2.3 %-7.6% % relative improvements while maintaining substantially lower architectural and computational overhead. These results confirm that our tailored graph encoder CARNet not only delivers the best accuracy but also remains lightweight and efficient alternative transformer-based graph encoders.
G ADDITIONAL ABLATIONS ON HISTORICAL INFORMATION PROCESSING
In this section, we compare GraphP anner with other methods that use LLM to process historical interactions and make routing decisions. To be specific, we design two baselines based on Router-Ri
Phttps://pytonn hhetesss/ppycorrhh-eeeerrrr http://pwr....oootrrrrreeeeeeees
geomet c. c. mo html Shtpps htttpp://pyytorc--geeeeee transformer. html
23

---

Published as a conference paper at ICLR 2026
Table 13: Ablations on historical information processing. We compare different strategies for incorporating past interaction histories into the routing process. The History-summary setting stores all prior interactions and injects summary of the histories most relevant to the current query, constrained by a 32,768-tokert context limit. The /eistvry-relrieval setting augments this approach most similar interaction histories and inserting the retrieved contexts directly into the routing prompt. This ablation evaluates how summary-based versus retrieval-based historical information influences routing performance.
by retrieving the top
Setting
Math
Code
CS
WK
Popular
Router-RI
0.45
0.52
0.81
0.29
0.37
History-retrieval
0.46
0.62
0.73
0.12
0.39
History-summary
0.51
0.62
0.75
0.14
0.36
SraphPlanner 0.67
0.76
0.78
0.38
0.52
History-summary: This setting extends Router-R1 by explicitly storing all past interaction histories. During both training and testing, the Router-R1 base model summarizes the interaction histories most relevant to the current query, constrained by its maximum context length (32,768 tokens). The resulting summary is then injected into the routing prompt as additional contextual guidance for selecting the appropriate route.
History-retrieval: Compared with the History-summary setting, which only incorporates sum- maries of neighboring interactions, this variant additionally performs retrieval: identifies the top K=5 most similar interaction histories to the current query and incorporates these retrieved contexts directly into the routing prompt. This design allows the router leverage both global historical summaries and fine- tneeggainned retrieved evidence when making routing decisions.
We report our results in Table 13. We can observe that LLM-based historical information processing provides only limited improvements over Router-RI, as both summarization and retrieval must operate over highly heterogeneous and unstructured interaction histories. Such histories contain mixed-quality reasoning traces and contextually entangled signals that LLMs struggle to exploit when injected directly as summaries or retrieved text. In contrast, GraphPlanne consistent gains across all scenarios, outperforming the best history-based method by 31.4% % on Math, 22.6% on Code, 4.0% % on CS, 171.4% on WK, and 33.3% on Popular. These results demonstrate that graph-based encoder GARNet provides significantly more principled and robust mechanism for modeling complex historical interactions, enabling GraphP SichPlannn lanner to capture cross-interaction structure, suppress noise, and effectively propagate useful relational information for routing.
achieves substantial and
H ADDITIONAL EXPERIMENTS ON NEW DATASET
Table 14: Performance on unseen dataset AIME in Phase-2, Bold and underline indicate the best and second-best results.
Single-round Router
Multi-cound Router
Metric
Graphe Lanner
Router KNN Router-MLL Router SVM ReuterDC GraphiRouter Prompt LLM Router KNN MR R2 Reasoner Router RI
Acc (98)
3.95
7.14
4.43
2.90
7.56
3.40
3.71
7.30
5.21
14.7
We compare the zero-shot generalization ability between GraphP GraphPlanner anner and baselines on A AIMES under the setting of Phase-2. Specifically, under the Phase-2 setting, we train all methods and conduct zero-shot evaluation on the AIME datasets from 2016 to 2025, whose detailed descriptions are hamphiaanner the unseen AIME dataset with accuracy of 14.7%, which is almost
provided in Section D. We report our results in Table 14. GraphP anner achieves the strongest zero-shot performance twice as high as the best baseline accuracy of 7.56%. Most single-round and multi-round routers remain below 8%, indicating limited transfer ability competition-level math problems. In contrast, GraphP] 1 anner benefits from its graph-structured workflow planning, which provides substantially better generalization to complex reasoning tasks.
/ww. www.waaa..coomm
24

---

Published as a conference paper at ICLR 2026
1 COMPARISON ON TIME COST
Table 15: Time cost comparison across all methods in Phase-2. We report four metrics: Data Col- lecting Time, the cost of generating interaction data; NN Training Time, the time required to optimize router parameters; Total Time for Training, the of both for fair comparison across supervised and RL-based methods; and Inference Time, the average latency per query during deployment.
Singh-munnd
Multi-runn
GraphPlanon
NNN
Roune-MLLP
Route-SVM
RouteOCC
Grophikontrr Phonpe LIM
Router-KNN- AR Ri-Resoner
RouteR)
Tuts Callecting Time (min)
395
395
395
395
395
0
0
NN Trxining Time (min)
34
82
7.
11
62
7
360
300
120
Total Time Training [min]
4004
403.
4027
406
401.
100 100
(siquers)
We compare the training and inference time costs of all methods under the Phase-2 setting. In the training stage, supervised approaches such as GraphRouter require collecting interaction data between each training query and all LLMs before training begins. In contrast, RL-based methods such as GraphP lanner and Router-RI collect data dynamically during training. To ensure fair comparison, we report a unified metric, Total Time for Training, which is computed as the sum of Data Collecting Time and NN Training Time. We report results in Table 15. Table 15 shows that GraphPlanne enner achieves the lowest overall time cost among all methods in both training and inference. This efficiency primarily comes from our multi-threades rollout design, which processes multiple queries in parallel and generates routing interactions simultancously as illustrated in Section C. As a result, GraphPiante time, which is substantially lower than RL-based baselines such as R2-Reasoner (360 minutes) and Router-RI (300 minutes), as well as supervised routers that incur large up-front data collection cost of 395 minutes. During inference, GraphP Pooohllaneerr Lnner also achieves the best latency at 1.2 seconds per query, outperforming both single-round and multi-round routers. Finally, because GraphP lanner collects and uses interaction data on-the-fly in an RL fashion, it avoids the expensive full-sweep data generation required by supervised methods, leading to much higher data efficiency as introduced in Section 4.1. Overall, the results demonstrate that GraphP 1 anner is both computationally efficient and data-efficient across the entire training and inference pipeline.
requires only 120 minutes of total training
J ILLUSTRATIVE EXAMPLES OF GRAPHPLANC
This section presents illustrative examples of how GraphP Mamllaaner generates adaptive work in Phase-2 across different task types. As shown in Figure 6, GraphP1 anner constructs distinet workflow structures depending on the complexity of the input query. Table 16 details a multi stage math reasoning example in which the planner decomposes the query into several sub-queries, assigns them to appropriate executors, and then uses summarizer to integrate intermediate results. Table 17 demonstrates more complex code-generation case involving nested planning and hierarchical decomposition. In contrast, Table 18 illustrates a direct executor-only path for simple natural- language questions. Together, these examples highlight GraphP 1 anner's r's ability to flexibly choose between single-step execution, multi-step reasoning, and hierarchical planning based on task difficulty and structure.
K PROMPT USAGE
L THE USE OF LARGE LANGUAGE MODELS (LLMS)
During the preparation of this manuscript, we used an LLM to assist with improving the readability of the text. The tool was employed exclusively for grammar correction. sentence restructuring, and minor stylistic refinements. All substantive intellectual contributions, including research design, analysis, and conclusions, were produced independently by the authors.
25

---

Published as a conference paper at ICLR 2026
Math Task
Natural Task
Planner
Executors
Summarizer
Final
Final
Query
Executor response
Query Executor response
Decompose
Code Task
Executors
Query
Executors
Final Executor response
Decompose
Summarizer
Summarizer
Planner
Executors
5
Figure 6: Illustrative examples of GraphPlanner's workflow generations in phase-2. The figure illustrates how GraphP lanner adaptively constructs different workflow paths for different task types. For math tasks, the planner first decomposes the query into several sub-queries. Each sub-query is processed by executor, and the intermediate results are then merged by summarizer before final executor produces the answer. For code tasks, GraphP anner performs nested planning: the initial decomposition triggers second planning step for one of the sub-queries, producing deeper sub-components that are executed and then summarized into multiple layers of reasoning before producing the final output. For simple natural-languaa questions, GraphP Sauphllanner lanner identifies that no decomposition is needed and directly selects an executor-only path to produce the final response in single step. Overall, the diagram shows that GraphP Panner flexibly adapts workflow depth and structure based on task complexity, ranging from single-step execution to multi-stage and hierarchical planning.
26

---

Published as a conference paper at ICLR 2026
Table 16: Phase-2 GraphPlanan Laannrr workflow example for math QA task. This example illustrates the full Phase-2 GraphPlaas lanner workflow, where the planner decomposes the original question into multiple sub-queries and assigns them different LLMs. Exccutors solve each sub- query individually, and intermediate results are summarized by a dedicated summarizer to form coherent reasoning context. Finally, another executor uses this structured context to compute the final answer. The workflow demonstrates the multi-stage architecture of GraphPla panpe,, including sub-query decomposition, parallel role assignment, structured summarization, and cross-model collaboration.
Step
Query / Sub-query
LLM
Role
Response (Summary)
Acc
Cost
Original question: "A notebook costs $3 and
LLaMA-3.1-8B
Planner
Produces three sub- queries: (Q1) notebook
pen costs $2. What is the total cost of 4 note- books and pens?"
subtotal; (Q2) pen
subtotal; (Q3) prepare
combined calculation.
Q1: "Compute the subtotal for 4 notebooks at $3 cach." "
Qwen2.5-7B
Executor
Computes 4 x 3 = 12.
95
Q2:
"Compute
Gemma-2-9B
Executor
Computes 6.
subtotal for pens at $2 cach."
"Using the subto- tals ($12 and $6), pre- pare the combined infor- mation for final reason- ing."
Q3:
LLaMA-3.1-8B
Executor
Returns structured sum- mary: "Notebook subto- tal 12; Pen subtotal 6."
140
"Summarize all interme- diate results into a con- cise final reasoning con- text."
LLaMA-3-70B-CHE
Summarizer
Generates final reason- ing context: "Total = 12
480
6."
Final answer step: "Given the original question and the sum- marized reasoning (12 6), compute the final result."
Qwen2.5-14B
Executor
Outputs: "The total cost is $18."
260
27

---

Published as a conference paper at ICLR 2026
Table Phase-2 GraphPlanne Workflow Example for Code Task. This example demon- strates the nested planning structure of the Phase-2 GraphP Panner workflow for a code QA task. The planner first decomposes the original programming problem into two high-level sub-queries. After the executors answer these, GraphPlanne lnnnr triggers second round of planning, where the planner further breaks down one sub-query into two finer-grained sub-questions about filtering logic and output-string construction. Executors then handle each low-level sub-query independently. The summarizer consolidates both layers of intermediate reasoning into a unified implementation plan, which is combined again with earlier results form the final structured context. Finally, executor produces the complete Python function. This workflow illustrates how GraphP anner supports hierarchical decomposition, multi-stage reasoning, and coordinated collaboration across multiple LLMs.
Step
Query / Sub-query
LLM
Role
Response (Summary)
Acc
Cost
Original "Implement
task:
LLaMA-3.I-8B
Planner
Produces sub-
120
queries: (Q1) describe
remove_digite (s: str) -> str."
digit-removal rule; (Q2)
outline implementation steps.
"Describe the rule for removing digits from a string."
Q1:
Qwen2.5-7B
Executor
Returns rule: iterate over characters and keep only non-digit characters.
Q2: "Outline the im- plementation steps for
LLaMA-3.1
Planner
Decomposes into: (Q2a) describe filtering
remove_di g ta.."
logie; (Q2h) describe final string construction.
Q2a: "Describe filtering logic for keeping non- digit characters."
CodeGemma-77
Executor
Explains: check each character with not ch.isd gi tt ().
200
"Describe how construct the final put string."
Q2b:
Qwen2.5-7B
Executor
Describes:
collect fil- tered characters and join them into new string.
95
"Summarize Q2a and -LaMA-3-70B- -LaC CharQA Q2h into unified im- plementation plan."
Summarizer
Produces concise plan: filter non-digit charac- ters join into result.
480
"Combine Ql's rule LLaMA-3-70F 7A with the summarized plan from Step 6."
Summarizer
Merged reasoning: re- moval rule + full imple- mentation steps.
480
Final answer: "Using the initial query and merged summary, pro- duce the final Python function."
Qwen2.5-14B
Executor
Returns final function: "remove_digits".
260
Table 18: Phase-2 GraphPlannee Workflow Example for Natural QA Task. This example illustrates the simplest execution path within the Phase-2 GraphP lanner workflow. For straightfor- ward natural-language questions that require decomposition or multi-stage reasoning, the planner selects direct executor-oni route. The chosen LLM receives the original query and immediately produces the final answer without invoking additional planners or summarizers. This demonstrates GraphP anner 's ability to adaptively determine when complex workflow construction is unneces- sary and efficiently route easy queries through single-step executor path.
Step
Query
LLM
Role
Response (Summary)
Ace
Cost
"Who painted the Mona Lisa?"
Qwen2.5-14B
Executor
"The Mona Lisa was painted by Leonardo da Vinci."
85
28

---

Published as a conference paper at ICLR 2026
Table 19: Planner prompt template for sub-query decomposition.
You are a query decomposition assistant. Your task to decompose the user's query into atomic and independent sub sub-queries.
Inputs: Original query: [QUERY)- Parent queries: {PARENT QUERIES] Previous sibling responses: (SIBLINGGRESPPONES,
Instructions: Determine the optimal number of sub-queries (1-3). Ensure each
sub-query self-contained and non-overlapping. Avoid redundancy by considering {SIBLING RESPONSES). Adjust the number of sub-queries depending on complex-
ity.
Output format: List 1-3 sub-queries. One sub-query line. No numbering extra commentary.
Table 20: Executor prompt template for query answering.
You are helpful assistant. Answer the given Suub-Juuery with support from full context. Inputs: Current sub-query: {QUERY)- Original query: {ROOT QUERY): Parent queries: [PARENT.QUERIES) QUERIES) Previous sibling responses: (SIBLING RESPONSES)- If final execution: summary of sub-query responses (SUMMARY)
Instructions: Interpret the sub-query with reference to full context. Align the answer with prior responses to ensure consistency. If this is the final step, synthesize everything into complete final answer.
Output format: Direct, complete answer in the format required by the task. No extra commentary.
Table 21: Summarizer prompt template for parent query synthesis.
You are professional summarizer. Your task is to synthesize multiple child answers into coherent response to the parent query.
Inputs: Parent query: (PARENT QUERY) Child answers: {CHILD ANSWERS]
Instructions: Combine all child answers into a complete, coherent response. Preserve all important details. Resolve overlap conflicts among child answers. Ensure the response directly addresses (PARENT.QUERY],
Output format: A single, well-structured paragraph answering the parent query.
Table 22: Thinker prompt template for sub-query reasoning.
You are Thinker Agent in multi- agent workflow system. Your task is to generate detailed reasoning responses for sub-queries. Inputs: Sub-query: (SUB QUERY) Original query: SRCOT_QUERY Parent queries: (PARENT QUERIES) Previous sibling responses: BEELINGRRESPONES
Instructions: Understand the sub-query in context of the orig- inal query. Think step-by-step through the problem with detailed reasoning. Consider information from previous sibling responses to maintain consistency. Show your reason- ing process clearly before reaching conclusion. Output format: Reasoning Steps: List numbered reasoning steps. Draft Answer: Your reasoned response to the sub-query. Be thorough as your response will be verified by Verifier Agent.
29

---

Published as a conference paper at ICLR 2026
Table 23: Verifier prompt template for response verification.
You are a Verifier Agent in a multi-agent workflow system. Your task is to verify draft responses and produce refined, verified outputs. Inputs: Sub-query: {SUB QUERY) Draft response from Thinker: (DRAFT_REE) RESPONSE) Previous sibling verified responses: (VERIFIED SIBLING R Instructions: Verify accuracy. completeness, consistency, and logical soundness. If draft response is correct: approve and format cleanly. issues found: correct errors and improve the response. Ensure consistency with other verified sibling responses. Output format: Verification Issues Found: List specific problems identified (if any). Verified Response: Final verified answer to the sub-query.
Original query:
Result: IAPPROVED/REVISE)
Table 24: Description of Planner agent.
The Planner acts as a dccomposition agent. Its primary role is to analyze a complex user query and break it down into set of clear, atomic sub-questions that can be addressed independently. This ensures that each sub-query targets a specific aspect of the original request, reducing ambiguity and overlap. The Planner helps streamline multi-step reasoning or multi-part queries by structuring them into manageable components for downstream processing.
Table 25: Description of Executor agent.
The Executor serves as the answering agent. responsible for generating responses to the user's queries, either directly or by incorporating additional background context when necessary. When context is provided, grounded response. It can operate in both raw query execution mode or in final, context- aware answering mode, depending on the task's 's stage and goal.
Executor uses to produce a more informed and
Table 26: Description of Summarizer agent.
The Summarizer functions the condensation agent. Its role is distill long complex content into a concise, coherent, and fluent summary. Instead listing key points, the Summarizer rewrites the original input into a well-structured passage that captures the essential meaning, making the information easier to digest and understand at a glance.
Table 27: Description of Thinker agent.
The Thinker acts as reasoning agent. Its primary role to process sub-queries through systematic step-by-stey step analysis, generating detailed reasoning chains that lead to well-founded conclusions. The Thinker excels at breaking down complex problems into logical steps, exploring multiple approaches, and providing comprehensive draft responses with explicit reasoning processes. serves as the core analytical component that transforms -uerque into thoroughly reasoned draft answers for subsequent verification.
Table 28: Description of Verifier agent.
The Verifier serves as a quality assurance agent. is responsible for critically evaluating draft responses from Thinker agents, checking for accuracy, completeness, logical consistency, and alignment with the original query context. The Verifier can identify factual errors, reasoning flaws, or gaps in responses, and either approve correct drafts or provide refined corrections. acts as the final quality gate, ensuring that only verified, high-confidence responses proceed to the synthesis stage.
30

---

Published as a conference paper at ICLR 2026
Table 29: Description of Qwen2.5 (7b).
Qwen2.5 (7b) represents upgraded version of the Qwen model series, featuring significantly enhanced multilingual capabilities across diverse language tasks. This improved model offers excellent value $0.20 per million input tokens and $0.20 per million output tokens.
Table 30: Description of CodeGemma (7b).
CodeGemma (7b) is specialized variant of the Gemma model family that focuses exclusively on code generation and completion tasks. This programming- oriented model provides robust coding assistance capabilities at an affordable rate of $0.20 per million input tokens and $0.20 per million output tokens.
Table 31: Description of Mistral (7b).
Mistral (7b) is highly efficient open-weight model with billion parameters, optimized for fast inference and strong performance on general text generation tasks. It offers competitive pricing $0.20 per million input tokens and $0.20 per million output tokens.
Table 32: Description of LLaMA-3.1 (8b).
LLaMA-3.1 (8b) is Meta's 8-billion parameter model from the advanced Llama-3 series, specifically designed for conversational Al and complex reasoning tasks. This versatile model combines strong performance with reasonable costs $0.20 per million input tokens and S0.20 per million output tokens.
Table 33: Description of LLaMA-3 ChatQA (8b).
LLaMA-3 ChatQA (8b) is an NVIDIA fine-tuned 8-billion parameter model specifically optimized for question-answeriin and reasoning applications. This specialized model delivers enhanced performance in conversational Al scenarios at $0.20 per million input and output tokens.
Table 34: Description of Gemma-2 (9b).
Gemma-2 (9b) is 9-billion parameter instruction-tunet model from Google, designed for general text processing and conversational applications. This compact yet capable model offers exceptional value with ultra-low pricing of $0.10 per million input tokens and $0.10 per million output tokens.
Table 35: Description of Mistral-Nemo (12b).
Mistral-Nemo (12b) is 12-billion parameter model that combines innovative Mistral architec- ture with NeMo technology for enhanced performance. This hybrid approach delivers superior capabilities across various tasks, priced at $0.30 per million input tokens and $0.30 per million output tokens.
Table 36: Description of LLaMA-3.3 Nemotron Super (49b).
LLaMA-3.3 Nemotron Super (49b) is powerful 49-billion parameter Nemotron model engineered for high-accuracy performance across demanding applications. This advanced model delivers exceptional results for complex tasks, available at $0.90 per million input and output tokens.
31

---

Published as a conference paper at ICLR 2026
Table 37: Description of LLaMA-331 Nemotron (51b).
LLaMA-3.1 Nemotron (51b) is NVIDIA's 51-billion parameter alignment model that focuses on producing safe, helpful, and accurate responses. This enterprise-gen model emphasizes responsible AI deployment and priced $0.90 per million input and output tokens.
Table 38: Description of Mixtral (8x7b).
Mixtral (8x7b) is 56-billion parameter Mixture of Experts (MoE) model composed of eight 7-billion parameter expert models, specifically optimized for creative text generation. This innovative architecture provides high-quality outputs while maintaining efficiency, available $0.60 per million input and output tokens.
Table 39: Description of LLaMA-3 ChatQA (70b).
LLaMA-3 ChatQA (70b) a 70-billion parameter model specifically optimized for conver- sational AI and chat applications. This large-scale model provides sophisticated dialogue capabilities and nuanced understanding, available at $0.90 per million input and output tokens.
Table 40: Description of Mixtral (8x22b).
Mixtral (8x22b) is advanced 176-billion parameter Mixture of Experts model comprising eight 22-billion parameter expert components. This large-scale MoE architecture delivers exceptional performance across diverse tasks while maintaining computational efficiency, priced at $1.20 million input and output tokens.
LLM Role
Function
Planner
Decomposes a complex query into atomic sub-queries and organizes the workflow.
Executor
Generates answers for sub-queries with or without contextual grounding.
Summarizer
Aggregates multiple intermediate outputs into coherent final response.
Thinker
Performs systematic reasoning to produce detailed draft analyses before execution.
Verifier
Evaluates the correctness and quality of generated content before finalization.
Table 41: LLM roles used in GraphPlanner, including additional agentic roles introduced in the appendix.
32


Reviews:
[{"review_id": "PcR3ch6MiT", "reviewer": "Reviewer_E6qX", "summary": "This paper introduces GraphPlanner, a heterogeneous graph-based agentic router that extends LLM routing beyond static or multi-round settings into dynamic multi-agent coordination. The paper formulates workflow generation as a Markov decision process, where at each step both the LLM backbone and the agent role (Planner, Executor, Summarizer) are selected. A novel graph neural network, GARNet, integrates both the current workflow graph and historical interactions, enabling inductive and transductive inference. The proposed method is trained using proximal policy optimization. Experiments across 14 tasks and 6 domains show improved accuracy and reduced GPU cost over prior routers, with strong zero-shot generalization.", "questions": "- **Q1.** How would GraphPlanner perform when additional agent types (e.g., retriever, verifier) are introduced? Is the policy flexible enough to handle new roles dynamically?\n\n- **Q2.** Why are other graph encoders (e.g., GAT, GraphTransformer) not compared or ablated against GARNet?\n\n- **Q3.** What motivated the use of Longformer embeddings? Was long-context modeling empirically necessary?\n\n- **Q4.** Can the authors clarify what constitutes “existing LLM workflows” in Phase 1 evaluation (Table 1)? Were these synthetic or from real systems?", "limitations": "", "rating": 4, "confidence": 4, "soundness": 3, "presentation": 2, "contribution": 2, "strengths": "- **S1.** Novel formulation of LLM routing as a graph-based agentic workflow generation problem using an MDP framework. The reinforcement learning-based optimization adds a dynamic decision-making aspect missing in static routers.\n\n- **S2.** Integration of historical context through GARNet for inductive and transductive inference provides a principled way to leverage past interactions.\n\n- **S3.** Comprehensive evaluation across several tasks and domains. Demonstrated efficiency with substantial reductions in GPU usage and token consumption. Zero-shot generalization to unseen LLMs and tasks shows strong adaptability and robustness.", "weaknesses": "- **W1.** The system fixes roles to Planner, Executor, Summarizer, which may constrain scalability to more complex or hierarchical workflows.\n\n- **W2.** The experiments fix depth = 1-2 and width = 2-3, which seems too limited for realistic multi-step tasks. \n\n- **W3.** The paper omits recent agent workflow generation systems (e.g., ADAS, AFlow, AgentSquare), which are directly relevant to the *workflow generation* claim in Table 3.\n\n\n- **W4.** Insufficient discussion of real-world deployment or integration with tool-based or API-based LLM ecosystems, despite the *agentic* framing.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "oEIbLJseY0", "reviewer": "Reviewer_3pJs", "summary": "In this paper, the authors proposed the GraphPlanner, which is a graph-based LLM router for agentic LLM flow prediction. Given a constructed workflow and history graph, the GraphPlanner predicts the best agent role and the LLM for the next step. by training the GNN model with PPO, it can generalize to unseen tasks and models.", "questions": "See above?", "limitations": "", "rating": 4, "confidence": 3, "soundness": 3, "presentation": 2, "contribution": 2, "strengths": "- The proposed methods show significant improvement over baseline methods under different scenarios.\n- The authors provide a comprehensive ablation study to prove the effectiveness of the proposed method.", "weaknesses": "- The writing can be improved. In particular, I am pretty confused about the graph construction part.  Why are all nodes connected to the role hub node? Is there any particular consideration behind this design? For multi-round routing, will there be multiple role hub nodes? How are different rounds connected in the graph? Will the role hub node encode the role information of both the history graph and the workflow graph? I believe a more detailed illustration or figure is needed to allow the reader to better understand it.\n- For the agent role, the Graphplanner defined three different roles.  I am wondering what the rationale behind it is, and I am curious about whether the proposed methods can generalize to unseen roles after training. \n- What's the time cost for GraphPlanner compared to other baselines under different settings? What is the training time for GraphPlanner and other baselines?\n- The major contribution and the source of performance improvement come from the history graph. I am wondering, is it necessary to construct historical information into a graph? What if I simply describe all historical information to a (small )LLM and use the same training pipeline to optimize it?", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "o2t6C4H7zd", "reviewer": "Reviewer_SiqR", "summary": "This paper introduces a novel LLM routing paradigm, an agentic router setting. Unlike traditional routers, the proposed GraphPlanner not only selects the backbone LLM but also assigns specific agentic roles, e.g., planner, executor, or summarizer, to solve the initial query. The router is parameterized by GARNet, a graph-based model that captures the relationships between queries, agentic roles, and responses. GARNet is optimized using PPO with a joint loss that balances task-specific performance and computational costs, enabling adaptive router learning. Extensive experiments across 14 diverse tasks, spanning in-domain and out-of-domain settings, as well as inductive and transductive scenarios, demonstrate GraphPlanner's SOTA performance, exceptional balance of cost and performance, and strong generalization capabilities.", "questions": "Please refer to Weaknesses part", "limitations": "", "rating": 8, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. The proposed agentic router setting is well-motivated and clearly articulated. While traditional single-round routers are limited to solving isolated queries and multi-round routers can only model sequential workflows, GraphPlanner addresses more complex graph-structured workflows that are under-explored in prior work.\n\n2. GraphPlanner is designed with sound principles, featuring a lightweight implementation and effective contextual history preservation. This ensures that the agentic router is simple to implement and extend. Additionally, the joint optimization of the router, combining task-specific loss and cost constraints, allows the model to learn policies tailored to solved task while maintaining efficiency.\n\n3. The experimental results are extensive, covering a wide range of downstream tasks in both in-domain and out-of-domain scenarios. The authors also include detailed cost-performance trade-offs and further analysis in inductive and transductive settings. These results highlight GraphPlanner's SOTA performance compared to single-round and multi-round routers, its robustness in inductive and out-of-domain tasks, and its favorable balance between performance and computational costs.\n\n4. The paper is well-written, with vivid figures and tables that significantly enhance comprehension.", "weaknesses": "1. The description of Phase 1 optimization is somewhat unclear. For instance, in the case of Depth = 1 and Width = 3, does this imply a fixed agentic workflow where the first step always involves an initial planner role, followed by two roles (e.g., summarizer or executor)? Further clarification of this process would be helpful.\n\n2. The paper lacks illustrative examples showing how the router assigns roles to specific models to successfully solve queries. Including such examples would better demonstrate how GraphPlanner operates in practice.\n\n3. The experimented datasets appear relatively simple, as single-round routers already achieve good performance in some scenarios. It would be valuable to test GraphPlanner on more challenging benchmarks, such as agent-related benchmarks, which involve complex workflows and are better suited for role decomposition.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)