acceptodds
Under review as a conference paper at ICLR 2027

Learning Reusable Agent Subroutines from Experience

Abstract

Existing methods induce various forms of knowledge from agent traces, from sample workflows to programmatic skills. We propose ARISE (Agent Routine Induction from Successful Experience), which identifies recurring procedures in agent traces and synthesizes them into a reusable library of agent subroutines. Across five tasks in narrative deduction, rule application, and constraint planning, it is shown to be a more effective learning strategy than prompting methods and prose and code artifact induction methods. ARISE outperforms chain-of-thought in all ten model–task settings of the main evaluation. Compared to state-of-the-art methods in agent experience induction, our method scores 6.1 percentage points over the strongest evaluated baselines, and 11.5 percentage points over code-skill induction. In our controlled experiment, ARISE also improves average accuracy by up to 15.6 percentage points compared to formatting the induced knowledge as skills and by up to 19.1 points over rewriting it as code tools.

Primary area:
foundation or frontier models, including LLMs
Keywords:
large language models, LLM agents, reasoning, learning from experience, skill induction, library learning, tool use

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_Ab5qOpenReview ↗
Rating
2(+1)
Confidence
4
Informativeness
1
Presentation
3
Soundness
2
Read review
Paper summary

The paper observes that models are not as good at using skills as they are at using tools.

They offload skill workflow steps into neuro-symbolic functions that the model can call.

These functions are separate model calls to another LLM, which the original agent has to parametrise.

They find that this results in improvements over long horizon tasks.

Critical strengths

The paper's observations on model utilizing functions/tool calling better than skills is useful. The idea of offloading intermediate steps onto a separate LLM is also good, but it is well studied.

Critical weaknesses
  1. No Comparison Against multi agent system The solution revolves around calling another llm with some parametrised focussed information, this is also how coding agents etc do handoffs, but the handoff entity is also another agent in its own right, which is more powerful. Should be baselined against. Otherwise this technique is outdated. The only difference I see is that the function signatures are defined offline while in agent handoff the model does it on the fly.

  2. The paper seems unfinished in many regards. I have expanded more on the following points in questions to the authors:

  • Why not do the ARISE process in a loop? Get trajectories --> define subroutines --> Get trajectories with subroutines --> get higher abstraction subroutines --> till convergence. Will this converge?
  • The mechanism of making labels before clustering seems arbitrary and is not justified. What is the stability of such operations. Please give examples and statistics. Are the labels obvious?
  1. The parametrization of text to function (llm call) is not discussed adequately. What is the size of the focus text provided in different domains? How is it capped? Won't it increase latency due to huge number of output tokens the model needs to produce for the parametrization.
Questions for authors

Lines 17–18: Chain-of-thought is the weakest baseline to headline in the abstract. Beyond AWM/ACE/ASI, prompt optimization methods (Trace2Skill, which is cited but not compared, GEPA etc.) are also useful additions, would love to know authors thoughts on this.

Lines 83–89: These sound the same to me as ARISE. The distinction (execution in a separate LLM call) is actually what agent hand-off and multi-agent orchestration systems do, which are not mentioned here.

Lines 91–95: Interesting. What I understand is that when the main agent calls a tool/subroutine, a separate single LLM call carries it out (not an agent). If that is so, a good comparison or implementation harness would be a multi-agent one with hand-offs, e.g., Claude Code. The novelty over Decomposed Prompting and meta-prompting (lines 134–137) also needs to be clearer.

Lines 187–188: Why only successful trajectories? Negative trajectories also contain useful information about what not to do, which can help guide compilation. This ablation would be good.

Line 213: What does this step mean? Filter already keeps the successful rollouts. Does Extract just split them into per-step items? Please specify.

Lines 214–215: What is the stability of such an operation? Does it always converge to the same library of labels?

Lines 221–224: It might be useful to do this in a loop, then? Sample till you get some successful trajectories, then create subroutines. Then take the trajectories arising from the subroutines and go again, till you converge. Dependence on successful trajectories needs to be studied more. Does performance improve on different task types? E.g., succeed on type A, fail on B, generate subroutines from A trajectories: do they help B? If they only help A, is this useful?

Line 230: Please expand more on this, since the executor is also an LLM. Figure 2 says the agent supplies only focus and the instance text is bound automatically. Does the main agent have to parametrize a lot of text for this? What are samples of size of text it has to give? If it is very large this is wasted output tokens, if it is low the model might be better off doing this in context without a hand-off.

Lines 230–232: If it is a single LLM call, then everything is in-context, which is quite weak. Please compare this with agent hand-off.

8 comments
AuthorsOpenReview ↗

Response to Reviewer Ab5q (1/4)

