DynaSaur: Large Language Agents Beyond Predefined Actions
Authors: Dang Nguyen
Viet Dac Lai
Seunghyun Yoon
Ryan A. Rossi
Handong Zhao
Ruiyi Zhang
Puneet Mathur
Nedim Lipka
Yu Wang
Trung Bui
Franck Dernoncourt
Tianyi Zhou
Venue: COLM 2025 (2025)
Keywords: LLM
LLM agents
TL;DR: We propose a flexible LLM agent framework for open-ended environments, where it dynamically generates new actions when existing ones are insufficient. These actions accumulate over time for future reuse.

Abstract: Existing LLM agent systems typically select actions from a fixed and predefined set at every step. While effective in closed, narrowly scoped environments, this approach presents two major challenges for real-world, open-ended scenarios: (1) it significantly restricts the planning and acting capabilities of LLM agents, and (2) it requires substantial human effort to enumerate and implement all possible actions, which is impractical in complex environments with a vast number of potential actions. To address these limitations, we propose an LLM agent framework that enables the dynamic creation and composition of actions in an online manner. In this framework, the agent interacts with its environment by generating and executing programs written in a general-purpose programming language. Furthermore, generated actions are accumulated over time for future reuse. Our extensive experiments across multiple benchmarks demonstrate that this framework significantly improves flexibility and outperforms prior methods that rely on a fixed action set. Notably, it enables LLM agents to adapt and recover in scenarios where predefined actions are insufficient or fail due to unforeseen edge cases.

Published as a conference paper at COLM 2025
DynaSaur h: Large Language Agents
Beyond Predefined Actions
Dang Nguyen 1 Viet Dac Lai?, Seunghyun Yoon?, Ryan A. Rossi" Handong Zhao?, Ruiyi Zhang', Puneet Mathur", Nedim Lipka', Yu Wang", Trung Bui?, Franck Dernoncourt, Tianyi Zhou' Uniieesitty of Maryland, 2 AAdobe Research {dangmn, tianyi J@umd. edu
Abstract
Existing LLM agent systems typically select actions from fixed and pre- defined set at every step. While this approach effective in closed, nar- rowly scoped environments, it presents two major challenges for real-world, open-ended scenarios: (1) significantly restricts the planning and acting capabilities of LLM agents, and (2) it requires substantial human effort to enumerate and implement all possible actions, which is impractical in com- plex environments with vast number of potential actions. To address these limitations, we propose an LLM agent framework that can dynamically cre- ate and compose actions as needed. In this framework, the agent interacts with its environment by generating and executing programs written in a general-purposs programming language. Moreover, generated actions are accumulated over time for future reuse. Our extensive experiments across multiple benchmarks show that this framework significantly improves flexibility and outperforms prior methods that rely on fixed action set. Notably, enables LLM agents to adapt and recover in scenarios where predefined actions are insufficient or fail due to un edge cases. Our code can be found in https: //gtthbb.b thub, com/ ad/be-dobeeeeeeee research research/dynasuur.
1 Introduction
Developing autonomous agents has long been a central goal in Al research. While reinforce- ment learning has extensively studied this problem and has achieved significant success in specific domains (Silver et al., 2016; 2017; Vinyals et al., 2019; Schrittwieser et al., 2020; Wurman et al., 2022), it often falls short in adaptability and generalization within dynamic and uncertain environments. Given the recent advancements in Large Language Models (LLMs) (Chen et al., 2021a; OpenAl, 2023; Bubeck et al., 2023; Anil et al., 2023; Reid al., 2024) with strong reasoning ability and the vast amount of world knowledge they encap- sulate during pretraining, LLMs are considered promising foundations for agent policies capable of solving complex, woaldworld problems (Schick et al., 2023a; Chen et al., 2023a; Yao et al., 2023b; Deng et al., 2023; Chen et al., 2024a; Zeng et al., 2024). Notable initial works include Toolformer (Schick et al., 2023a), which explores self-supervised training for LLM agents to utilize external tools, such as calculators, search engines, and translation services, thereby enhancing responses to complex question-answering tasks. ReAct (Yao et al., 2023b) proposes a synergistic approach by interleaving reasoning and action sequences at each step, which has become the de facto prompting framework in most LLM agent systems. Reflexion (Shinn et al., 2023), follow-up work, investigates LLM agents that maintain a set of self-reflections on their past mistakes in failed trajectories; conditioning on self-reflection feedback significantly improves agent performance across various benchmarks, albeit with the trade-off of increased inference costs.
Despite these efforts, most existing LLM agent systems are studied in closed, simulated environments that accept only a finite and small set of predefined actions (Zhou et al.,
Work done during internship at Adobe Research.

---

Published as a conference paper at COLM 2025
2024a; Yao et al., 2022; Deng et al., 2023; Shridhar et al., 2021; Liu et al., 2018). At every decision point, an LLM agent is constrained to select an action from this set, leading to several drawbacks. First, it restricts the agent's flexibility, preventing it from performing actions outside the predefined scope. Second, it requires significant human effort to carefully enumerate and implement all possible actions beforehand; while manageable for closed environments, this approach becomes prohibitively expensive and impractical for real- world settings. Third, in long-horizon tasks, the agent must compose sequences of primitive actions from scratch each time, limiting its ability to learn from past experiences and improve efficiency over time. To address these limitations, we propose DynaSaur, , an LLM agent framework that enables the dynamic creation and composition of arbitrary actions by modeling each action as Python function. At each step, the agent performs actions by generating Python code snippets that either define new functions, when the existing set is insufficient, or reuse existing functions from the current action set. The generated code is executed through Python interpreter, and the resulting observations are returned to the agent. All actions generated by the agent are accumulated over time, building a library of reusable functions for future use. This approach allows the agent to extend its capabilíties on the fly and compose complex actions from simpler ones, thereby enhancing its flexibility and problem-solving abilities. By leveraging the extensive ecosystem of third-party Python packages, the agent can interact with a wide range of systems and tools.
Through experiments on a diverse set of benchmarks, including GAIA (Mialon al., 2024), MATH (Hendrycks et al., 2021b), TabMWP (Lu et al., 2023), AIME (Li et al., 2024), and GPQA (Rein al., 2023), we demonstrate that our framework enables extremely versatile LLM agents. The agent is capable of handling diverse tasks and file types without requiring human implementation of supporting functions. While the LLM agent is performant and capable on its own, extending the framework by incorporating tools developed by human experts is straightforward, simply include these tools in the agent's action set. We find that combining human- desinndd tools with agent-generater functions results in complementary capabilities, further enhancing the agent's s performance and versatility.
2 Problem Formulation
We begin by formally stating our problem of interest. We model the behavior of an LLM agent as Partially Observable Markov Decision Process defined by the tuple A,, O, T, Z), where ' is the task space; A is the action space, which most existing works define as finite set of predefined actions: A = {a,,..., an S is the state space; O is the observation space, T: S x A + P(S) is the state transition function, mapping a state-action pair to probability distribution over subsequent states; and Z : S A - PO) is the observation function, mapping a state-action pair to probability distribution over observations. Given task u E U, the agent starts in an initial state so S. At each time step f, the agent selects an action a E A which causes the environment to transition to new state St+1 according to the transition probability T(st, at). The agent then receives an observation O; i1 O drawn from the distribution 7(5 a:). This process repeats until the agent reaches a terminal state ST that satisfies the original task u.
In this paper, we are interested in a more general setting where A is not fixed in advance. Specifically, we introduce a potentially infinite set A' of all possible actions the agent can propose. At each time step f, the agent is allowed to propose any action E A" to solve the task u. The cumulative action set at time f is defined as A; = a2,,a,,,,,, new action a, may be entirely novel action actions from A, 1. Consequently, the overall action space A evolves dynamically as the agent encounters more tasks in lí. The state transition function is accordingly redefined as T:S x A' + P(S), and the observation function as Z : S x A + P(O).
Each
composition of previously generated
3 Methodology
Action Representation. To design such an LLM agent system, our first challenge is to select an appropriate representation for the action space. This representation must satisfy
2

---

