EvoDS: Self-Evolving Autonomous Data Science Agent with Skill Learning and Context Management

Most autonomous data science agents eventually succumb to "context explosion." As they iterate through code execution and debugging, the sheer volume of logs and data previews overwhelms their reasoning capacity. This leads to the "lost-in-the-middle" phenomenon (a degradation in performance when critical information is buried in long contexts). EvoDS attempts to break this cycle. It achieves a 28.9% relative performance improvement over the strongest open-source baseline by treating skill acquisition and context management as learned control problems.

Researchers have long sought to automate the end-to-end data science pipeline. This involves moving from raw data to cleaned features, trained models, and insightful visualizations. Current efforts center on Large Language Model (LLM) agents. These agents reason over natural language and invoke tools to navigate workflows. However, most existing agents are trapped in a cycle of repetitive trial-and-error. They rely on a static set of predefined tools and struggle to manage the massive amounts of context generated during iterative experimentation.

The core problem is twofold. First, agents cannot "learn" from successes to create new, reusable capabilities. Second, they eventually hit token limits (the maximum amount of text a model can process). Without a principled way to compress or prune history, agents lose the thread of the original objective.

The limits of static toolkits and exploding context

Existing autonomous data science agents, such as DS-Agent or DeepAnalyze, typically operate within a fixed action space (the set of possible moves an agent can make). They treat tools as static primitives. These are pre-written functions that the agent can call but cannot evolve. If an agent discovers a clever way to handle a specific edge case, that knowledge is lost once the task ends. The agent must rediscover the same solution in the next task. This prevents systematic improvement.

Compounding this is the challenge of long-horizon reasoning. Data science is inherently iterative. A single task might involve dozens of steps of code execution and debugging. As the conversation history grows, agents encounter the "lost-in-the-middle" phenomenon. Their ability to attend to critical information degrades as the context window fills up. Without active management, agents frequently encounter out-of-token (OOT) failures.

Hierarchical architectures and autonomous skill synthesis

EvoDS addresses these failures through a hierarchical multi-agent architecture . Instead of a single monolithic agent, the system employs a Manager Agent. This manager coordinates specialized sub-agents: Cleaner, Featurizer, Modeler, Visualizer, and Debugger. This decomposition reduces the decision space for each agent. The authors theoretically argue this lowers the probability of tool-selection errors.

The most significant innovation is the Autonomous Skill Acquisition (ASA) mechanism. When a sub-agent encounters a requirement its current toolkit cannot satisfy, it enters a four-stage loop: 1. Synthesis: The agent uses the underlying LLM to generate a new executable skill. This includes a name, a functional description, and the Python code implementation. 2. Verification: The agent executes the new code in a sandbox. It ensures the code works and produces valid outputs. 3. Caching: Validated skills are stored in a temporary repository. 4. Expansion: To prevent clutter, the agent only permanently adds a skill to its repertoire if it has been synthesized and verified at least $\tau=3$ times.

To manage the resulting influx of information, the Adaptive Context Compression (ACC) strategy acts as a secondary layer of control. Sub-agents distill raw execution results into concise summaries. These summaries are conditioned on the global task objective. Simultaneously, the Manager Agent is equipped with a dedicated context_summarize tool. This allows the manager to autonomously decide when the history has become too noisy to continue reasoning effectively.

Performance gains through agentic reinforcement learning

The authors optimize this ecosystem using a two-stage training scheme. They use supervised fine-tuning (SFT) followed by online reinforcement learning (RL) via Group Relative Policy Optimization (GRPO). By training the Manager and sub-agents jointly, the system learns to coordinate and manage resources efficiently.

The empirical results are significant. EvoDS achieves an average performance improvement of 28.9% over the strongest open-source baseline (DataMind-14B) across four diverse benchmarks [Table 1]. This represents a substantial leap in capability for models of similar scale. On the MLE-Dojo benchmark, EvoDS achieved a score of 0.311. This surpassed several proprietary baselines.

Crucially, the ACC mechanism appears to solve the scalability issue. While competitors like DeepAnalyze suffer sharp performance degradation as context length increases, EvoDS maintains stability .

In fact, the paper reports that EvoDS completely eliminated out-of-token failures across all tested benchmarks. Furthermore, the ASA mechanism proves its worth through cross-task reuse. The authors found a 69% cross-task reuse rate for synthesized skills .

This shows the agent builds a persistent, functional library of expertise.

Where the evolution hits a ceiling

While these metrics demonstrate high proficiency, they also reveal the boundaries of the agent's autonomy. The performance gains do not imply perfect reasoning. A qualitative failure analysis shows that the majority of errors (52%) are "Instruction Following Errors." In these cases, the agent simply fails to adhere to the specific constraints of the prompt. This suggests that the underlying reasoning engine still struggles with high-precision compliance.

There is also a notable "knowledge wall" that limits the agent's reach. In Case 3 of the study, the agent failed a complex quantitative finance task involving CVaR (Conditional Value at Risk) optimization. The authors attribute this to a deficit in domain-specific scientific knowledge. This implies that while EvoDS can learn how to use tools, it cannot spontaneously manifest deep mathematical intuition. If that knowledge is not already latent in the foundation model, the agent cannot bridge the gap.

Finally, the reliance on a teacher model (DeepSeek-V3.1) for SFT introduces a potential bottleneck. The agent's initial competence is tethered to the quality of the trajectories provided during the warm-up phase. The "evolution" begins from a baseline established by imitation.

Verdict: A blueprint for lifelong learning agents

EvoDS is a successful demonstration of how to move toward continuous learning systems. By formalizing skill acquisition and context management as part of a unified RL objective, the authors have redefined what "autonomous" means in data science.

If you are building agents for long-running, iterative workflows, the takeaway is clear. Do not rely on a static toolset. The combination of hierarchical delegation and an adaptive, learned memory is likely the only way to prevent inevitable context collapse. The code is available at https://github.com/usail-hkust/EvoDS. For those implementing similar logic, the interplay between the ASA threshold ($\tau$) and the reward penalties for context length ($P_{context}$) provides a concrete starting point for optimization.

Figures from the paper