We thank the reviewer for the detailed questions. We first clarify a few points in the summary.

  • ARISE is a method for learning from experience. It induces the inventory of subroutines and their specifications from the agent's own successful trajectories, similarly to AWM, ASI, and ACE. Unlike prior experience-learning methods, the learned constructs for ARISE are natural-language specifications executed by an LLM: this sort of construct has not been widely used as the form of learned knowledge in the past, but it is not a neuro-symbolic function.
  • The finding is not as broad as a claim that “models use tools better than skills.” More precisely, the finding is that when learning from agentic experience, ARISE’s LLM-executed subroutines outperform prior formalisms: with the induced text held fixed, LLM-executed subroutines outperform in-context skills (10 of 10 settings) and Python tools (9 of 10).
  • In calling LLM models via subroutines, the agent supplies only a short focus, an argument naming what the call should examine (e.g., focus="Unity", a suspect in a murder mystery; median 2–9 tokens). The instance itself (the full narrative, rule text, or problem statement) is passed to the subroutine automatically, so the agent does not need to copy it into the call (W4).
  • The gains are measured on narrative deduction, rule application, and constraint planning, against methods that learn from the same trajectories.

Relating to multi-agent hand-offs: Multi-agent systems are used for a variety of reasons: as a way of orchestrating complex agentic tasks, as a means for test-time scaling by parallelization, as a means for context management, as a means of coordinating work between stronger and weaker agents, and doubtless other reasons. While it is true that the LLM-executed subroutines are executed by something much like a multi-agent hand-off, our paper’s contribution is on learning to perform a task from experience, which is not to our knowledge a common focus for multi-agent systems. Defining the function signatures offline is precisely the mechanism ARISE uses to encode what it has learned - so that difference is critical.

Simply enabling on-the-fly ARISE-like subroutine hand-offs in a multi-agent system would not, as far as we can see, enable learning from trajectories, because nothing learned on one task instance would carry over to the next.

Since the paper asks what an agent should learn from experience, the most informative comparisons are other methods that learn from the same experience (AWM, ACE, ASI, and now GEPA and Trace2Skill) and controls that keep the learned text fixed and change only how it is used.

We understand the concern that delegation alone might lead to gains, so we added hand-off baselines with a tool-using sub-agent and ran ARISE with such sub-agents as executors. In short, hand-off does not improve on the base ReAct agent on average (65.0 and 60.4 vs 69.0), while the single-call ARISE library outperforms every hand-off variant on all five tasks: the gain comes from what is learned, not from delegation. Details are in W1 (parts 1/4 and 2/4; Appendix F, Table 8), W4 in part 4/4 (in-context controls), and Q1 in part 2/4 (GEPA, Trace2Skill). We hope these results lead the reviewer to reconsider the assessment.

Our point-by-point responses follow.

W1 (also Q2, Q3, Q9): Relation to hand-off and multi-agent systems (lines 83–95, 230–232). While this paper is not about agent hand-off and is intended as an extension of skill induction and tool induction, we will clarify this with a comparison between ARISE and agent hand-off: delegating a focused request to a separate model call is shared with hand-off and multi-agent orchestration, and we will discuss this relationship explicitly. Again, ARISE's main contribution is learning agent subroutines: the inventory of subroutines and their specifications, induced from the agent's own successful trajectories.

As the reviewer notes, in a hand-off system the orchestrator defines each sub-task on the fly. The paper already contains a single-call form of this condition: in generic tools (Appendix F, Table 8), the agent has the same number of tools and the same separate-call execution, but the tools carry no learned names or specifications, so the agent defines every delegated request at run time through focus. It averages 64.2%, below the ReAct agent (68.2%); ARISE averages 78.4%. With the mechanism held fixed, the learned definitions account for 14.2 points.

AuthorsOpenReview ↗

Response to Reviewer Ab5q (2/4)

W1 (continued): Hand-off experiments. To further compare our method with agent hand-off for this review, we conducted additional experiments and added hand-off conditions with a tool-using delegate (see table below): the base ReAct agent gets a delegate(instruction) tool, and each call starts a sub-agent (same model, base tools, the instance input, a fresh context, up to 20 requests) that returns a report, as in coding-agent sub-agents. In a second variant, the agent is also instructed to decompose the problem and delegate. We also ran ARISE with agentic executors: each induced subroutine is executed by such a sub-agent following its specification, instead of by one LLM call.

Gemini 2.5 FlashmurderobjectteamNBAmeetingAvg (4 tasks w/o NBA)
ReAct78.050.976.065.271.069.0
Hand-off: ReAct + delegate (tool-using sub-agent)74.051.969.065.265.065.0
Hand-off, agent instructed to decompose and delegate77.058.563.069.743.060.4
ARISE library, agentic executor85.078.368.074.275.076.6
ARISE library, single-call executor (paper)86.075.576.071.280.079.4

