Paper Explanined "DynaSaur: Large Language Agents Beyond Predefined Actions"
Understanding DynaSaur: A New Approach to LLM Agents
The Traditional Challenge
Current LLM agents face a significant constraint - they can only work with pre-defined actions, like using a calculator or searching the web. This is similar to having a toolkit where every tool must be specified beforehand. While this works for simple tasks, it becomes impractical for complex real-world scenarios.
The DynaSaur Innovation
DynaSaur introduces a breakthrough approach - instead of being limited to a fixed set of tools, it can create new tools on the fly. Think of it as having an AI assistant that can not only use existing tools but also craft custom tools when needed.
The system represents every action as a Python function. This choice is powerful for several reasons:
→ Python's extensive library ecosystem provides ready-made components
→ Modern LLMs excel at generating Python code
→ Functions can be easily combined and modified
The Power of Dynamic Creation
Consider a scenario where an agent needs to analyze an Excel file in a specific way. Instead of being restricted to basic Excel operations, DynaSaur can write custom Python functions to handle unique requirements. These new functions become part of its growing toolkit.
Building a Living Toolkit
What makes DynaSaur particularly innovative is its ability to learn from experience:
→ New functions are stored for future use → Complex actions can be built from simpler ones → The system becomes more capable over time
This represents a fundamental shift from static, pre-defined capabilities to an evolving, adaptive system that grows more sophisticated through use.
-The system incorporates an action retrieval scheme to manage the expanding library of Python functions. Each function is tagged with a brief docstring, then embedded for quick similarity searches. If the agent needs something new, it can query the existing actions with a textual prompt, retrieve the most relevant ones, and decide whether to reuse or define a fresh function.
Let me break this down step by step:
→ Action retrieval is the process of finding and reusing previously created functions from the system's library when needed. Here's how it works:
→ When any Python function is created, it gets a short description (docstring) that explains what it does. For example:
def filter_data(items: list) -> list:
"""Removes invalid items from a dataset based on criteria."""
# function code here
→ These docstrings are converted into numerical vectors using text embeddings (text-embedding-3-large model). This allows comparing how similar different functions are mathematically
→ When the agent needs to solve a task, it can do a text search against all stored functions by:
Converting its search query into the same type of numerical vector
Finding functions whose embedded docstrings are most similar using cosine similarity
Getting back the top k most relevant functions
→ After retrieving similar functions, the agent makes a decision:
If a retrieved function fits the need - reuse it
If nothing suitable exists - write a new function
→ This search-before-create approach helps prevent duplicate functions and builds up a reusable library of tools over time
So in simple terms - it's like having a smart search engine for previously written code, helping the agent find and reuse existing solutions before writing new ones.
Mechanism of DynaSaur agent framework
Core Components and Architecture
→ The system consists of two distinct action repositories:
Generated Actions (Ag): A dynamic collection of Python functions created by the agent
User-defined Actions (Au): Pre-built tools provided by human developers
Workflow Mechanics
→ Input Processing:
The agent π receives a specific task u
It has access to both user-defined and previously generated actions
→ Action Generation and Execution:
The agent proposes an action a, implemented as Python code
This code runs in an IPython kernel within the environment E
The kernel can interact with multiple interfaces:
Action Retriever R for accessing stored actions
Internet for web-based operations
Operating system for local computations
Feedback Loop and Learning
→ The system implements a sophisticated feedback mechanism:
Each action execution produces an observation o
This observation could be either:
Successful execution results
Error messages from failed executions
Technical Innovation
→ The architecture enables three critical capabilities:
Dynamic action creation through Python code generation
Seamless integration with external systems and resources
Continuous expansion of the action set through accumulation
This framework represents a significant advancement over traditional fixed-action systems, enabling flexible, adaptive behavior through programmatic action generation and execution.
The architecture's modular design allows for extensibility while maintaining robust error handling and feedback mechanisms - critical features for real-world AI deployment.
Action Accumulation - Core Mechanism
Action accumulation represents a sophisticated approach to dynamic function management in LLM agent systems. At its core, it implements a persistent memory architecture that enables:
→ Progressive Function Storage
Each new function created by the agent is automatically captured
Functions are stored with metadata including purpose and interface specifications
The system maintains a structured repository of accumulated actions
→ Storage Architecture
Functions are indexed using embedding-based retrieval systems
Docstrings serve as semantic descriptors for efficient search
Type hints ensure interface compatibility
A key feature is action accumulation, which stores newly generated functions. These are added to the agent’s library once they are created during a task. By saving them for future reuse, the agent becomes more capable over time and avoids reimplementing the same functionality repeatedly.
-The code snippet below shows a simple approach for creating a new Python function during a task. The function’s name and parameters are generic, and the docstring is a single line describing its purpose:
def filter_data(data_list: list, threshold: int) -> list:
"""Filters data_list items above a certain threshold."""
result = [item for item in data_list if item > threshold]
return result
This example shows how an agent programmatically creates a generic function that can filter a list of values above a given threshold. The function is self-contained, meaning it defines everything it needs without relying on external parameters, which makes it reusable in future scenarios. The docstring briefly explains the function’s purpose and assists the agent’s retrieval mechanism in matching text queries to relevant functions.
Once the code is executed, the function becomes part of the agent’s action set, allowing it to be accessed whenever similar tasks appear. The agent avoids repeatedly coding the same functionality by storing it. This approach streamlines problem-solving and preserves valuable building blocks for long-term use.
The paper’s experiments rely on the GAIA benchmark, which covers a wide variety of tasks. Traditional agent pipelines with finite, predefined actions struggle with many of GAIA’s challenges. DynaSaur’s dynamic program creation outperforms alternative methods by handling unexpected file formats, combining subtasks, and recovering from failures when existing tooling is inadequate.
Ablations show that accumulating these newly created functions significantly enhances performance. The agent systematically reuses previously defined actions for advanced tasks, and coverage analyses confirm that more stored actions correspond to greater adaptability. The system handles edge cases by spontaneously creating helpers that extend well beyond the initial human-supplied toolset.
Overall, DynaSaur demonstrates that letting an LLM implement arbitrary Python actions on the fly maximizes versatility. It sidesteps the need for enormous predefined libraries and shows how an agent can compose solutions from a growing repertoire of functions. By merging code generation, retrieval, and iterative accumulation, it achieves more open-ended and robust execution than conventional agent designs.