Published as a conference paper at COLM 2025
Retreve eve
Action A
Action a
Generated Actions A
Update
Environment E
Action Retriever R
f
Agent
IPython
User-defined A
Input
Internet
WWWW
mteroch
Operating System
Task
Observation 0
Figure 1: Illustration of the DynaSaur agent framework. The agent π7 receives task and optionally a set of human-designed actions A". It then interacts with an environment & by proposing an action a E A, implemented as Python function. The action executed in an IPython kernel, which may interface with the operating system, the internet, or the action retriever as needed. The result, either the output of the function or an error message, observation Generated actions that execute successfully are
is returned to the agent accumulated into A8,
two key criteria: (1) Generality: it should be expressive enough to represent actions capable of solving wide range of tasks; and (2) Composability: should naturally support the composition of actions. We argue that a general-purpont p programming language meets these requirements well. We choose Python for its popularity and extensive ecosystem of libraries. This choice not only satisfies the aforementioned criteria but also facilitates seamless integration with existing tools and libraries. In our framework, each action a E A is represented Python function.
Action Retrieval. Including all generated actions as part of the prompt runs the risk of exceeding the context limit as the agent generates more actions. To address this issue, we decompose the action set A into two subsets: an optional human-designed action set A" and generated action set A8. Only actions in A" are included in the prompt by default, allowing developers to inject domain-specific actions they consider important. To provide the agent access to actions in A&, we introduce action retrieval function R x + 2-48 where Q denotes the space of queries and IN is the set of positive integers. When generating the actions, we also instruct our agent provide a docstring describing the purpose of each action function it generates. The docstrings are then embedded to form set of indices of the generated actions. Given query 9 E Q and an integer E N, the function R R(q, k) embeds the query using the same embedding, then computes the cosine similarity between the query's 's embedding and each action's 's docstring embedding. The top-k actions in A8 with the highest similarities are returned to the agent as part of its observations. To enable the agent to decide when to invoke action retrieval, we include the action retrieval function itself as an action in the human-designed action set A²" Therefore, the agent can autonomously decide to perform action retrieval by selecting R during its decision maaiingnn process.
Action Accumulation. Our complete pipeline is illustrated in Figure 1: Given a task " E u and a human-designed action set A with R E A"", at time step f, we sample thought- action pair ()), ~ No(a; A"", Cr 1) following the ReAct framework (Yao et al., 2023b), where C- 1 {(h, #1, 01), 01) (h:- 1,4, 1,44-1,0, 0;-r)) 1)} represents the interaction history up to The action a, executed and an observation o, is returned from the environment, updating the context to C C--1 U ((h,,,, 0.)). If at contains new function not present in
time t 1- 1.
A$ we update the generated action set by setting A& A 1 (at),, where fa:) denotes
3

---

Published as a conference paper at COLM 2025
GPT-4o mini
GPT-40
Agent Pipeline
Level
Level 2
Level Avg.
Level
Level 2
Level 3
Avg.
MMAC (rep.)
45.16
20.75
6.12
25.91
AutoGen Multi-Agent (rep.)
47.31
28.93
14.58
32.33
HF Agent (rep.)
49.46
28.30
18.75
33.33
Sibyl (rep.)
47.31
32.70
16.33
34.35
Trase Agent (rep.)
50.54
33.33
14.29
35.35
No Pipeline
7.53
4,40
0.00
4.65
13.98
8.81
2.04
9.30
Sibyl (repl.)
21.51
15.72
4.08
15.61
38.71
24.53
10.20
26.58
HF Agent (repl.)
32.26
21.38
8.33
22.67
39.78
27.04
14.58
29.00
DynaSaur
45.16
22.01
51.61
36.48
18.37
38.21
Table 1: Performance comparison between various baseline methods and our proposed ap- proach the GAIA benchmark, evaluated under two LLM backbones: 1---4--224-0--- and spt-4o-mini-2022-222
"No Pipellie" refers to the baseline where no agent pipeline is employed, and the raw LLM is used. Results marked with (rep.) are reported results, while (repl.) indicates replicated results. Each value represents the average exact match percentage between the predicted answers and the ground truth.
No Pipeline
Sybte
HF Agent
DynaSaur
#
AA
AI
IA
Level
Level 2
Level 3
Avg.
TabMWP
MATH
95.71
77.86
95.00
74.29
80.71
96.43
97.14
82.14
2
1
V
X
43.40
33.96
35.85
37.21
19.77
18.60
11.54
7.69
7.69
35.15
23.03
AIME
13.00
20.00
20.00
31,71
4
x
47.17
40.70
15.38
38.79
GPQA
48.00
46.00
38.00
54.00
5
/
49.06
41.86
26.92
41.82
Table 2: Performance comparison between var- ious baseline methods on additional datasets. We utilize 2024-08-06 as the LLM back- bone in this experiment.
Table 3: Ablation study on the impact of three major components: Action Accu- mulation (AA), Action Implementation (AT), and Initial Actions (IA).
the set of functions defined in action A₁. Our detailed prompt can be found in Figure 7. For evaluation, we employ action accumulation during training but disable it during testing. This approach ensures that performance on each test task is independent of other test tasks.
Experiments
4.1 Experimental Setup
While numerous interactive environments exist for LLM agents, such as WebArena (Zhou et al., 2024a), WebShop (Yao et al., 2022), Mind2Web (Deng et al., 2023), ALFWorld (Shridhar al., 2021), and MiniWoB++ (Liu al., 2018), they are suitable for evaluating our proposed agent framework, as they only support a limited set of predefined actions and do not allow arbitrary action execution. We instead evaluate DynaSaur on set of static datasets. Specifically, we consider GAIA (Mialon et al., 2024), general agent benchmark covering broad range of tasks including web browsing, file parsing and pro- cessing, symbolic reasoning, video understanding, and audio understanding. Additionally, we evaluate our agent on MATH (Hendrycks et al., 2021b), TabMWP (Lu et al., 2023), AIME (Li al., 2024), and GPQA (Rein et al., 2023) for more comprehensive assessment.
Benchmarks.
Baselines. We compare method with agent systems that utilize fixed set of predefined actions, including Hugging Face Agents (HF Agent) (Roucher, 2024) and Sibyl System v0.2 (Sibyl) (Wang et al., 2024b). For the GAIA benchmark, we also include MMAC v1.1 (MMAC) (Song et al., 2024c), Multi-Agent Experiment v0.1 (AutoGen Multi-Agent) (Wu et al., 2023), and Trase Agent (Systems, 2025) for reference. Additionally, we include vanilla GPT-4o models without any agentic framework to establish a lower bound for comparison.
Initial Actions. For a fair comparison with baselines, we initialize the action set with human-designed tools from Microsoft's AutoGen (Wu et al., 2023), similar to HF Agent.
4

---

Published as a conference paper at COLM 2025
These tools include web browser, file inspection tool that converts various file types into machine-readable Markdown format, and a visual question-answering tool. A detailed list of the tools and their descriptions can be found in Table 5.
Models. We utilize two LLM backbones for all agentic pipelines: GPT-4o 4g0t-40-2024-88 and GPT-4o mini (gpt-4o-mini 1on-ii-222-0----11 through Azure OpenAI For further analyses, to save costs, we only evaluate using GPT-4o.
Implementation Details. We use OpenAl's text -ttee-emeddinng--eaeee model and set the number of retrieved actions of steps to 20 and set the temperature to 0.5 for all experiments. In the main experiment, we first run our agent on all examples in the validation set and accumulate the generated actions. We then freeze the action set for evaluation on the test set.
as the embedding 10. We limit the maximum number
4.2 Main Results
We evaluate our proposed method and compare its performance with selected baselines in Table 1. As shown in the table, DynaSaur significantly outperforms previous baselines for both LLM backbones across all difficulty levels of the GAIA benchmark. This demonstrates that the ability perform arbitrary actions, combined with the capacity to accumulate actions over time, provides substantial advantages over traditional LLM agent pipelines with fixed action sets sets-particularii) in highly complex, long-horizon tasks such as GAIA Level and Level 3. In this experiment, because the exact version of GPT-4o used by HF Agent and Sibyl unclear, we re-evaluated their pipelines under the same LLM backbones as ours to ensure fair comparison. Their original results, reported on the GAIA public leaderboard, are included as references. Results in Table 2 further show that our method consistently outperforms the baselines on the MATH, TabMWP, AIME, and GPQA benchmarks. We include additional experiments on open-source LLMs in Appendix A.
4.3 Further Analysis
In the following analysis, we use GAIA as the default dataset unless stated otherwise. Since only the GAIA validation set contains labels, we action accumulation on 200 test examples and then evaluate on the entire validation set using the frozen action set.
4.3.1 The Impact of Action Accumulation, Action Implementation, and Initial Actions?
Our first analysis focuses on ablations of key components in the agent pipeline. We highlight three main components: (1) the initialization of the action set, (2) the capacity to implement arbitrary actions, and (3) the ability to accumulate actions across episodes. Notably, action accumulation depends the agent's ability to implement arbitrary actions, as previously generated actions must be executable.
As shown in Table 3, initializing the agent with a set of human-designed actions (row 3) improves performance on GALA by 61% relative to the minimal baseline (row 1). This improvement expected, as these tools are highly specialized for GAIA tasks, which often involve browsing the web or reading various file types. Adding support for arbitrary action implementation (row 4) further improves performance by 10% (relative to row 3), and enabling action accumulation (row 5) yields an additional 7% gain (relative to row 4). These results support the effectiveness of each component in our proposed framework.
4.3.2 How Does Implementing Arbitrary Actions Improve Agent Performance?
To dive deeper into understanding the specific advantages action implementation, we filtered out GAIA tasks that an agent without action implementation (referred to as agent A) answered incorrectly but an agent with action implementation (referred to as agent B) answered correctly. We then analyzed the reasons why agent A failed at these tasks and whether enabling action implementation in agent helped resolve these limitations. We se- lected pipeline variants from row 3 in Table 3 as agent A and row 1 as agent B. After filtering,