With the ARISE library, both executors are above every hand-off variant, and the tool-using executor does not improve on the single call (76.6 vs 79.4) while costing about twice as much on murder (USD 9.43 vs 4.85 for the test split). In these runs, the gain comes from the learned library rather than from the capability of the delegate.

Q1 (lines 17–18): We appreciate this feedback and will revise the abstract to lead with the comparison to experience-adapted methods rather than CoT. That said, CoT is not a very weak baseline; it is actually the third-best-performing baseline on Gemini. We thank the reviewer for this suggestion and now add two other baselines.

GEPA and Trace2Skill:

Accuracy (%), mean of three test runs:

murderobjectteamNBAmeetingAvg
GEPA84.776.170.764.681.075.4
Trace2Skill77.775.553.367.245.363.8
ARISE87.374.274.371.281.377.7
  • GEPA averages 75.4 over three test runs, against 77.7 for ARISE, at about three times ARISE's total cost (USD 10.36 vs 3.63 per task).

ARISE is higher than Trace2Skill on four of five tasks and by 13.9 points on average, at a lower total cost per task (USD 3.63 vs 4.22). The closest controlled analogue in the paper is Ours as skill: the identical induced text read in context is lower than ARISE in all ten model–task settings (51.8 vs 67.4 on DeepSeek-V3, 66.1 vs 77.7 on Gemini 2.5 Flash).

Q3 (lines 134–137): Novelty over Decomposed Prompting and meta-prompting. In Decomposed Prompting, a developer writes the decomposition and each handler. In meta-prompting, the conductor invents expert instances for each query, and nothing carries over between problems. Coding-agent sub-agents are either written by the user (named, with a natural-language prompt) or described on the fly by the orchestrator. ARISE produces such named, specified procedures automatically from experience; the comparisons in W1 measure what that learning adds.

AuthorsOpenReview ↗

Response to Reviewer Ab5q (3/4)

W2 (also Q7): Running ARISE in a loop (lines 221–224). We ran two more rounds on Gemini 2.5 Flash: the round-r agent solves the training split, the pipeline is applied to its successful trajectories (subroutine calls become action items), and the new library is tested.

TaskTest accuracy, rounds 1 / 2 / 3Training successes, rounds 1 / 2 / 3
murder86.0 / 87.0 / 85.054 / 62 / 58 of 75
object75.5 / 67.9 / 73.633 / 56 / 62
team76.0 / 71.0 / 72.053 / 60 / 59
NBA71.2 / 72.7 / 74.247 / 52 / 51
meeting80.0 / 86.0 / 89.053 / 61 / 59 of 70
Avg77.7 / 76.9 / 78.8

Iteration does not converge to a fixed library, and it does not raise average accuracy. Our reading is that a model solves a task family with a stable set of recurring procedures: correct trajectories reuse them, and this recurrence is what ARISE captures. In later rounds the agent solves more training instances (e.g., 33 → 62 on object), but the additional successes reuse the same procedures, and each round recovers procedures for the same task functions with different wording and boundaries. Specification similarity between consecutive rounds (TF-IDF cosine 0.27–0.49) is close to that between two independent inductions on the same task (0.29–0.30) and well above that between unrelated tasks (0.07–0.11). Re-capturing the procedures therefore adds little beyond one round. Continual improvement would need a different mechanism that refines what has been learned, for example optimizing the specifications with textual feedback as in TextGrad, or refining details over several adaptation epochs as ACE does, and likely a careful combination of such techniques with induced subroutines. We leave this to future work. On the dependence on successful trajectories, we also re-induced libraries from 5, 10, and 20 successful trajectories (see our response to Reviewer hvgA, Q2): on murder, 10 trajectories already match the full set, while on object and team the smaller libraries stay about 7–10 points below.

W3 (also Q6): Stability of labelling and merging (lines 214–215). Labelling items before grouping them is a standard way to induce categories from free text. In qualitative analysis, data segments are first coded and the codes are then collated into themes (Braun & Clarke, 2006); LLM topic models such as TopicGPT label each document with a topic, then merge near-duplicate topics and drop infrequent ones (Pham et al., 2024), much as our merge step and minimum support do; and AWM prompts the model to extract common sub-routines across experiences (Wang et al., 2024). Labelling first also helps the grouping itself: IDAS reports that clustering utterances by short LLM-generated labels, which keep the core content and drop non-essential detail, outperforms prior intent-discovery methods (De Raedt et al., 2023). Our step items are full of instance-specific content (suspect names, times, rule numbers), so naming the reasoning move is what makes recurrence across instances countable. In ARISE, each step item receives a short, free-form name for the reasoning move it performs (e.g., "verify alibi consistency"). Batches of 30 items are labelled by independent calls, and one merge call then maps synonymous labels onto canonical categories using their counts. On Gemini 2.5 Flash, for example, 114 murder items receive 49 distinct raw labels, which merge into 7 categories; the five most frequent become subroutines (object 13 → 5, team 22 → 6, NBA 29 → 5). Are the labels obvious? They are short verb phrases naming the move, and the merge groups near-synonyms. For example, for murder, Investigate Means And Weapon collects "Identify murder weapon" (5 items), "Identify weapon type" (4), "Check suspect weapon access" (4), and "Link suspect to weapon" (3), among 9 raw labels. They are fairly obvious. Since free-form names differ from run to run, the relevant question is whether the resulting libraries cover the same task functions. Appendix B (Table 6) addresses this: two different models, each inducing from its own trajectories, recover the same functions. For example, for object placement, both libraries track which object movements a character could observe and infer the character's belief from that (DeepSeek-V3: analyze_character_knowledge, infer_character_belief; Gemini 2.5 Flash: get_character_object_belief, formulate_character_belief).

Reviewer_hvgAOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper presents the method called ARISE. ARISE is a method that identifies recurrent operations performed by an LLM during its reasoning from successful trajectories with which a library is built. The model is given the names and descriptions of these operations(subroutines) which the model can call. A call to a subroutine is done through a separate LLM call from the rest of the reasoning. The authors showcase the performance of ARISE across different benchmarks and two model families.

Critical strengths
  • ARISE is a simple and well described method to learn reusable subroutines which is also reasonably cheap compared to other agentic methods
  • It has quite impressive performance across different benchmarks, and model families
Critical weaknesses
  • The main results come from single runs and you do not report any statistical significance
  • Some of the baseline agentic methods that are used in the paper are outside of the environment they were designed for. For instance, AWM and ASI were designed for web environments and evaluating them in this setting might be unfair
  • One could have done also a comparison against prompt optimization methods such as GEPA (GEPA: Reflective Prompt Evolution Can Outperform Reinforcement Learning)
  • ARISE requires to have a training set to establish the subroutines that are necessary to include. That means that given a new task these subroutines could potentially not benefit the new task
Questions for authors
  • Once some categories have been discovered in the step 'categorize & merge', does the LLM know that these categories can be reused? or does it automatically sometimes comes up with the same category? Or maybe said differently, are all the filtered trajectories passed to this step in a single batch?
  • How many samples are necessary for a proper induction pipeline (set size)? And how diverse should they be to be able to capture the necessary subroutines?
  • What explains the quite low performance of ARISE in RuleArena and NatPlan benchmarks for Gemini2.5-Flash?
  • Does a single prompt which includes the specification discovered with ARISE perform worse than using the subroutines? (is that the skill row in Table 2?)
  • Given a new task, how does it work? Are there any transferable subroutines across tasks?
  • I noticed that you also run an experiment with self-consistency, did you also try that on a math benchmark (AIME), and does it behave the same way?
  • Also why did you use only CoT for the self-consistency, instead of having one with ReACT?
5 comments
AuthorsOpenReview ↗

Response to Reviewer hvgA (1/3)

We thank the reviewer for the careful reading and the positive assessment. Below we report new experiments to address your questions/concerns. (New runs use the Gemini models of the paper, i.e., Gemini 2.5 Flash for the main tasks; and Gemini 3.1 Flash-Lite for AIME).

W1: The submission already reports repeated runs and intervals (Appendices H and J). To summarize the appendix results:

  • Appendix H (Table 11). DeepSeek-V3, three runs per method on MuSR: ARISE has the highest mean on all three tasks (71.0±4.0, 68.9±3.8, 68.7±3.1), 7.7 / 6.3 / 5.0 points above the next-best method (PoT).
  • Appendix J (Table 16). DeepSeek-V3, paired 95% case-bootstrap intervals against CoT: ARISE − CoT excludes zero on four of five tasks (+15.0 to +29.2); team is +3.0 [−7.0, +13.0].
  • Appendix J (Table 13). Gemini 2.5 Flash, three runs each of ARISE and CoT: +15.1 [6.0, 23.9] on object and +11.7 [2.3, 21.0] on meeting; murder (+6.0) and NBA (+5.1) include zero; team shows no gain (−0.7).
  • Appendix J (Table 17). Cross-model transfer (Gemini 2.5 Flash libraries on Gemini 3.5 Flash-Lite): all five intervals exclude zero.

We also add:

  • Here we add a full three-run Gemini table with extended baselines, per your request, and will add it to the main table. Gemini 2.5 Flash, mean test accuracy (%) over three runs (learned artifacts fixed; test shuffle seeds 42 / 123 / 456):