---

Published as a conference paper at COLM 2025
Insufficient Action
Instruction Following
Other
Level 1
Level 2
Level 3
0.0
0.2
0.4
0.6
0.8
1.0
Figure 2:
Distribution of error types in tasks where agent A (without action implementation) answers incorrectly, while agent B (with action implementation) answers correctly.
Extracting Parsing
Misceloneous
22.5%
Mean Coverage
0.3
22.5%
8.7%
0.2
Checking
0.1
MATH
Searcingg
20
40
60
80
# Actions
Figure 3: Mean coverage over the valida- tion set as the number of actions increases. The red dashed line marks the point where human-designed actions are added.
Figure 4: Categories of actions accumulated during evaluation on GAIA validation set.
obtained a set of 22 tasks. We employed OpenAl's ol model (01-ppreveew22224-99-1 as an evaluator. For each task, we provided ol with the task, the correct answer, the reference trajectory from human annotator, agent A's answer and trajectory, well agent B's answer and trajectory. We instructed ol to summarize both agents' approaches with expla- nations for success or failure, then explain whether agent B succeeded failed because of its ability to implement new actions. The detailed prompt is provided in Figure 6 in the Appendix. After ol's evaluation, categorize agent A's errors into three types: (1) failure due to insufficient tooling, (2) failure to correctly follow instructions, and (3) failure due other reasons.
manually analyzed the reports from ol to further
Our findings reveal that 61.91% of Agent A's failures were due to Reason 1, with 12 cases where the agent lacked the necessary tools to solve the task, and 1 case where human- designed tool failed to return relevant information. In 9.52% of the cases, agent A failed due to reason 2 (e.g., returning an answer with an incorrect unit). The remaining 28.57% of the failures were caused by other unrelated factors, such the inability to find relevant information online or getting stuck without making progress. A more detailed breakdown of the error distribution for each level is shown in Figure 2. In all type-1 errors, agent B was able to complete the task by implementing custom actions. This result demonstrates that our framework significantly improves the agent's flexibility in problem solving.

---