MethodmurderobjectteamNBAmeetingAvg
CoT81.359.175.066.269.770.3
PoT71.372.664.746.545.060.0
ReAct76.754.776.066.272.369.2
AWM79.056.668.768.787.772.1
ACE79.375.567.063.151.067.2
ASI78.359.458.065.271.366.5
GEPA84.776.170.764.681.075.4
Trace2Skill77.775.553.367.245.363.8
Ours as skill79.053.571.066.759.365.9
Ours as code84.761.965.370.758.768.3
ARISE87.374.274.371.281.377.7

Table 2 reports single runs, as do the original AWM, ACE, and ASI papers, which is primarily due to the high cost of running agentic tasks (for example, ACE runs five epochs to train). The submission already included repeated runs, and we add more here; in every repeated-run comparison, ARISE keeps the highest average accuracy.

W2: AWM, ACE, and ASI are strong, well-cited baselines, and their pipelines are not limited to web navigation: AWM reports cross-task generalization, and ACE is evaluated on AppWorld agent tasks and financial analysis. ASI in particular induces skills as executable code, and the comparison with code skills is central to our claim. All three also perform well on our benchmarks. Each baseline shares ARISE's base agent, tools, training split, gold labels, and request limits (Appendix D); ACE runs five adaptation epochs against our single pass. The ports are not degenerate: AWM is the best method on Gemini NBA (74.2) and meeting (88.0), and ACE is the best on DeepSeek murder (77.0). The knowledge-format comparison (the same induced text delivered as skills, code, or subroutines) does not depend on how faithfully any external method was ported. We understand your concern and also add two more baselines, GEPA (as the reviewer suggested) and Trace2Skill; see W3 below.

W3: Comparison with GEPA. We ran GEPA on Gemini 2.5 Flash on all five tasks, optimizing the ReAct agent's instruction with a 450-rollout budget. GEPA additionally uses the 75-instance validation split as its Pareto set, labels that ARISE does not see.

Accuracy (%), mean of three test runs (the optimized GEPA instruction and the ARISE library are fixed; test shuffle seeds 42 / 123 / 456):

murderobjectteamNBAmeetingAvg
GEPA84.776.170.764.681.075.4
ARISE87.374.274.371.281.377.7

Cost per task (USD). Training is trajectory collection plus induction for ARISE, and prompt-evolution rollouts plus reflection for GEPA. Inference is the full test split. ARISE values are those of Appendix I, Table 12.

murderobjectteamNBAmeetingAvg
ARISE5.281.283.784.253.553.63
GEPA3.622.415.7123.2716.7910.36

ARISE is higher on four of five tasks and on average (77.7 vs 75.4), at about a third of GEPA's total cost (USD 3.63 vs 10.36 per task) and with half the labelled data. On NBA and meeting, GEPA's optimization stopped at our per-task cost ceiling (after 390 and 340 rollouts), so running its full budget would cost more. GEPA tunes the agent's instruction while ARISE learns callable procedures, so the two are complementary.

AuthorsOpenReview ↗

Response to Reviewer hvgA (2/3)

W3 (continued): Comparison with Trace2Skill. We also implemented Trace2Skill from the official code and prompts, in creation mode: analyses of failed and successful training trajectories propose patches, which are merged hierarchically (32 per call) and applied to the skill; the evolved skill is preloaded into the agent's context. It uses the same model, base agent, and training split as ARISE. Accuracy (%), mean of three test runs (the learned skill and the ARISE library are fixed; test shuffle seeds 42 / 123 / 456):

murderobjectteamNBAmeetingAvg
Trace2Skill77.775.553.367.245.363.8
ARISE87.374.274.371.281.377.7

ARISE is higher on four of five tasks and by 13.9 points on average, at a lower total cost per task (USD 3.63 vs 4.22).

Last but not least, ARISE is a complementary extension of existing methods: subroutines learned separately can be stacked into one library, and GEPA can be stacked on top of ARISE to tune the agent's instruction. We see this as a future direction to pursue.

W4: ARISE requires a training set. Yes, as do AWM, ACE, ASI, GEPA, and Trace2Skill: each learns from a training set or from a period of experience on the target task. The requirement is modest: one pass of the base agent over 75 training instances, of which the Gemini 2.5 Flash libraries used 54 (murder), 33 (object), and 53 (team) successful trajectories. Q2 and Q5 below address how many trajectories are needed and transfer to new tasks.

Q1: Categorize & merge. Items are labelled in batches of 30 by independent LLM calls; a batch does not see the labels of earlier batches. Consistency comes from the prompt, which asks for short, case-independent, canonical names for the reasoning move, and from a single merge call that reads all labels across batches with their counts and maps synonyms onto canonical categories (target 5–10). On Gemini 2.5 Flash, for example, the raw labels merge as murder 49 → 7, object 13 → 5, team 22 → 6, and NBA 29 → 5. The revision lists every raw label and its canonical category for murder.

Q2: How many samples, and how diverse? We re-induced libraries from random subsets of 5, 10, and 20 successful training trajectories (three subsets per size; Gemini 2.5 Flash, MuSR):

Successful trajectoriesmurderobjectteam
581.065.168.3
1085.766.069.0
2085.367.666.0
Full set (54 / 33 / 53)86.075.576.0

On murder, 10 successful trajectories already match the full set. On object and team, however, the subset libraries stay 7–10 points below the full-set library; we did not vary diversity separately.

Q3: Gemini 2.5 Flash on NBA and meeting. On NBA, the Table 2 gap (ARISE 71.2 vs AWM 74.2) does not hold over three runs: AWM's 74.2 is its best of three (74.2 / 69.7 / 62.1), and the three-run means favor ARISE, 71.2 vs 68.7 (+2.5 [−3.5, 8.6]). On meeting, AWM is better: 87.7 vs 81.3 over three runs (−6.3 [−12.0, −1.0]). On DeepSeek-V3, however, ARISE is the best method on both tasks (74.2 and 51.0), so part of the gap is tied to model-specific behavior.

Q4: A single prompt containing the specifications. The skill row is close but not identical: the skill text equals the specification, but the agent retrieves it into its own context on demand. We added the exact condition the reviewer describes: all specifications in the agent's prompt, base tools, no subroutines (Gemini 2.5 Flash; mean of three runs, as for ARISE).

TaskAll specifications in the promptARISE
murder79.087.3
object77.774.2
team59.074.3
NBA68.771.2
meeting85.381.3
Avg73.977.7

Putting every specification in the prompt recovers much of what retrieval loses (73.9 vs 66.1 for skills in Table 2). Executing the specifications as subroutines is still higher on average and on three of five tasks, while the prompt variant is higher on object and meeting.

AuthorsOpenReview ↗

Response to Reviewer hvgA (3/3)

Q5: New tasks and transfer across tasks. ARISE does not transfer across task families, and by design it should not. Its subroutines encode the recurring procedures of one task, for example investigate_means_and_weapon and investigate_motive_and_intent for murder mysteries, infer_character_belief for object placement, and check_nba_cba_compliance for NBA rules. These procedures have no counterpart in another task family. The same holds for every experience-based method we compare with: AWM's workflows, ACE's playbooks, ASI's skills, and GEPA's optimized instructions are all learned from one task's training data and are specific to it. Like them, ARISE needs experience on a new task family; in our tasks, one pass of the base agent over 75 training instances suffices. What does transfer is a library for the same task across executing models. Libraries induced by Gemini 2.5 Flash and deployed unchanged on Gemini 3.5 Flash-Lite improve accuracy on all five tasks, by 10.7 to 32.8 points, with every interval excluding zero (Table 5).

Q6: Self-consistency on AIME. On AIME, the answer depends on the model:

AIME accuracy (%)Gemini 2.5 FlashGemini 3.1 Flash-Lite
CoT, SC@20 (T=0.7)90.769.8
ReAct, SC@20 (T=0.7)90.769.8
ARISE, single run (T=0)81.479.1
ARISE, SC@5 (T=0.7)81.486.0

With Gemini 3.1 Flash-Lite, the pattern matches MuSR. A single ARISE run (79.1) exceeds 20-sample voting over CoT or ReAct (69.8) at similar cost (USD 1.98 vs 2.12 and 2.48), and voting over five ARISE samples raises it to 86.0. With Gemini 2.5 Flash, it does not. Sampled reasoning is already strong: single CoT samples at T=0.7 average 88.7%, and 20-sample voting reaches 90.7 for both CoT and ReAct, above ARISE's 81.4. Our reading is that the library helps most when the base model cannot reliably carry out the procedure itself: Gemini 2.5 Flash's own sampled reasoning already solves most AIME problems, while Flash-Lite's does not. This is the same pattern as in the main tasks: on Gemini 2.5 Flash, ARISE's gain over its base ReAct agent is largest where ReAct is weakest (object, +24.6) and zero where ReAct is already strongest (team, 76.0 vs 76.0). AIME 2023–2024 leaves little headroom for Gemini 2.5 Flash, where single CoT samples already reach 88%, so the library pays off mainly for cheaper models: with Flash-Lite, five ARISE samples (86.0) come within 3 points of Gemini 2.5 Flash's single CoT samples.