Published as a conference paper at COLM 2025
Actions browon web Tise
Agent A
Agent
Thought
Lespect, filc
leguer pousiins of bla coll.
layoet, ixiluding
Thought
Action:
I nood acoms the file cifferes mathod
Task Read Essel from con move por and you may move up. down, or right con't move sewer than
Lefolry using sperges
Inspect, Crap xt
Action:
Observation:
Inpost openpysl
NEDI
def get excel valien, and atyles ($ile path) woekbook ccenpppc Jead wasstsck patta
StaE
M6.9
5.3
36/
363
cells, and you cant move budkward You cant cuove onto any blue cells. Ou the 1ith tum, what the é-digit has codo (wcl prefinj of the color of the cell where you land after moving!
8639
34h
363
io sheot.mix colume sheet.mzx FON
ceault [I
For cox abeut..ttar pestaat_sotttoo.o ac, Sonn, zet:
Thought
for bel1 row:
saloe cell.vateg
Feeed yur comout metted to acose the path ry tegerting
agais
date append (oalon, coloz))
peault. copend dase;
Action:
neturn
Inspect fuim cap "
Observatio:
get excel bee and etyles aanpuatttt
Observation:
("'starr* 01, (Roos, "/20030ye"), ...]
Bull
Stlft
H423
Eial
[Skam, 19974185711
[hure. 19P0569F915
[Rion,, 10F129000
(Kone. 19989793213
M423
368
[Olone, 'FF00937"1.
Itone. 17F00-99P13
6410
188
N010
[Olmm, '29009922"1
thome. 122:220052"1
Figure 5; A case study demonstrates the difference in problem-solving flexibility between Agent A (a variant of DynaSaur without action implementation) and Agent B (the proposed agent framework). Both agents begin with the same initial step, but only Agent B, equipped with the ability to implement its own actions, successfully completes the task. Due to space constraints, the first step taken by Agent B is not shown.
4.3.3 How Useful Are Generated Actions on Unseen Tasks?
In this experiment, we evaluate how the utility of a generated action set improves as the agent accumulates more actions over time. To quantify this utility, propose an Action Coverage metric, which measures how often an agent relies on the actions in a given set A to solve an unseen task Formally, given a task u, ground-truth answer y, and action set A, we sample a trajectory 7 = ( a and 0, denote the action and observation at step i (we omit the intermediate thought sequence h; for brevity). We consider the task successfully solved if the final observation Or y. At each step, the agent either reuses an action from A or generates a new one not in A. If the agent must generate a new action to complete the task, we consider the action set A insufficient for that task. We define the coverage of A over as the proportion of steps where the agent uses actions from A, conditioned on successful task completion:
or), from the policy Tt(. A, u), where
u)A,
E
1
1 = y) ((a.0:) ET:a; & AA [
|
1
(1)
Tm~Jal AA)
However, computing this metric exactly is prohibitively expensive. In practice, we approxi- mate it by sampling single trajectory for each task. We report the average Action Coverage over the test sets of GAIA and MATH, as visualized in Figure 3.
Initially, when |A| 1 (consisting only of the
action), coverage is low for both datasets, as expected. However, it is not zero, since a small number of tasks in both
GAIA and MATH can be solved by directly submitting the final answer at the first step. When human-designed tools are added (marked by the red dashed line), Action Coverage increases substantially for GAIA, but less so for MATH. This is because the tools are well- aligned with the steps required in GALA tasks, such as web browsing and file reading, but are less applicable to mathematical problem solving. In the subsequent steps, as the agent
7

---

Published as a conference paper at COLM 2025
accumulates generated actions, coverage increases for both datasets, with stronger rise observed in MATH. Our analysis suggests this due to the domain mismatch: on GAIA, the agent continues to rely heavily on the human-designed tools; whereas on MATH, where those tools are less useful, the agent increasingly relies on its own generated tools.
4.4 Statistics of the Generated Actions
We present summary statistics and analyses of the actions generated during evaluation GATA tasks. This section includes a breakdown of action types, categorization by functionality, and complexity analysis of the generated code. Additionally, we provide concrete examples of both successful and failed actions in the Appendix.
4.4.1 Action Statistics and Categories
total of 174 actions were generated, comprising 80 actions accumulated during training (from 165 examples) and 94 newly generated during testing (from 300 examples). We manu- ally inspected each action and grouped them into categories based on their functionality. The distribution is shown in Figure 4. Specifically, 23.75% of the actions are dedicated to extracting and parsing information from data or files, 22.5% perform calculations, 12.5% involve searching operations, 8.75% check conditions (e.g, evaluating whether a statement is true or false), and the remaining 32.5% fall into a miscellaneous category, including tasks such file conversion and counting.
4.4.2 Complexity Analysis
To assess the complexity of the generated actions, (McCabe, 1976), which quantifies the number of linearly independent paths in program's control flow. A cyclomatic complexity below 10 is generally considered threshold for maintainable code, while higher values may indicate more intricate and error-prone logic. Based on this metric, the generated actions exhibit an average complexity of 3.06, slightly lower than the average of 3.72 observed in human-authored actions.
the cyclomatic complexity metric
4.5 Case Studies
We present real case study comparing how agent without action implementation (denoted as agent A) and an agent with action implementation (denoted as agent B) approach the same problem. In this example, the task requires the agents to load an Excel file containing a map, as shown in the lower left corner of Figure The agent must then navigate through the map according to the task's movement rules and, after the 11th turn, return the color of the current cell. The provided action set is similar to previous experiments. In this scenario, the inspect_file ffle tool, developed by Microsoft's AutoGen (Wu et al., 2023), assists an agent by reading diverse file types and returning the file content in Markdown format. However, when reading Excel files, the tool does not account for formatting properties such as cell color, leading to incomplete information being returned and preventing agent A from solving the task. Since agent lacks other tools, it repeatedly attempts to invoke the inspect file tool until the maximum iteration limit is reached. On the other hand, agent B also initially tries invoke the same tool but recovers from the error by using a different approach to read the Excel file content through openpyxl. In subsequent steps, agent implements the solution for map navigation as a function and successfully completes the task (we omit the full steps due to space constraints). We include additional case studies on the benefits of dynamic action creation in Appendix C.
5
Related Work
5.1
LLM Agents
Most current methods that utilize LLMs for agent tasks involve prompting techniques (Yao et al., 2023a; Liang et al., 2023; Gao al., 2023; Kim et al., 2023; Song et al., 2024c),
8

---

Published as a conference paper at COLM 2025
supervised fine-tuning (Schick et al., 2023b; Zeng et al., 2023; Chen et al., 2024b; Zhang et al., 2024a; Chen et al., 2023b; Wang et al, 2024a), or reinforcement learning (RL) algorithms for self-exploration (Zhou et al., 2024b; Song et al., 2024b; Yang et al., 2024; Aksitov et al., 2023; Christianos et al., 2023; Abdulhai et al., 2023; Gulcehre et al., 2023; Song et al., 2024a). However, these approaches mainly study agents under the assumption that the set of actions is fixed and provided by the environment. Furthermore, most existing work uses text (Schick et al., 2023b) or JSÓN (Qin et al., 2023) as the representation of actions, which significantly lacks the two criteria mentioned earlier: generality and composability. In contrast, DynaSaur can utilize available actions or create new ones if necessary, using code as unified representation. In principle, acting with code enables agents to solve any Turing-complan problem.
5.2 LLM Agents for Code Generation
Although using LLMs to generate code is not new, these approaches have a long history dating back to the early stages of LLM development (Chen et al., 2021b; Austin et al., 2021; Hendrycks et al., 2021a). However, this line of research has primarily focused on using LLMs as software engineering assistants for tasks like code completion or program synthesis (Austin et al., 2021; Zhang et al., 2024b). In our work, we utilize programming languages as a tool to solve generalist AI agent tasks in the GAIA benchmark, which require multistep execution in partially observable and stochastic environments.
5.3 LLM Agents for Tool Creation
There have been few attempts to explore LLMs' ability to create their own tools, though these efforts have largely been limited to solving simple problems (Cai et al., 2023; Qian et al., 2023; Wang et al., 2023; Yuan al., 2023). For example, (Cai et al., 2023) examines LLMs generating code snippets to tackle basic tasks such as word sorting or simple logical deduction. Their approach involves sampling three input-output pairs of a specific task type, using the LLM to generate function to solve the problem, validating it with three additional pairs from the validation set, and then evaluating the solution on all test instances from the same task type. This setup simplifies the problem as the task type remains consistent during both training and testing. Similarly, (Qian et al., 2023) and (Yuan al., 2023) explore tool creation, but restrict their focus to math problems, with (Yuan et al., 2023) also introducing VQA benchmarks. These tasks are typically solvable in a single step and do not require interaction with an external environment. We are the first to study generalist LLM agents that implement and accumulate actions within the real-world agent benchmark GAIA.
Conclusion
We propose novel LLM agent framework that leverages Python as universal representa- tion for actions. By using general-purposs programming language, our framework enables the implementation of arbitrary actions as well as compositions of existing ones effeettvcyy addressing the limitations of prior agent systems that rely on a fixed, predefined action set. This design not only enhances expressiveness but also allows the agent to perform more complex, context-specific reasoning and decision-making. Moreover, our framework supports unsupervised accumulation of new actions over time, making it suitable for both online and offline deployment scenarios. This adaptability enables the agent to continually expand its capabilities without manual intervention or retraining. We believe that such flexibility is key to achieving strong generalization across diverse tasks and environments. To validate our approach, we conduct extensive experiments across variety of challenging benchmarks, including GAIA, MATH, TabMWP, AIME, and GPQA. Results consistently demonstrate the effectiveness of our framework. In addition, our analysis reveals that the agent is capable of autonomously recovering from tool failures caused by unforeseen edge cases highlighttn its robustness in real-world settings.
9

---

Published as a conference paper at COLM 2025
Ethics Statement
As a proof of concept, our framework allows agents to generate and execute arbitrary Python code. While this approach not advisable for real-world deployment due to potential security risks, we acknowledge that various safeguards can be implemented to mitigate these concerns. For example, one can apply a safety filter or a mordd- formal verifier to each action during creation prior to execution. Furthermore, the agent should be deployed in an isolated environment with restricted inbound and outbound traffic. Limiting file system permissions-sucl minimal edits instead of overwriting files-car further reduce the risk of unintended or harmful behavior. Restricting the agent's permissions also helps prevent the execution of malicious scripts.
enforcing read-only access encouraging
References
Marwa Abdulhai, Isadora White, Charlie Snell, Charles Sun, Joey Hong, Yuexiang Zhai, Kelvin Xu, and Sergey Levine. Lmrl gym: Benchmarks for multi-turn reinforcement learning with language models, 2023.
Renat Aksitov, Sobhan Miryoosefi, Zonglin Li, Daliang Li, Sheila Babayan, Kavya Koppa- rapu, Zachary Fisher, Ruiqi Guo, Sushant Prakash, Pranesh Srinivasan, Manzil Zaheer, Felix Yu, and Sanjiv Kumar. Rest meets react: Self-improvement for multi-step reasoning Ilm agent, 2023.
Rohan Anil, Sebastian Borgeaud, Yonghui Wu, Jean-Baptiste Alayrac, Jiahui Yu, Radu Sori- cut, Johan Schalkwyk, Andrew M. Dai, Anja Hauth, Katie Millican, David Silver, Slav Petrov, Melvin Johnson, Ioannis Antonoglou, Julian Schrittwieser, Amelia Glaese, Jilin Chen, Emily Pitler, Timothy Lillicrap, Angeliki Lazaridou, Orhan Firat, James Molloy, Michael Isard, Paul Ronald Barham, Tom Hennigan, Benjamin Lee, Fabio Viola, Malcolm Reynolds, Yuanzhong Xu, Ryan Doherty, Eli Collins, Clemens Meyer, Eliza Rutherford, Erica Moreira, Kareem Ayoub, Megha Goel, George Tucker, Enrique Piqueras, Maxim Krikun, lain Barr, Nikolay Savinov, Ivo Danihelka, Becca Roelofs, Anaïs White, Anders Andreassen, Tamara von Glehn, Lakshman Yagati, Mehran Kazemi, Lucas Gonzalez, Misha Khalman, Jakub Sygnowski, and et al. Gemini: A family of highly capable mul- timodal models. CoRR, abs/ 2312.11802111111 2023. doi: 10.48550/ 100550//AXXV.232.118885 URL https://doi. org/10 10. 48550/ 2312. 11805.
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.
Sébastien Bubeck, Varun Chandrasekaran, Ronen Eldan, Johannes Gehrke, Eric Horvitz, Ece Kamar, Peter Lee, Yin Tat Lee, Yuanzhi Li, Scott M. Lundberg, Harsha Nori, Hamid Palangi, Marco Túlio Ribeiro, and Yi Zhang, Sparks of artificial general intelligence: Early experiments with GPT-4. CoRR, abs abs/3/33..2212 2023. doi: 10.48550/ ARXIV.2303.1211. URL https://doi. org/10..//00 http//...855//areee 48550/arXiv.. 2303 12712.
Tianle Cai, Xuezhi Wang, Tengyu Ma, Xinyun Chen, and Denny Zhou. Large language models as tool makers. ArXic, abs abbs/230..1716, 2023. URL https: //api. semanticscholar.
/tg//CrrpusID:2284477222
Baian Chen, Chang Shu, Ehsan Shareghi, Nigel Collier, Karthik Narasimhan, and Shunyu Yao. Fireact: Toward language agent fine-tuning. CoRR, abs /b30003000591 2023a. doi: 10.48550/ ARXIV.2310.05915 1. URL http::: /tt::://ooioooo org/10. 48550/arXiv.. 231.0..i...1...... 05915.
Baian Chen, Chang Shu, Ehsan Shareghi, Nigel Collier, Karthik Narasimhan, and Shunyu Yao. Fireact: Toward language agent fine-tuning, 2023b.
Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Pondé de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin,
10

---

Published as a conference paper at COLM 2025
Brooke Chan, Scott Gray, Nick Ryder, Mikhail Pavlov, Alethea Power, Lukasz Kaiser, Mo- hammad Bavarian, Clemens Winter, Philippe Tillet, Felipe Petroski Such, Dave Cummings, Matthias Plappert, Fotios Chantzis, Elizabeth Barnes, Ariel Herbert- 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, Joshua 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. CoRR, 2ttp/2210.003374,, 2021a. https//s///arxi http:/www...rgg////////////// 03374.
Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, 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, Mo- hammad 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 Wojeiech Zaremba. Evaluating large language models trained on code, 2021b.
Zehui Chen, Kuikun Liu, Qiuchen Wang, Wenwei Zhang, Jiangning Liu, Dahua Lin, Kai Chen, and Feng Zhao. Agent-flan: Designing data and methods of effective agent tuning for large language models. In Lun-Wei Ku, Andre Martins, and Vivek Srikumar (eds.), Findings of the Association for Computational Linguistics, ACL 2024, Bangkok, Thailand and virtual meeting, August 11-16, 2024, pp. 9354-9366. Association for Computational URL https:///ol. org/
Linguistics, 2024a. doi: 10.18653/ /V1533/////0/ /2//22/FFIIINNGGSSAAII 10. 18653/v1/2024 findings-acl.55 acl.
Zehui Chen, Kuikun Liu, Qiuchen Wang, Wenwei Zhang, Jiangning Liu, Dahua Lin, Kai Chen, and Feng Zhao. Agent-flan: Designing data and methods of effective agent tuning for large language models, 2024b.
Filippos Christianos, Georgios Papoudakis, Matthieu Zimmer, Thomas Coste, Zhihao Wu, Jingxuan Chen, Khyati Khandelwal, James Doran, Xidong Feng, Jiacheng Liu, Zheng Xiong, Yicheng Luo, Jianye Hao, Kun Shao, Haitham Bou-Ammar, and Jun Wang. Pangu- agent: A fine-tunable generalist agent with structured reasoning, 2023.
Xiang Deng, Yu Gu, Boyuan Zheng, Shijie Chen, Samual Stevens, Boshi Wang, Huan Sun, and Yu Su. Mind2web: Towards a generalist agent for the web. In Alice Oh, Tristan Naumann, Amir Globerson, Kate Saenko, Moritz Hardt, and Sergey Levine (eds.), Advances in Neural Information Processing Systems 36: Annual Conference on Neu- ral Information Processing Systems 2023, NeurlPS 2023, New Orleans, LA, USA, Decem- http:/ppppre223//////
ber 10- 16, 2023, 2023. URL http:: /papers. nips. cc/paper 5950bf290a1 157 0070229011170010111 bF988821281 1008811229t--Asstttttt-atttsss ts and Benchmarks. html.
Luyu Gao, Aman Madaan, Shuyan Zhou, Uri Alon, Pengfei Liu, Yiming Yang, Jamie Callan, and Graham Neubig. Pal: Program-aided language models, 2023.
Caglar Gulcehre, Tom Le Paine, Srivatsan Srinivasan, Ksenia Konyushkova, Lotte Weerts, Abhishek Sharma, Aditya Siddhant, Alex Ahern, Miaosen Wang, Chenjie Gu, Wolfgang Macherey, Arnaud Doucet, Orhan Firat, and Nando de Freitas. Reinforced self-training (rest) for language modeling, 2023.
Dan Hendrycks, Steven Basart, Saurav Kadavath, Mantas Mazeika, Akul Arora, Ethan Guo, Collin Burns, Samir Puranik, Horace He, Dawn Song, and Jacob Steinhardt. Measuring coding challenge competence with apps, 2021a.
Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Measuring mathematical problem problel solving with the MATH dataset. CoRR, /b133.0033338 2021b. URL. https:://aaasttt http://///aaai.o.o////01/1..00 03874.
11

---

Published as a conference paper at COLM 2025
Geunwoo Kim, Pierre Baldi, and Stephen McAleer. Language models can solve computer tasks, 2023.
Jia Li, Edward Beeching, Lewis Tunstall, Ben Lipkin, Roman Soletskyi, Shengyi Huang, Kashif Rasul, Longhui Yu, Albert Q Jiang, Ziju Shen, et al. Numinamath: The largest public dataset in ai4maths with 860k pairs of competition math problems and solutions. Hugging Face reposilory, 13:9, 2024.
Jacky Liang, Wenlong Huang, Fei Xia, Peng Xu, Karol Hausman, Brian Ichter, Pete Florence, and Andy Zeng. Code policies: Language model programs for embodied control, 2023.
Evan Zheran Liu, Kelvin Guu, Panupong Pasupat, Tianlin Shi, and Percy Liang. Re- inforcement learning on web interfaces using workflow-guider exploration. In 6th International Conference on Learning Representations, ICLR 2018, Vancouver, BC, Canada, April 30 May 3, 2018, Conference Track Proceedings. OpenReview.net, 2018. URL https://openreet
nett/forum?/GrryTTp3------
Pan Lu, Liang Qiu, Kai-Wei Chang, Ying Nian Wu, Song- Chun Zhu, Tanmay Rajpurohit, Peter Clark, and Ashwin Kalyan. Dynamic prompt learning via policy gradient for semi- structured mathematical reasoning. In The Eleventh International Conference on Learning Representations, ICLR 2023, Kigali, Rwanda, May 1-5, 2023. OpenReview.net, 2023. URL https://openreeveew net///ewweee//tee wttp://wwwweeeeeoorrriiiiiieeeee (ttefforrmmmmiitttyyrW....
T.J. McCabe. A complexity measure. IEEE Transactions on Software Engineering, SE-2(4): 308-320, 1976. doi: 10.109/TSE.197223337..
Grégoire Mialon, Clémentine Fourrier, Thomas Wolf, Yann LeCun, and Thomas Scialom. GAIA: a benchmark for general AI assistants. In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024. OpenReview.net, 2024.
URL http:////pppeeeeeeeeeeeeerrr//nr
OpenAl. GPT-4 technical report. CoRR, abt////3..077222 2023, doi: 10.48550/ARXIV22200 08774. URL https://doi org/10. 48550/arXiz 2383.08774.
Cheng Qian, Chi Han, Yi Ren Fung, Yujia Qin, Zhiyuan Liu, and Heng Ji. Creator: Tool creation for disentangling abstract and concrete reasoning of large language models. In Conference on Empirical Methods in Natural Language Processing, 2023. URL https: stapiissematicsccooleeo org/ httg//CrrpsII:::: 258841655 653.
Yujia Qin, Shihao Liang, Yining Ye, Kunlun Zhu, Lan Yan, Yaxi Lu, Yankai Lin, Xin Cong, Xiangru Tang, Bill Qian, Sihan Zhao, Lauren Hong, Runchu Tian, Ruobing Xie, Jie Zhou, Mark Gerstein, Dahai Li, Zhiyuan Liu, and Maosong Sun. Toollim: Facilitating large language models to master 16000+ real-world apis, 2023.
Machel Reid, Nikolay Savinov, Denis Teplyashin, Dmitry Lepikhin, Timothy P. Lillicrap, Jean-Baptiste Alayrac, Radu Soricut, Angeliki Lazaridou, Orhan Firat, Julian Schrittwieser, Ioannis Antonoglou, Rohan Anil, Sebastian Borgeaud, Andrew M. Dai, Katie Millican, Ethan Dyer, Mia Glaese, Thibault Sottiaux, Benjamin Lee, Fabio Viola, Malcolm Reynolds, Yuanzhong Xu, James Molloy, Jilin Chen, Michael Isard, Paul Barham, Tom Hennigan, Ross Mcllroy, Melvin Johnsón, Johan Schalkwyk, Eli Collins, Eliza Rutherford, Erica Moreira, Kareem Ayoub, Megha Goel, Clemens Meyer, Gregory Thornton, Zhen Yang, Henryk Michalewski, Zaheer Abbas, Nathan Schucher, Ankesh Anand, Richard Ives, James Keeling, Karel Lenc, Salem Haykal, Siamak Shakeri, Pranav Shyam, Aakanksha Chowdhery, Roman Ring, Stephen Spencer, Eren Sezener, and et al. Gemini 1.5: Unlocking multimodal understanding across millions of tokens of context. CoRR, abs/ 2024. doi: 10.48550/ ARXIV.2403.05534 05530.
URL https: http:://ooooooo/////
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&a benchmark. CoRR, abs/ 2202.1202,, 2023, doi: 10.48550 A URL https://ddo org/10. 48550/ 2w1...11..1111...... 12022.
12

---

Published as a conference paper at COLM 2025
Aymeric Roucher. GAIA.
Huggingface agent. 2024. URL
Timo Schick, Jane Dwivedi-Vi Yu, Roberto Dessi, Roberta Raileanu, Maria Lomeli, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. Toolformer: Language models can teach themselves to use tools. CoRR, /bbbs/230204761,, 2023a. doi: 10.48550/ ARXIV22302. 04761. URL httpp:://oi.i: att.://.oorgg.....e///a/a/11. art.v 2302. 04761.
Timo Schick, Jane Dwivedi-Yu, Roberto Dessi, Roberta Raileanu, Maria Lomeli, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. Toolformer: Language models can teach themselves to use tools, 2023b.
Julian Schrittwieser, Ioannis Antonoglou, Thomas Hubert, Karen Simonyan, Laurent Sifre, Simon Schmitt, Arthur Guez, Edward Lockhart, Demis Hassabis, Thore Graepel, Timo- thy P. Lillicrap, and David Silver. Mastering atari, go, chess and shogi by planning with URL
learned model. Nat., 588(7839):604-009 2020. doi: 10.1038 10.1038/S41586
https://doi org/ 1008///4118--22-033337777
Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. Reflexion: language agents with verbal reinforcement learning, In Alice Oh, Tristan Naumann, Amir Globerson, Kate Saenko, Moritz Hardt, and Sergey Levine (eds.), Advances in Neural Information Processing Systems 36: Annual Conference on Neu- ral Information Processing Systems 2023, NeurIPS 2023, New Orleans, LA, USA, Decem- ber 10 - 16, 2023, 2023. URL /ttpprrspppp/....p/p//ppp nips. cc/paperrfiiiiieeeeeee (lles/paper/2223/haatt 0e4-6//788b88226554448888886888
-bstteeeetttttttt-toooo Conf html.
Mohit Shridhar, Xingdi Yuan, Marc- Alexandee Côté, Yonatan Bisk, Adam Trischler, and Matthew J. Hausknecht. Alfworld: Aligning text and embodied environments for in- teractive learning. In 9th International Conference on Learning Representations, ICLR 2021, Virtual Event, Austria, May 3-7, 2021. OpenReview.net, 2021. URL https://openreviee.
net/forrmmidd-00000yccall
David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche, Julian Schrittwieser, loannis Antonoglou, Vedavyas Panneershelvam, Marc Lanctot, Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy P. Lillicrap, Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of go with deep neural networks and tree search. Nat., 529(7587):484 488, 2016. nature16961.
doi: 10.1038/NA (0000//NATRE1666111 URL https: /ttpss://oo// //tp::://////eee//////////se or../0..1/00000 1038/
David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, Yutian Chen, Timothy P. Lillicrap, Fan Hui, Laurent Sifre, George van den Driessche, Thore Graepel, and Demis Hassabis. Mastering the game of go without human knowledge. Nat., 354 2017. doi: 10.1038 10.138/NNATRR2DD0 NATURE24270. URL nttps://dol /r0/ 1038/nature22278.
Yifan Song, Da Yin, Xiang Yue, Jie Huang, Sujian Li, and Bill Yuchen Lin. Trial and error: Exploration-baset trajectory optimization of LLM agents. In Lun-Wei Ku, Andre Martins, and Vivek Srikumar (eds.), Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 7584-7600 Bangkok, Thailand, August 2024a. Association for Computational Linguistics. doi: 10.18653 /v1 20011633/v122224cc/aaa /2024.acl-loogg 409. URL https: / wwwp///conntottocoooooooooooooet www.oogg.orr//// orw/ -lng. 409.
Yifan Song, Da Yin, Xiang Yue, Jie Huang, Sujian Li, and Bill Yuchen Lin. Trial and error: Exploration-based trajectory optimization for 11m agents, 2024b.
Zirui Song, Yaohang Li, Meng Fang, Zhenhao Chen, Zecheng Shi, Yuan Huang, and Ling Chen. Mmac-copilot: Multi-modal agent collaboration operating system copilot. CoRR, abs/ Abs//2404188074, 2024c. doi: 1048550/ARXXI22244.110 48550/arXiv.244 2404. 18874.
URL http:::/dooooo///1////
Trase Systems. Trase AI, uncomplicated, 2025. URL
13

---

Published as a conference paper at COLM 2025
Oriol Vinyals, Igor Babuschkin, Wojciech M. Czarnecki, Michaël Mathieu, Andrew Dudzik, Junyoung Chung, David H. Choi, Richard Powell, Timo Ewalds, Petko Georgiev Junhyuk Oh, Dan Horgan, Manuel Kroiss, Ivo Danihelka, Aja Huang, Laurent Sifre, Trevor Cai, John P. Agapiou, Max Jaderberg, Alexander Sasha Vezhnevets, Rémi Leblond, Tobias Pohlen, Valentin Dalibard, David Budden, Yury Sulsky, James Molloy, Tom Le Paine, Çaglar Gülçehre, Ziyu Wang, Tobias Pfaff, Yuhuai Wu, Roman Ring, Dani Yogatama, Dario Wünsch, Katrina McKinney, Oliver Smith, Tom Schaul, Timothy Lillicrap, Koray Kavukcuoglu, Demis Hassabis, Chris Apps, and David Silver. Grandmaster level in starcraft II using multi-agent reinforcement learning. Nat., 575(7782)3350 354, 2019. doi: URL https://doii org/10.
10.1038/ 941586-019-17244
Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. Voyager: An open-ended embodied agent with large language models, 2023.
Renxi Wang, Haonan Li, Xudong Han, Yixuan Zhang, and Timothy Baldwin. Learning from failure: Integrating negative examples when fine-tuning large language models as agents. CoRR, abs/2402.11651 2024a. doi: 10.48550/ 00.4550/ARXIV2442.111 ARXIV.2402.1165. URL https: //doi. oeroi.orr//1... 111..48550/arxii 2402. 11651.
Yulong Wang, Tianhao Shen, Lifeng Liu, and Jian Xie. Sibyl: Simple yet effective agent framework for complex real-world reasoning. CoRR, abs/ abs//440.1007ss, 2024b. doi: 10. 0::50/ARXXV.2407.11077 10718. URL https://doi. http://...4550///r/..220000 10718.
Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Shaokun Zhang, Erkang Zhu, Beibin Li, Li Jiang, Xiaoyun Zhang, and Chi Wang. Autogen: Enabling next-gen LLM applications via multi-agent conversation framework. CoRR, abs/2308.08155 2023. doi: 10.48550/ ARXIV.2308.08155 URL https: /ttp://diiiooo org/10. 48550/arXiv. 23205./3..... 08155.
Peter R. Wurman, Samuel Barrett, Kenta Kawamoto, James MacGlashan, Kaushik Subrama- nian, Thomas J. Walsh, Roberto Capobianco, Alisa Devlic, Franziska Eckert, Florian Fuchs, Leilani Gilpin, Piyush Khandelwal, Varun Raj Kompella, HaoChih Lin, Patrick MacAlpine, Declan Oller, Takuma Seno, Craig Sherstan, Michael D. Thomure, Houmehr Aghabo- zorgi, Leon Barrett, Rory Douglas, Dion Whitehead, Peter Dürr, Peter Stone, Michael Spranger, and Hiroaki Kitano. Outracing champion gran turismo drivers with deep reinforcement learning. Nat., 602((896) 2022. doi: URL https://doi org/10. 1038/ 1844118--400 021-0431550 04357-7.
Zonghan Yang, Peng Li, Ming Yan, Ji Zhang, Fei Huang, and Yang Liu. React meets actre: When language agents enjoy training data autonomy, 2024.
Shunyu Yao, Howard Chen, John Yang, and Karthik Narasimhan. Webshop: To- wards scalable real-world web interaction with grounded language agents. In Sanmi Koyejo, S. Mohamed, A. Agarwal, Danielle Belgrave, K. Cho, and A. Oh (eds.), Ad- vances in Neural Information Processing Systems 35: Annual Conference on Neural Infor- mation Processing Systems 2022, NewrlPS 2022, New Orleans, LA, USA, November 28- December 9, 2022, 2022. URL http: /twp:r///ppp/pppapaa//aa nips. cc/paper files/paper /202///2222/hshh 82ad1 3ec01 cb91814ff7b8cc
html.
Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting language models, 2023a.
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, ICLR 2023, Kigali, Rwanda, May 1-5, 2023. OpenReview.net, 2023b. URL https:://ppeeeeiieeeeeeee net hfrt//ormm?? www.forrroww.....r. wi=:ww -
Lifan Yuan, Yangyi Chen, Xingyao Wang, Yi Ren Fung, Hao Peng, and Heng Ji. Craft: Cus- tomizing Iims by creating and retrieving from specialized toolsets. ArXiv, abs/ 1200..22777488 2023. URL https: / /api. semanticschol
org/ Ttg/CorrpusD 26131166666222
Aohan Zeng, Mingdao Liu, Rui Lu, Bowen Wang, Xiao Liu, Yuxiao Dong, and Jie Tang. Agenttuning: Enabling generalized agent abilities for llms, 2023.
14

---

Published as a conference paper at COLM 2025
Aohan Zeng, Mingdao Liu, Rui Lu, Bowen Wang, Xiao Liu, Yuxiao Dong, and Jie Tang. Agenttuning: Enabling generalized agent abiliitees for lims. In Lun-Wei Ku, Andre Martins, and Vivek Srikumar (eds.), Findings of the Association for Computational Linguistics, ACL 2024, Bangkok, Thailand and virtual meeting, August 11-16, 2024, pp. pp.3053-a0 3053-3077. Association URL
for Computational Linguistics, 2024. doi: 10. /0186633V/// /200///FINDNNGSSACC..C. https://doi. http:://doooog/1000 18653/v1/2024/ findings-acl 181.
Jianguo Zhang, Tian Lan, Rithesh Murthy, Zhiwei Liu, Weiran Yao, Juntao Tan, Thai Hoang, Liangwei Yang, Yihao Feng, Zuxin Liu, Tulika Awalgaonkar, Juan Carlos Niebles, Silvio Savarese, Shelby Heinecke, Huan Wang, and Caiming Xiong. Agentohana: Design unified data and training pipeline for effective agent learning, 2024a.
Kechi Zhang, Jia Li, Ge Li, Xianjie Shi, and Zhi Jin. Codeagent: Enhancing code generation with tool-integrated agent systems for real-world repo-level coding challenges, 2024b.
Shuyan Zhou, Frank F. Xu, Hao Zhu, Xuhui Zhou, Robert Lo, Abishek Sridhar, Xianyi Cheng, Tianyue Ou, Yonatan Bisk, Daniel Fried, Uri Alon, and Graham Neubig, We- barena: A realistic web environment for building autonomous agents. In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024. OvenRevie,.net, 2024a. URL httpss////ppeereiiieee
Yifei Zhou, Andrea Zanette, Jiayi Pan, Sergey Levine, and Aviral Kumar. Archer: Training language model agents via hierarchical multi-turn rl, 2024b.
15

---

Published as a conference paper at COLM 2025
Qwen22.-32B-Instruu
Qwee225-ooee--2---nnttuc
Agent Pipeline
Level
Level 2
Level 3
Avg.
Level 1
Level 2
Level 3
Avg.
No Pipeline
5.66
5.81
0.00
4.85
13.21
1.16
0.00
4.85
Sibyl
24.53
10,47
0,00
13.33
20.75
8.14
0.00
10.91
HF Agent 26.42
11.63
3.85
15.15
13.21
10.47
3.85
10.30
DynaSaur
35.85
30.23
3.85
27.88
35.85
20.93
11.54
24.24
Table 4: Performance comparison between various baseline methods and our pro- posed approach on the GATA benchmark, evaluated under two LLM backbones: Qwen2.5-2 1-33B-Innstren and Qwen2. 1iee225--oder-22 5--odde--3B--nnsrreee line where no agent pipeline employed, and the raw LLM is used. Each value represents the average exact match percentage between the predicted answers and the ground truth.
"No Pipeline" refers to the base-
Action Header
Description
submit_ Janswer get.relevant.ace. informational.web navigational web search
Submits the final answer to the given problem.
Retrieve most relevent generated actions given query.
Perform an informational web search query then return the search results. Perform navigational web search query then immediately navigate to the top result.
visit_page
Visit webpage given URL and return its text.
download file page_up
Download file given URL.
Scroll the viewport up in the current webpage and return the new viewport content.
page_down
Scroll the viewport down in the current webpage and return the new view- port content.
Find.on.page.ctrl.f
Scroll the viewport to the first occurrence of the search string.
find_next
Scroll viewport to next occurrence of search string.
find www.ived..durrr
Given url, scarches Wayback Machine and returns archived version
the url that's closest in time the desired date.
visualizer
Answer question about given image.
13
inspect.file.ss.text
Read file and return its content as Markdown text.
Table List of initial actions used in this project.
A
Additional Experiments on Open-source Large Language Models
To evaluate whether our method generalizes beyond proprietary models and remains effective when paired with models with weaker code generation abilities, tested two open-source models: Swen2.5-Coder-32--Insttee
a code-specialized, instruction-tuned general-purpose, instruction-tuned model with weaker
model, and Owwen2.532BBIInstree code generation capabilities. The results, shown in Table 4, highlight that DynaSaur works effectively with open-source models, not just proprietary LLMs. Even with a general- purpose model like Qwen2.5-32BBInsstuue DynaSaur significantly outperforms other pipelines. Surprisingly, Swwe2.5-33BB-nnee even slightly outperforms its code-specialized variant. We hypothesize that its stronger commonsense reasoning and decision-making capabilities may compensate for weaker coding skills, ultimately resulting in better overall performance.
which has weaker code generation abilities,
B Implementation Details
B.1 Initial Actions
We present the list of initial actions used in this project, along with their descriptions, in Table 5. Actions to are adopted from Microsoft's AutoGen (Wu et al., 2023).
B.2 Prompt For Qualitative Analysis
The prompt for qualitative analysis with OpenAl's o1 op-preview model is shown in Figure 6.
16

---

Published as a conference paper at COLM 2025
There "spes of MM agents: agent and agent R, Roth of work fo lowes tast and the colve
both actions from each step, while agent eitaer usee actione from implenents actions as Fython tunations If I not cufficient le.gu, when the test requires proceesing en xxlax file but 7 only containe actions for wea browsing and viausl quest ensvering).
You will be
the trajectory, egens predicted
the gold tragestory
agent predioted
report evaluating shish agent pez formu better shy. rouar on how agent ats abiliiy ixplemen own actions affects ils parformance leither ponltively or seqatisely). Your zepost should follow this d5o0 fornat:
egent trajectory, cest
Jaon
task", summery:: "trlef surmary of agent trajectory", tu surmayy"" "aciel suraary of agent ata teajectosy",
ttakk purmary"; "Briet surmary
"better eggnnt;; "Outpuz "X" or "B" depending whish osa batter",
"Explain
inssrrectly perforned worse.", merseclly perfomed betler. aqeat pezforna better
"aby bellsss "Eaplain
"ispact setion, inplerentation" new functions? hnover Yea or Ne and provide arief explanation."
ita ability inslerent
nccescary intormation:
Task [cuastion]
Gold
!gold_ans:
Gold trajectory
!gold_crag]
12_pred_ans ans]
AI agent A'a trajectory [A_pred_ Era))
agent [b_peed_ara sna]
AT agent B's trajectory [b_prwi_Les)
Figure 6: Prompt for OpenAl's ol to perform qualitative evaluation.
B.3 DynaSaur's 's System Prompt
The system prompt used for DynaSaur is shown in Figure 7.
C Additional Case Studies
We present another comparative case study of two agents: one without action implementa- tion (referred to as agent A) and one with action implementation (referred to as agent B), illustrated in Figure 8. In this scenario, both agents are provided with binary operator defined by table and tasked with finding counterexample to demonstrate that is not commutative. Successfully solving this task requires symbolic reasoning abilities. Agent A, lacking the necessary actions to address this task thoroughly, attempts reasoning within its Thought sequence but ultimately submits an incorrect answer. contrast, agent B dynami- cally generates specialized function to tackle the question. This action is general enough to solve other instances the original problem as well. This example further highlights the ad advantage of equipping agents with the ability to dynamically generate and execute actions through code to tackle a range of problems.
D Examples of Generated Actions.
We include examples of both successful and failed generated actions in Figures 9 and 10. A generation is considered successful when the action is reasonably generalizable and applicable across various contexts. Conversely, an action is considered failed generation if contains hard-coded values or is too context-specific be reused in different tasks.
17

---

Published as a conference paper at COLM 2025
Instructions
You aze an At asoistant that helsa useza selve problans. You have accesa to pychon interpreter with internet acczcs and spereting systen fmcttionlity.
ahan
task, proceed
step:
1. Thought: Beiefly explain your zeasoning
you to do next.
2. Code:
Provide Python code that implements your plan, Por exemple, to interact with or gatber intermation from seb pages, use "equeata", "bae', "lanl", or selenium" To handle or read tacel files, use "apenpyil or sled".. Io handla oz road PE2 files, ase "PUCEED"" If the rolevant sackaqas are not installed, write code to install then 'ppp". These exempies
other appropriate packages.
execuse your steps to docida your next sction.
The incesprater
retuin rasulta to you. Baviov the results carsent and previous
Continue this
until you find the solution "subnit
<deax iterations> iterations,
function
Output Pornat
at each step, outpot dSON object in the following forrat:
ttoought "Your thought here.", "cude"; "sour zyan code here."
Example:
jaon
"thouche"; need retrieve
"sode": "ingort reguoeecinnndde get Set__stn__ee
response requesta.get (orlg
swsponsw, cax Ankoiind content get hial centent ('https// hhttps//eeemple.cmmm")
Available Functions
You dee provided with acveral available functions, I2 you to discover noze zelevant Fanctiona, use get cecp_rreeeenneeee bools" function.
ectool desoriptiono>>
Quidelines for Nriting
1. Fizst, docido whother to reuse an cxisting funstion or detine nox ane.
2. boak at the list of lable tuacticns. It existing runation relevant, run get_reelevant_tooe tools' to cind
funcsions end
retrieved fanctions 4. inplementing now function, you must
still selevant, dafine function.
folloving:
The tonction is abstract, nodular, and reusable, Specifically, the function nane nost be generic (eigir
'court objects" insteed of "count apples "). The function must use parsnecera instead of hard-coded va values. The function body be self gusta ined.
Explicitly
types
hinte.
Exeeple:
(paran:
Include a one lise docwrinn describing the Sunct purpose, following PEP standards, when your function calla sultiple other functions that are not froe a chird-party library, ensure you print the ourput after each call. This sill help identidy by funation that produces inoorrect or inexgested reeults.
Guidelines for Analyzing
Output
exacution, analvae the oucout folloks:
1. -he code fallle ia to execute suogessfally and error returned, reed the error ressage and trageback cacufully, then revisw your cade in the nest step.
2. the code execuzes successfally and an cutput is returned, proceed as follows:
contains relevant any
the consider
approsches, exssple, try different data sources or vebaites, use different functions libraries, irplement awe functions necessary.
ourpu:
Important Botes
1. aben: zwading film web nake sure have eeed all the content in it don't nixe detaily
arzive the conclasion.
2. Pay actention the task specifics, as sequised to.
answer or box many digits zound
3. Basa your deciaiona on real-vorld dasa. All tasks are backed by seal-worid data, which is either available as
the incernet oz in the file provided you. Roly solely real-vorld data to generate your answerar not roly cut nowhero, este your data scurces rerg.. which webeice it fron, which Line the cile, ato.l that hunan. can varify then.
inovledge, your sode,
comnents
4. Do ROT dIve UP. Keep ts ying until you reach the maximu itoration linit.
Figure The system prompt of our DynaSaur agent framework.
18

---

Published as a conference paper at COLM 2025
Agent
Thought
commeatavv
cleck
sr all clmmetto and in Iil ioentry my comme--rample ehune toe peopary dees nor hold and moam of invoiver cormersanphe
Civvn this rbble defining on the wa 8 (h 4.4.)
biild
Action:
Eind commutacive alenezta topacation, tabiers couster saaapãa, aleenric GaEL
bEOKDO_NN web viauslize_ inace Inageot_
b
b hi
for x in opecatien cables
LE opecation Lable [n] yV to opecation tybl
provide vaboo of involvod
119,
essmples live commutiiivee Provide your amsur arpplabctical unier.
zaazis lwctted lccunter ScERpiN alenesca))
sppanital lis elemente
10% 18
repuit Sind pos, commenativv, (semettaloperatienr, pabla)
Agent
Thought:
Observation:
operation b for all clements a in S. Iill ideatity pais (a. by where this
Thought
property fills and find the subect involved these commin-csappls.
Thessbet of inoovve in complo where operiiis commuzativc (k.)).
Action:
Action:
oubritt anovez Pbyovert
sobert Finad snnoer (*b_0")
Figure& 8: A case study demonstrates the difference in problem-solving flexibility between Agent A (a variant of DynaSaur without action implementation) and Agent B (the proposed agent framework).
import fitz
def extract_text_
wetpttexx__ffo_oooe from fftdeorrfmmffiiio (file_path: str)
str:
"""Extract text from a PDF file." "** text = with fitz.open(file__atte for page in pdf: text += page. @ggegeet_eett() return text
pdf:
from openpyxl import load_workbook
def
str):
"*" Inspect data from an Excel file. now workbook = load_workbook (flemooeelleemmm==iieee.eelll) sheet workbook. active data
for row in sheet sheet.iter iows_rows (values_only=Truse data append(row) return data
Figure 9: Successful examples of generated actions in GAIA.
19

---

Published as a conference paper at COLM 2025
def calculate_food wow.eoooosslssseeeeeee (sheet) float:
n** *"Caaculatee the total sales from food items the given Excel sheet amn
total_sales = 0.0
for row in sheet. iter_rows (wi..owwwwwww values_only=True)
total_sales += (1:66](1:66)
return total_sales
def count_crustaee
str) -> int:
"** Count slides mentioning crustaceans in the provided slide text." crustaceans I'crayfish', 'isopods', 'Yeti crab", 'Spider crab
count 0
for crustacean in crustaceans: if crustacean in slide_text: count
return count
Figure 10: Failed examples of generated actions GAIA.
20


Reviews:
[{"review_id": "ynF7Kzh4Or", "reviewer": "Reviewer_P4Yg", "summary": "This paper introduces DynaSaur, a framework that enables LLM agents to dynamically create and compose arbitrary actions represented as python functions, rather than being constrained to a fixed set of predefined actions. The authors show that this approach allows agents to extend their capabilities on the fly and build a library of reusable functions over time.", "questions": "", "limitations": "", "rating": 6, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "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": "1. This paper addresses a genuine limitation in existing LLM agent frameworks- the constraint of fixed, predefined action sets\n2. Clean architecture using python functions for action abstraction and accumulation\n3. Shows meaningful performance improvements across multiple benchmarks", "reasons_to_reject": "1. The fundamental idea of using code generation for LLM agents is not novel. Prior work already explores similar concepts\n2. The action retrieval and accumulation mechanisms raise context window and memory concerns as the function set grows. No real analysis of long term usability or degradation.\n3. Limited analysis of the quality of generated functions. Many functions might be too task-specific to be truly reusable\n4. No clear comparison with strong baseline methods that use a more comprehensive set of predefined actions\n5. The paper mostly tests with GPT-4o, so we don't know if it works with other LLMs, especially open-source ones", "questions_to_authors": "1. How does the approach handle incorrect or malicious code generation? What safeguards would be necessary for real-world deployment?\n2. How well does the approach transfer to open-source LLMs with weaker code generation capabilities?\n3. Have you explored using this framework in truly interactive environments (dynamic) rather than static benchmarks?\n4. How would this architecture adapt to edge-device (phone, tablet, etc.) deployment where code execution is resource constrained?\n5. Could this system generate incorrect but plausible functions that mislead the agent? Any checks for semantic validity beyond syntactic correctness?", "extra_scores": {}}, {"review_id": "0OSmCOdFoG", "reviewer": "Reviewer_rSiz", "summary": "This paper presents a novel framework for large language model (LLM) agents that eliminates the need for a predefined action set. Instead of selecting from a static list of actions, the proposed agent dynamically generates and composes executable programs in a general-purpose programming language, enabling more flexible and adaptive decision-making. Furthermore, the agent maintains a memory of past generated actions for future reuse. Through extensive evaluations on multiple benchmarks, the framework demonstrates superior adaptability, especially in open-ended or failure-prone scenarios where fixed action sets are insufficient.", "questions": "", "limitations": "", "rating": 6, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "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": "The paper tackles a critical bottleneck in current LLM agent systems — reliance on fixed action sets — which hinders performance in dynamic, real-world environments.\n\nThe framework’s ability to generate and compose actions on-the-fly, combined with execution via a programming language, introduces a highly flexible and generalizable mechanism for agent behavior.\n\nThe accumulation and reuse of generated actions adds a valuable layer of learning and efficiency, simulating a form of long-term agent memory.\n\nThe experimental results clearly support the proposed framework, showing significant improvements over baselines on multiple benchmarks.", "reasons_to_reject": "While the idea of using program generation is compelling, it builds on existing trends in code-based agents. The framework may appear incremental unless more detailed comparisons with prior works are provided.", "questions_to_authors": "NA", "extra_scores": {}}, {"review_id": "rVBW3ghuUL", "reviewer": "Reviewer_coxz", "summary": "This paper introduces an agent framework that can dynamically create and compose actions as needed. It addresses one of the main limitations of current agentic systems: fixed and predefined tools are not enough for open-ended real-world scenarios. Experiments across multiple benchmarks show that the proposed framework significantly improves flexibility and outperforms prior methods.", "questions": "", "limitations": "", "rating": 7, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "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": "- The proposed action implementation and action accumulation mechanisms are innovative.\n\n- The experimental results are compelling, with a thorough ablation study and comprehensive results analysis.\n\n- The paper is well-structured and clearly written.", "reasons_to_reject": "- The action implementation capability relies heavily on the coding proficiency of the backend LLM, which may constrain the framework's applicability across diverse use cases.\n\n- Given that some initial actions are derived from AutoGen, it would be beneficial to include AutoGen as a baseline tool for comparison to better contextualize the proposed framework's contributions.", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "3ENkRf2xSB", "reviewer": "Reviewer_CTUg", "summary": "The paper proposes DynaSaur, an LLM agent framework which lets the system write, execute and cache its own Python functions at run-time. The framework treats code itself as the universal, dynamically expandable action space, plus persisting successful functions for reuse. Extensive experiments on GAIA plus four static QA datasets show consistent gains over strong fixed-tool baselines. The empirical evidence is generally convincing, and the manuscript is clearly written.", "questions": "", "limitations": "", "rating": 6, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "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": "- The manuscript is clearly and effectively written, making the proposed ideas and methodology easy to understand.\n\n- The conclusions presented in the paper are thoroughly supported by comprehensive experimental results, enhancing the credibility and strength of the findings.", "reasons_to_reject": "- Revision required, for example, improper citation formatting in L58-L60.\n\n- The manuscript does not adequately discuss relevant related works, eg. Voyager[1], which similarly addresses autonomous skill creation and persistent retrieval. Including a direct comparison would significantly clarify the novelty of the current approach, such as its formal MDP framework and the broader range of task evaluations.\n\n[1] Wang, Guanzhi, et al. \"Voyager: An open-ended embodied agent with large language models.\" arXiv preprint arXiv:2305.16291 (2023).", "questions_to_authors": "- (Q1) The choice of retrieval parameter k=10 lacks justification. Could the authors explain this choice? Furthermore, varying k and using different embedding models to evaluate the robustness and efficiency of the cache retrieval mechanism would enhance understanding.\n\n- (Q2) There is a concern regarding memory scalability. While the retrieval method helps keep the prompt short, the action library (Ag) appears capable of unlimited growth. Could the authors provide empirical data on the growth rate and final size of Ag after extensive usage (e.g., thousands of episodes), and clarify how this impacts retrieval latency?", "extra_scores": {}}]

Author rebuttal:

Meta-review: I recommend accepting this paper. DynaSaur presents a valuable contribution to LLM agent research by enabling dynamic action creation and composition rather than relying on predefined action sets. All four reviewers rated the paper positively (scores of 6, 6, 7, and 6), recognizing its innovative approach to agent flexibility. The authors responded thoroughly to reviewer concerns, providing additional experiments with open-source LLMs and different embedding models that demonstrated the framework's robustness across model families. While some reviewers initially questioned the novelty compared to code generation approaches, the authors clarified their unique contribution: treating a general-purpose programming language as a composable action space for agents across domains. The paper includes solid experimental validation and addresses important practical concerns about memory scalability and retrieval effectiveness. This work represents a meaningful step forward in creating more adaptable and autonomous LLM agents.
Decision: Accept