Q7: Why CoT, and self-consistency with ReAct. We used CoT because self-consistency over CoT is the standard way to scale test-time compute. Following the reviewer's suggestion, we added majority voting over ReAct samples (T=0.7). On MuSR with Gemini 2.5 Flash, voting over 5 / 10 / 20 ReAct samples gives 84.0 / 85.0 / 82.0 on murder and 57.5 / 58.5 / 56.6 on object, against 86.0 and 75.5 for a single ARISE run. Twenty ReAct samples cost USD 10.71 and 7.88 per task, against USD 4.85 and 0.94 for ARISE. The learned subroutines outperform additional sampling of the base agent, at lower cost.

Finally, we really appreciate your insightful suggestions, which have already helped us strengthen both the analysis and the presentation of this work. We hope the above clarifications resolve the concerns. If the response is helpful, we would be grateful if you could consider adjusting your score accordingly. We are committed to incorporating all promised additions in the camera-ready version to make the paper as valuable as possible to the community.

Reviewer_QP3sOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The paper proposes to learn a library of reusable reasoning subroutines from successful agent trajectories. Each subroutine has a calling interface and a natural-language specification executed through a separate LLM call. A ReAct agent selects and combines these routines when solving new tasks. The paper systematically shows that this method improves over other skill induction baselines that do not use LLM-called routines as skill representation.

Critical strengths
  1. An interesting systematic study of how learned experience should be represented and executed. IMO the major contribution is the comparison between executing induced LLM subroutines, retrieving the same text as guidance, and rewriting the specifications as code. Table 2 reports advantages over same-text retrieval in all ten model–task settings and over code rewrites in nine. Together, these experiments provide a useful overview of leveraging different representations for skill learning.

  2. Useful empirical gains across several reasoning settings. ARISE achieves the highest five-task average among the evaluated methods on both models. The collection-tool ablation, cross-model reuse, and additional mathematics results further demonstrate the approach beyond the main comparison.

Critical weaknesses

Learning reusable libraries from successful experience is not new, considering baseline methods such as AWM, ASI, and ACE. IMO, ARISE's major contribution is to combine experience-based library induction with natural-language subroutines that are separately executed by an LLM. This is a useful extension, but relatively modest. My positive assessment rests primarily on the systematic empirical investigation.

Questions for authors
  1. Table 10 compares successful-only and unfiltered trajectories. In the unfiltered condition, are failures explicitly labeled and analyzed, or simply pooled with successful traces? Could learning from failures help further, especially when successful trajectories are sparse?

  2. Section 3.1 states that intermediate steps are not independently verified. Since a correct final answer might come from flawed reasoning, does induction distinguish useful reasoning from erroneous steps within these trajectories? Did you examine whether such errors propagate into the learned routines?

2 comments
AuthorsOpenReview ↗

Response to Reviewer QP3s

We thank the reviewer for the careful reading. We agree that the systematic comparison of how learned experience is represented and executed is the paper's main contribution, and we will state it first in the introduction. We have strengthened that comparison with new experiments and answer the two questions below.

W1: Novelty relative to AWM, ASI, and ACE. We agree that inducing a library from successful experience is shared with these methods, and we do not claim it as new. However, each of them changes what is learned and how it is used at the same time; the paper separates the two.

  • Table 2: Retrieved as skill documents, the induced text averages 51.8 (DeepSeek-V3) and 66.1 (Gemini 2.5 Flash). Executed as subroutines, it averages 67.4 and 77.7. On Gemini, retrieval leaves the agent below the ReAct agent that produced the trajectories (66.1 vs 68.2).
  • Table 8 (Appendix F, p. 20) shows: Replacing the specifications with a generic instruction gives 67.7, and generic tools give 64.2, against 78.4.
  • Robustness of the comparison with prior methods. Over three runs, the five-task averages are 77.7 for ARISE, 72.1 for AWM, and 67.2 for ACE.

We read these results as placing our method as a third design point, beside in-context prose (AWM, ACE) and executable code (ASI).

Q1: Failures in Table 10 (Appendix G). To clarify: in the unfiltered variants (C, D), failed trajectories are pooled with successful ones without any label; categorization and synthesis see only the step text.

Could learning from failures help? Table 10's intention is to test whether filtering helps (it does, on all three tasks). Following the reviewer's suggestion, we also tested two uses of labelled failures on MuSR:

  • Use (a): failed-trajectory steps are marked as such during labelling, and synthesis uses them as counterexamples;
  • Use (b): each specification gains 2–4 pitfalls distilled from the most similar failed steps.

In the new experiments, neither variant yielded a positive result. The three-task means are 79.2 (successful only), 77.5 (Use a), and 77.9 (Use b), and no task differs at p < 0.05 (sign test). These runs use the full training set.

Could learning from failures help when trajectories are sparse? We reduced the number of successful trajectories, and with only 10 successful trajectories, ARISE reaches 85.7 / 66.0 / 69.0 on murder / object / team (85.3 / 67.6 / 66.0 with 20), against 86.0 / 75.5 / 76.0 with the full set of 33–54 trajectories. Failures would matter most on tasks such as Natural Plan trip (2 successes), which we list as a limitation. For these new experiments, failures can be case-specific and, when learned, can add noise to the agent subroutines.

Q2: Error propagation for erroneous steps. We audited all 45 specifications in the ten Table 2 libraries and the 221 trajectory steps they were synthesized from. A Gemini 2.5 Pro judge, validated against our hand labels and given the full instance and gold answer, labelled each step, and we checked every label by hand. Correct answers do hide flawed steps - 12 of the 101 assessable steps (11.9%) contain a false claim or an invalid inference - but none of the 12 appears in any specification. Two design choices account for this: a subroutine needs support from at least three items, and synthesis writes a general procedure over a fixed signature rather than a step's conclusion. Error might also propagate when synthesis copies one selected source step as the specification's output example. The selected step was erroneous in only 1 of 45 specifications, and the error was not reproduced there.

Finally, we really appreciate your insightful suggestions, which have already helped us strengthen both the analysis and the presentation of this work. We hope the above clarifications resolve the concerns. If the response is helpful, we would be grateful if you could consider adjusting your score accordingly. We are committed to incorporating all promised additions in the camera-ready version to make the paper as valuable as possible to the community.

AuthorsOpenReview ↗

Follow-up on our responses

Dear Reviewer QP3s, as the discussion period ends today, we would appreciate knowing whether our responses and the revised PDF address your concerns. We are happy to clarify any remaining questions. Thank you again for your time.

Comments on the paper

2 comments
Area_Chair_ZbaoOpenReview ↗

[To Reviewers] Active Participation in the Author–Reviewer Discussion

Dear Reviewers,

As the author–reviewer discussion period is coming to end soon, this is a gentle reminder to stay engaged. Please take some time to review and acknowledge the authors’ rebuttals, follow up on any remaining questions, and update your reviews as appropriate.

Thanks, AC

AuthorsOpenReview ↗

Summary of Rebuttal and Revisions

Dear Area Chair and Reviewers,

We would like to briefly summarize our responses during the rebuttal and the corresponding revisions. We have uploaded a revised PDF in which all changes are marked in blue.

How reviewer concerns are addressed

During the rebuttal, we provided:

  • Clarifications on the contribution relative to prior experience-based methods (AWM, ASI, ACE) and to agent hand-off and multi-agent systems, now stated in the introduction and in a new related-work paragraph. [QP3s, Ab5q]
  • New hand-off baselines that delegate to tool-using sub-agents, and ARISE with agentic executors. Hand-off does not improve on the base ReAct agent on average, while the single-call ARISE library outperforms every hand-off variant on all five tasks (new Appendix M). [Ab5q]
  • Three-run means with standard deviations for all Gemini 2.5 Flash methods, now in the main table. ARISE keeps the highest average accuracy in every repeated-run comparison. [hvgA]
  • Two additional baselines, GEPA and Trace2Skill, now in the main table. ARISE scores higher on average (77.7 vs. 75.4 and 63.8) at a lower total cost per task. [hvgA, Ab5q]
  • New experiments on learning from failed trajectories, on the number of successful trajectories, and on iterated induction (new Appendix N). [QP3s, hvgA, Ab5q]
  • An audit of whether erroneous trajectory steps propagate into the learned specifications: none of the 12 flawed steps found among 101 assessable steps appears in any specification (Appendix N). [QP3s]
  • The full list of raw labels and their canonical categories for murder mystery (Appendix N), and statistics on the size of the focus argument. [hvgA, Ab5q]
  • Self-consistency comparisons with CoT and ReAct on AIME and MuSR, and an evaluation with all specifications placed in the agent's prompt. [hvgA]
  • Further clarifications on the induction pipeline, baseline adaptation, and transfer across tasks and models. [hvgA, Ab5q]

How reviewers responded

  • Reviewer hvgA thanked us for the thorough response and stated that it addresses their concerns.
  • Reviewer Ab5q commended the additional experiments, noted the added rigor, and raised their score. We answered their follow-up question on why ARISE outperforms hand-off: the agentic executor uses the same sub-agent implementation as the hand-off baselines, so the difference comes from the learned library (76.6 vs. 65.0 and 60.4).

Appendices A–L and Tables 1–18 keep the numbering used in our responses; the new material is in Appendices M and N and Tables 19–23.

We are sincerely grateful for the reviewers' detailed feedback, which has already helped us strengthen the paper, and we remain committed to incorporating all promised additions and clarifications into the final version.

Thank you for your time and consideration.

Sincerely, Authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.