1 Introduction↩︎

Autonomous data science agents have recently been proposed to automate a wide range of data science tasks, ranging from exploratory data analysis to predictive modeling [1], [2]. For example, ML-Master 2 [3] achieves medal-level performance on 56.4% of Kaggle competition tasks on MLE-Bench [4]. Existing methods typically leverage test-time scaling strategies, exploring numerous candidate solutions through iterative trial-and-error workflows [5], [6]. However, these strategies heavily rely on expensive analytical computation, including data processing, model training, evaluation, and workflow updating. As a result, the majority of execution time is spent on computation rather than agent reasoning. For example, ML-Master [7] spends over 86% of its execution time on model training in MLE-Bench. Such heavy computational overhead substantially limits the efficiency and scalability of autonomous data science systems.

This raises a critical question: Can we develop a transition prediction model for data science workflows, enabling agents to anticipate the effects of data science operations before performing costly computation? To this end, we introduce the concept of Data Science World Model. As illustrated in Figure 1 (a), similar to vision world models that imagine future states of the physical world [8], [9], data science world models treat the data science execution environment as the world to be modeled. Given a workflow state and a candidate data science operation, the model predicts the next environment state, including dataset and model changes, execution feedback, errors, and performance signals. Such a capability enables agents to anticipate the effects of data science operations without performing expensive real-world execution, thereby substantially accelerating both autonomous agent training and inference.

To realize this vision, we propose DSWorld, a practical data science world model framework for autonomous data science workflows. Specifically, a State Constructor transforms raw data science environments into structured state representations containing tasks, datasets, execution histories, outputs, and environment status. To balance prediction accuracy and efficiency, we further introduce a cost-aware routing mechanism. Given an agent action, a Router determines whether the action requires heavy computation. Lightweight actions are directly executed through a Compiler to ensure accuracy, while computationally expensive actions are handled by an LLM-based Simulator, which predicts the next environment state without actual execution to improve efficiency. Building upon this framework, we first perform supervised fine-tuning (SFT) for initialization and further propose Reflective World Model Optimization, a reflective reinforcement learning strategy that improves next-state prediction through error-aware reflection and iterative refinement.

Due to the lack of large-scale transition data for autonomous data science workflows, we construct DSWorld-8K, a training dataset containing 8 thousand high quality data science agent trajectories. Specifically, we first collect authentic transition trajectories from real-world autonomous data science tasks and further synthesize corresponding Chain-of-Thought (CoT) trajectories [10] to explain transition logic. However, real-world trajectories are expensive and inherently limited in scale. Therefore, we further develop a scalable data synthesis pipeline that leverages advanced LLMs and large-scale data sources from MMTU [11] to synthesize diverse workflow states and data science operations. The generated actions are executed in real environments to obtain next states, and only verified samples are retained for training. Additional CoT trajectories are synthesized to further explain transition dynamics.

We evaluate DSWorld in two practical downstream settings: (1) as a transition model for training autonomous data science agents, and (2) as a transition model for agent inference. Experimental results demonstrate that DSWorld substantially accelerates both agent training and inference while maintaining strong agent performance, achieving approximately \(14\times\) RL training speedup and \(3\)-\(6\times\) inference acceleration. In addition, we evaluate DSWorld across multiple transition prediction tasks. Experimental results show that DSWorld achieves strong predictive performance and outperforms the strongest LLM baseline by 35.6% on average on transition prediction tasks.

In summary, our contributions are as follows:

• We introduce the concept of Data Science World Models, which aim to predict the effects of data science operations in autonomous data science workflows without performing costly real-world computation.

• We propose DSWorld, a practical data science world model framework for modeling state transitions, and further introduce a reflective reinforcement learning strategy that improves transition prediction through error-aware reflection and iterative refinement.

• We develop a scalable data synthesis pipeline for constructing large-scale transition data for data science world model training.

• Extensive experiments demonstrate the effectiveness of DSWorld, achieving approximately \(14\times\) RL training speedup and \(3\)-\(6\times\) inference acceleration while maintaining strong downstream agent performance.

2 Related works↩︎

2.1 World Models↩︎

World models aim to model environment dynamics for prediction, control, and simulation, typically by predicting future states conditioned on current states and actions [8], [9], [12]. Existing world model research spans multiple domains. In the Physical World, world models are used for video generation [13], [14], 3D world generation [15], [16], and latent-space dynamics modeling [12], [17]. In the Digital World, recent works simulate webpage or software state transitions for web and GUI agents [18], [19]. Despite these advances, world modeling for autonomous data science environments remains largely unexplored. Different from prior work, we study data science world models that model environment transitions in data science workflows.

2.2 Autonomous Data Science Agents↩︎

Recently, autonomous data science agents have been proposed to automate a wide range of data science tasks [1], [2]. Existing methods mainly improve agent performance in two ways. One line of work enhances the backbone model through training. For example, ML-Agent [20] trains agents with reinforcement learning for machine learning tasks. Another line of work improves performance through test-time scaling strategies. For example, AIDE [5], ML-Master [7], AutoMLGen [6], and AutoMind [21] use search algorithms to explore candidate solutions and select the optimal one. Despite their effectiveness, these approaches heavily rely on time-consuming computation during both training and inference. Therefore, developing data science world models that can model environment transitions and enable agents to anticipate the effects of data science operations before costly computation is critical.

3 Preliminaries↩︎

4 Methodology↩︎

Figure 2 illustrates the overall framework of DSWorld. Given a data science workflow state, a State Constructor converts it into a structured representation. Based on the current state, a data science agent generates an action. The action is encoded into a dense embedding and routed to either a Compiler for real execution or an LLM-based Simulator for next-state prediction.

4.1 DSWorld↩︎

The proposed data science world model consists of four components \(\mathcal{W} = \{\mathcal{SC}, \mathcal{R}, \mathcal{C}, \mathcal{S}\}\), where \(\mathcal{SC}\) denotes the State Constructor, \(\mathcal{R}\) denotes the Router, \(\mathcal{C}\) denotes the Compiler, and \(\mathcal{S}\) denotes the LLM-based Simulator.

State Constructor. We first introduce the State Constructor, which transforms the raw execution environment into a structured state representation, formulated as \(S_t = \mathcal{SC}(E_t)\), where \(E_t\) denotes the data science environment at time step \(t\).

Specifically, the State Constructor is a rule-based program that extracts and organizes key information from the environment, including task descriptions, dataset statistics, data previews, execution environments, execution histories, intermediate outputs, and error messages. The resulting structured state representation enables DSWorld to model environment transitions in a unified manner.

Router. Given the current state, a data science agent generates an action as \(A_t = \pi(S_t)\), where \(\pi\) denotes the agent policy. To enable efficient routing, we first encode the generated action into a dense embedding representation using an action encoder. The resulting action embedding, together with the current state, is then fed into the Router for decision making. The Router determines whether the generated action can be executed efficiently as \(m_t = \mathcal{R}(S_t, A_t)\), where \(m_t \in \{\texttt{execute}, \texttt{simulate}\}\).

Intuitively, lightweight operations such as simple data manipulation or environment inspection are routed to direct execution, while computationally expensive operations, such as large-scale model training, are routed to simulation.

Compiler. If the action is inexpensive, the Compiler executes it directly: \[\begin{align} \hat{S}_{t+1} = \mathcal{C}(S_t, A_t). \end{align}\] The Compiler interacts with the actual execution environment and returns the resulting next state, including updated data states, execution outputs, and runtime feedback.

Simulator. Otherwise, the Simulator predicts the next state without real execution: \[\begin{align} \hat{S}_{t+1} = \mathcal{S}(S_t, A_t). \end{align}\] The Simulator is an LLM-based transition model that predicts execution outcomes and potential errors directly from the current state and action, thereby avoiding expensive computation.

To improve robustness against routing errors, we further impose a time limit on Compiler execution. If execution exceeds the predefined timeout threshold, the action is redirected to the Simulator for transition prediction. Thus, the overall transition process can be formulated as:

Through this hybrid execution-simulation mechanism, DSWorld balances efficiency and accuracy, enabling scalable environment interaction for autonomous data science agents.

4.2 World Model Optimization↩︎

To effectively train DSWorld and improve transition prediction quality, we adopt a two-stage post-training strategy consisting of SFT followed by Reflective World Model Optimization, a reflective reinforcement learning strategy that explicitly analyzes prediction errors and refines subsequent predictions to provide higher-quality training signals.

4.2.1 SFT Warm-Up↩︎

We first perform supervised fine-tuning on data science transition trajectories to initialize the Simulator with basic transition modeling capabilities. The SFT objective is defined as: \[\begin{align} \mathcal{L}_{\text{SFT}} = -\log \mathcal{S}_\theta(S^{'} \mid S, A), \end{align}\] where \(S\), \(A\), and \(S^{'}\) denote the current state, action, and next state, respectively.

4.2.2 Reflective World Model Optimization↩︎

After initializing DSWorld through SFT, we further optimize it with RL. Given the current state and action, the Simulator first predicts the next state as \(\hat{S}^{'} \sim \mathcal{S}_\theta(\cdot \mid S, A)\). We then compare the prediction with the ground-truth next state and generate reflection feedback: \[\begin{align} f = \mathcal{S}_\theta(\hat{S}^{'}, S^{'}), \end{align}\] where \(f\) identifies missing, incorrect, or inconsistent predictions. Conditioned on the reflection feedback, the Simulator refines its prediction as \[\begin{align} \hat{S}^{'}_{r}=\mathcal{S}_\theta(S, A, f). \end{align}\]

For each training sample, we perform \(n\) rollouts to obtain both original and refined predictions as \(\mathcal{P} = \{\hat{S}_{i}^{'}, \hat{S}_{r,i}^{'}\}_{i=1}^{n}\). We jointly optimize all trajectories using Group Relative Policy Optimization (GRPO) [22]. The overall objective is defined as:

\[\begin{align} \mathcal{L}(\theta) = & \mathbb{E} \Bigg[ \frac{1}{2n} \sum_{i=1}^{n}\Big( \mathcal{L}_{\text{clip}}(\hat{S}^{'}_i, A_i) + \mathcal{L}_{\text{clip}}(\hat{S}^{'}_{r,i}, A_{r,i}) \Big)\Bigg] \\ &- \beta_{\text{KL}} \, \mathbb{D}_{\text{KL}}(\pi_\theta \,\|\, \pi_{\text{ref}}), \end{align}\] where \[\begin{align} \mathcal{L}_{\text{clip}}(\hat{S}^{'}, A) = & \frac{1}{|\hat{S}^{'}|} \sum_{t=1}^{|\hat{S}^{'}|} \min \Bigg[ \frac{\pi_\theta(y_t|x, y_{<t})}{\pi_{\theta_{\text{old}}}(y_t|x, y_{<t})} \mathcal{A}, \\ & \text{clip}\!\left( \frac{\pi_\theta(y_t|x, y_{<t})}{\pi_{\theta_{\text{old}}}(y_t|x, y_{<t})}, 1-\varepsilon, 1+\varepsilon \right) \mathcal{A} \Bigg]. \end{align}\]

Here, \(\varepsilon\) and \(\beta_{\text{KL}}\) are hyperparameters, \(\pi_{\text{ref}}\) denotes a reference policy, and \(\mathbb{D}_{\text{KL}}\) denotes the Kullback–Leibler divergence. The advantage \(\mathcal{A}\) is computed as a group-relative advantage: \[\begin{align} \mathcal{A}_i = \frac{R_i - \mu(R)}{\sigma(R) + \epsilon}, \end{align}\] where \(R_i\) denotes the reward of the \(i\)-th rollout, \(\mu(R)\) and \(\sigma(R)\) denote the mean and standard deviation of rewards within the rollout group, and \(\epsilon\) is a small constant for numerical stability. The reward function evaluates whether the Simulator correctly predicts execution status, outputs, error information, and task performance.

4.3 Training Data Construction↩︎

Due to the lack of state transition data for data science workflows, we construct a high-quality training dataset, DSWorld-8K, consisting of both real and synthesized state transitions. To support transition reasoning learning, we additionally synthesize reasoning explanations for each transition. Each sample is represented as \((S, A, S^{'}, \tau)\), where \(S\) is the current state, \(A\) is the action, \(S^{'}\) is the next state, and \(\tau\) is the reasoning trajectory explaining the transition process.

4.3.1 Real-World Transition Collection↩︎

We first leverage existing autonomous data science agents and real-world data science benchmarks to collect authentic environment transition trajectories. Specifically, we run agents on real-world tasks and record the resulting environment transitions as \((S, A, S^{'})\). Based on the collected transitions, we further prompt an advanced LLM to synthesize corresponding CoT reasoning trajectories: \[\begin{align} \tau = p_\eta(S, A, S^{'}), \end{align}\] where \(p_\eta\) denotes the LLM.

4.3.2 Synthetic Transition Construction↩︎

However, collecting real-world transition data is expensive and inherently limited in scale. To enable scalable training, we further design a synthetic pipeline for generating transition trajectories.

State Synthesis. To construct diverse environment states, we leverage datasets from MMTU [11], which contains over 60K real tables across diverse domains, providing rich and heterogeneous data science environments. For each sample, we randomly select a dataset and construct the corresponding state using the State Constructor as \(S = \mathcal{SC}(E)\), where \(E\) denotes the sampled data science environment. The constructed state includes task descriptions, dataset statistics, and data previews.

Action Synthesis. To generate diverse actions, we construct data operation and execution error libraries based on the NumPy and Pandas ecosystems. Each entry contains an operation or error type, textual descriptions, and code examples. For each synthesized sample, we randomly sample a data operation \(o\), an error type \(e\), and an execution status \(r \in \{\texttt{success}, \texttt{failure}\}\). Conditioned on the current state and sampled attributes, the LLM synthesizes executable actions: \[\begin{align} A \sim p_\eta(A \mid S, o, e, r), \end{align}\] where \(A\) denotes the generated action. This strategy enables the training data to cover both successful executions and diverse execution failures in data science workflows.

Ground-Truth Construction and Verification. After generating executable actions, we execute the synthesized action using the Compiler to obtain the corresponding next state: \[\begin{align} S^{'} = \mathcal{C}(S, A). \end{align}\]

The resulting transition captures actual execution outcomes, including updated data states, execution outputs, runtime logs, and error messages. To ensure data quality, we further verify whether the execution results satisfy the intended execution status and error constraints: \[\begin{align} \text{Verify}(S, A, S^{'}, e, r). \end{align}\]

Only valid and consistent samples are retained. For each verified transition tuple \((S, A, S^{'})\), we further prompt the LLM to synthesize the corresponding CoT reasoning trajectory: \[\begin{align} \tau = p_\eta(S, A, S^{'}) \end{align}\] Combining both real-world and synthesized trajectories, we construct a final training dataset containing approximately 8K transition samples with corresponding reasoning trajectories.

5 Experiments↩︎

This section aims to answer the following research questions: RQ1: How effective is DSWorld on data science transition prediction tasks? RQ2: Can DSWorld effectively support the training and inference of agents? RQ3: Is the proposed optimization strategy effective for training DSWorld? RQ4: How do training data scale and model scale affect DSWorld performance?

5.1 Experimental Setup↩︎

Benchmarks. We evaluate DSWorld on the Predict-before-Execute [23] benchmark to assess its performance ranking (PR) capability. In addition, since no benchmark exists for data science world models, we construct 540 evaluation tasks to measure execution success prediction (ESP), error type prediction (ETP), execution result similarity (ERS), execution keyword matching (EKM), and performance prediction (PP). Furthermore, we evaluate DSWorld as an environment simulator for autonomous data science agents on MLE-Bench Lite [4]. Detailed benchmark descriptions are provided in Appendix 7.1.

Metrics. For PR, ESP, ETP, and EKM, we use accuracy as the evaluation metric. For ERS, we use embedding cosine similarity, while for PP, we use \(1-\text{RMSE}\). For MLE-Bench Lite, we report the medal rate and overall score. Detailed metric descriptions are provided in Appendix 7.2.

Baselines. Since no existing methods are specifically designed for data science world modeling, we compare DSWorld with two categories of baselines: (1) advanced LLMs, including Llama-3.1-8B [24], Qwen3-8B [25], DeepSeek 3.2 [26], GPT-4o [27], and o4-mini; and (2) trained LLM baselines, including Llama-3.1-8B-sft, Llama-3.1-8B-grpo, Qwen3-8B-sft, and Qwen3-8B-grpo.

Implementation Details. DSWorld employs Qwen3-8B as the simulator backbone. The encoder is implemented using Harrier OSS v1 0.6B [28], while the Router is implemented as a two-layer MLP. Detailed implementation settings are provided in the Appendix 7.3.

5.2 Transition Prediction Performance (RQ1)↩︎

Table 1 presents the overall performance comparison between DSWorld and strong LLM baselines across multiple prediction tasks. Overall, DSWorld consistently achieves the best performance on nearly all evaluation dimensions, improving the average performance by 35.6% over the strongest baseline, o4-mini. These results demonstrate the effectiveness of DSWorld for modeling data science environment transitions.

Specifically, compared with general-purpose LLMs, DSWorld substantially improves prediction accuracy on execution-related tasks. Compared with the strongest baseline, DSWorld achieves improvements of 33.4%, 57.6%, 71.5%, and 50.5% on these tasks, respectively. These results indicate that DSWorld can more accurately model execution dynamics and environment transitions in data science workflows. In addition, both SFT- and GRPO-trained models significantly outperform their untuned backbones, validating the effectiveness of the proposed synthetic transition data for training.

For performance-related tasks, DSWorld achieves competitive results with the best-performing methods. DSWorld achieves the best performance prediction score and the second-best performance ranking result. We attribute this to the fact that these tasks require stronger reasoning about machine learning algorithms, task characteristics, and evaluation metrics, making them more difficult to learn. In contrast, execution-related prediction tasks exhibit more explicit execution patterns and environment dynamics, which are easier for DSWorld to model effectively.

5.3 Training Agents with DSWorld (RQ2)↩︎

To investigate whether DSWorld can effectively support agent training, we use 105 machine learning tasks from MLE-Dojo [29] to train agents under the same ReAct [30] framework for 10 RL steps and evaluate them on MLE-Bench Lite. As shown in Table 2, the agent trained with DSWorld achieves strong performance and remains competitive with Compiler-based training, while outperforming training with DeepSeek 3.2 as the simulator. Notably, the DSWorld-trained agent also outperforms the stronger Qwen3-14B baseline despite using Qwen3-8B as the backbone. These results demonstrate that DSWorld can serve as an effective training environment for autonomous data science agents.

More importantly, Figure 3 also compares the training efficiency of different simulators. Compiler-based training with real execution is significantly more time-consuming, whereas DSWorld achieves approximately \(14\times\) acceleration while maintaining comparable downstream performance. Although Compiler-based training achieves slightly better final performance, the gap is relatively small compared with the substantial efficiency gain of DSWorld. These results further demonstrate the efficiency and scalability advantages of DSWorld.

5.4 Agent Inference with DSWorld (RQ2)↩︎

We further investigate whether DSWorld can serve as an efficient inference environment for search-based autonomous data science agents. Specifically, we use the Compiler, DeepSeek 3.2, and DSWorld as the executers of search-based agents, including AIDE, ML-Master, and AutoMLGen. Table 3 presents the performance and efficiency results on MLE-Bench Lite. Overall, DSWorld consistently achieves competitive downstream performance while substantially reducing inference time across different agents and backbone models.

Specifically, compared with Compiler-based execution, DSWorld achieves approximately 3-6\(\times\) acceleration while largely preserving downstream performance. In contrast, although directly using DeepSeek 3.2 also reduces execution time, it leads to severe performance degradation due to inaccurate execution feedback and hallucinated environment transitions. These results indicate that DSWorld can effectively simulate real environment transitions and provide sufficiently accurate execution feedback. Since search-based agents require evaluating many candidate solutions, replacing expensive real execution with efficient world model simulation can significantly reduce inference overhead while preserving search quality.

5.5 Ablation Study (RQ3)↩︎

To investigate the effectiveness of the proposed training strategy, we compare different variants of DSWorld. The results are shown in Table 1, where Qwen3-8B-sft and Qwen3-8B-grpo denote models trained with only SFT and with additional GRPO-based RL, respectively. Compared with the original Qwen3-8B backbone, Qwen3-8B-sft achieves substantial improvements across all tasks, improving the average performance by 37.5%. These results demonstrate the effectiveness of the proposed data synthesis pipeline and supervised world model training. In particular, Qwen3-8B-sft significantly improves execution-related prediction tasks, indicating that supervised fine-tuning on large-scale transition trajectories enables the model to effectively learn data science environment dynamics.

Building upon Qwen3-8B-sft, Qwen3-8B-grpo further improves the overall performance by 1.05%, demonstrating the effectiveness of RL for improving prediction quality through iterative refinement. Furthermore, DSWorld achieves the best overall performance across nearly all evaluation dimensions. Compared with Qwen3-8B-grpo, DSWorld further improves the overall performance by 1.3%, and improves by 2.36% over Qwen3-8B-sft, demonstrating the effectiveness of Reflective World Model Optimization. By introducing reflective error-aware optimization, DSWorld can iteratively refine transition reasoning and improve next-state prediction quality, enabling more accurate simulation of data science environment transitions.

5.6 Further Analysis (RQ4)↩︎

In this section, we further investigate the effects of training data size and model scale on DSWorld. Figure 4 shows that DSWorld consistently benefits from more training data and larger backbone models. Specifically, as the training data size increases from 0.1k to 6.4k samples, the performance of both Llama3.1-8B and Qwen3-8B steadily improves, demonstrating the importance of large-scale transition data for world model learning. Moreover, scaling the Qwen3 backbone from 0.6B to 14B parameters also leads to significant performance gains, suggesting that stronger LLMs provide more accurate environment transition modeling and reasoning capabilities. Overall, these results indicate that DSWorld scales favorably with both data and model size, highlighting its potential for further improvement with larger-scale training resources.

6 Conclusion↩︎

In this paper, we present DSWorld, a learned transition model for data science workflows. By modeling environment transitions conditioned on the current state and actions, DSWorld enables agents to anticipate the effects of data science operations before performing costly computation during both training and inference. To support effective world model learning, we construct a large-scale trajectory dataset combining real and synthetic transition data, and further propose Reflective World Model Optimization to improve prediction quality through reflective reinforcement learning. Extensive experiments demonstrate that DSWorld achieves strong predictive performance across diverse transition prediction tasks while substantially accelerating autonomous agent training and inference.

Limitations↩︎

Despite the promising results, this work still has several limitations. First, DSWorld currently focuses on modeling data science transitions and does not explicitly model external tool-call transitions in autonomous agent workflows. Second, the quality of transition prediction remains constrained by the capability of the underlying LLM simulator, which may occasionally produce inaccurate predictions in complex workflow scenarios. Third, synthesized trajectories may still exhibit distribution gaps compared with real-world autonomous workflows, potentially affecting generalization performance. We leave these limitations for future work.

7 Experimental Setup↩︎

7.1 Benchmarks↩︎

• Predict-before-Execute [23]. Predict-before-Execute is a performance ranking benchmark containing 28 machine learning problems and 18,438 ranking tasks in total. Each task consists of a machine learning problem together with several candidate code solutions, and the model is required to predict which solution achieves better performance without executing the code. Since evaluating all 18,438 tasks is computationally expensive, we randomly sample 20 performance ranking tasks for each machine learning problem, resulting in 471 evaluation tasks in total.

• Synthetic Evaluation Tasks. Since there are currently no dedicated benchmarks for data science world modeling, we construct 540 evaluation tasks using our training data construction pipeline. To avoid data leakage, we use additional data sources from DABench [31] and MLE-Dojo [29], which are different from the data sources used for synthesized training transitions. The tasks evaluate five core prediction capabilities:

  Execution Success Prediction (ESP). Predict whether a code action can execute successfully under the current environment state.

  Error Type Prediction (ETP). Predict the execution error category for failed code actions, such as syntax, runtime, or data-related errors.

  Execution Result Similarity (ERS). Evaluate the semantic similarity between predicted execution outputs and ground-truth execution results.

  Execution Keyword Matching (EKM). We use DeepSeek 3.2 to extract several keywords from the ground-truth execution results and evaluate whether the predicted execution outputs contain these keywords.

  Performance Prediction (PP). Given a machine learning task and a code solution, predict the resulting task performance.

• MLE-Bench Lite [4]. MLE-Bench is a machine learning benchmark that requires agents to autonomously solve real-world machine learning tasks. Due to the high computational cost, we use MLE-Bench Lite for evaluation and further remove one task with a dataset exceeding 100GB. The final evaluation set contains 21 tasks.

7.2 Metrics↩︎

For PR, ESP, and ETP, we use accuracy as the evaluation metric: \[\begin{align} \text{Score} = \frac{1}{N} \sum_{i=1}^{N} \mathbf{1}(\hat{y}_i = y_i), \end{align}\] where \(\hat{y}_i\) and \(y_i\) denote the predicted and ground-truth labels, respectively.

For EKM, we use keyword matching accuracy to measure the proportion of correctly predicted keywords: \[\begin{align} \text{Score} = \frac{1}{N} \sum_{i=1}^{N} \frac{|K_i^{p} \cap K_i^{g}|}{|K_i^{g}|}, \end{align}\] where \(K_i^{p}\) and \(K_i^{g}\) denote the predicted and ground-truth keyword sets, respectively.

For ERS, we use embedding cosine similarity between predicted outputs and ground-truth execution results: \[\begin{align} \text{Score} = \frac{\mathbf{e}_{p}^{\top}\mathbf{e}_{g}}{\|\mathbf{e}_{p}\|\|\mathbf{e}_{g}\|}, \end{align}\] where \(\mathbf{e}_{p}\) and \(\mathbf{e}_{g}\) denote the embeddings of the predicted and ground-truth execution outputs, respectively. The embeddings are extracted using Harrier OSS v1 0.6B.

For PP, we use \(1-\text{RMSE}\): \[\begin{align} \text{Score} = 1 - \sqrt{ \frac{1}{N} \sum_{i=1}^{N} (\hat{s}_i - s_i)^2 }, \end{align}\] where \(\hat{s}_i\) and \(s_i\) denote the predicted and ground-truth task performance scores, respectively.

For MLE-Bench Lite, we follow the official evaluation protocol and report the percentages of Gold, Silver, Bronze, and Any medals, as well as the percentage of tasks achieving above-median leaderboard performance. In addition, following MLE-Dojo, we compute a normalized leaderboard score ratio and use \(1-\text{ratio}\) as the final score metric.

7.3 Implementation Details.↩︎

DSWorld employs Qwen3-8B as the simulator backbone. The encoder is implemented using Harrier OSS v1 0.6B [28], while the Router is implemented as a two-layer MLP with hidden dimensions of 256 and 64, trained on collected code-execution time pairs. Data synthesis is performed using DeepSeek 3.2. For real-world transition collection, we use tasks from DACode [32] together with the ReAct framework. For synthesized transitions, we use data sources from MMTU [11], a large-scale multi-task table understanding and reasoning benchmark containing 28,136 table-centric questions over 61,763 real tables across 25 task categories, providing diverse data science environments and analytical workflows. For all experiments, each task is evaluated over three independent runs, and we report the mean and variance of the results.

For SFT, we train the model for 5 epochs with a batch size of 32 and a learning rate of \(1\times10^{-5}\). For RL, the reward function for execution prediction tasks is defined as the average score across the four execution prediction objectives: \[\begin{align} R_{\text{exec}} = \frac{1}{4}( R_{\text{ESP}} + R_{\text{ETP}} + R_{\text{ERS}} + R_{\text{EKM}}). \end{align}\] For performance prediction tasks, the reward function is defined as: \[\begin{align} R_{\text{perf}} = 1 - (\hat{s} - s)^2, \end{align}\] where \(\hat{s}\) and \(s\) denote the predicted and ground-truth performance scores, respectively.

We use a rollout size of 8 and a learning rate of \(1\times10^{-6}\) for 200 training steps. The maximum response length is set to 16K tokens. All experiments are conducted using VeRL [33] on 4 NVIDIA A800 GPUs.

8 Additional Experiments↩︎

8.1 Cross-Environment Generalization↩︎

In this section, we evaluate the robustness of DSWorld across different execution environments, including Ubuntu, CentOS, and Windows systems. As shown in Table 4, DSWorld achieves consistently strong performance across all environments, with only minor variations in both execution prediction and performance prediction metrics. In particular, Ubuntu achieves the best overall average performance, while CentOS and Windows remain highly competitive. These results demonstrate that DSWorld generalizes well across heterogeneous operating environments and is not overly dependent on a specific execution platform.

8.2 Evaluating DSWorld as a Training Environment on Additional Benchmark↩︎

To further evaluate the effectiveness of DSWorld as a training environment, we conduct additional experiments on 100 machine learning tasks from DACode [32]. Specifically, we train autonomous data science agents under the same ReAct framework using different simulators, including DeepSeek 3.2, real execution through the Compiler, and DSWorld.

Table 5 presents the results. Overall, agents trained with DSWorld achieve the best average performance among all settings. Consistent with the findings in Section 5.3, DSWorld-trained agents outperform the stronger Qwen3-14B baseline while only using Qwen3-8B as the backbone model. Compared with training using DeepSeek 3.2 as the simulator, DSWorld substantially improves downstream task performance, demonstrating stronger environment transition modeling capabilities. In addition, DSWorld achieves performance comparable to Compiler-based training while avoiding expensive real execution during training. These results further demonstrate that DSWorld can serve as an effective and scalable training environment for autonomous data science agents.

9 Task Examples↩︎

In this section, we provide two representative examples from our constructed evaluation tasks. The first example evaluates execution-level transition prediction, where the model predicts detailed execution outputs generated by data analysis code. The second example evaluates performance prediction, where the model estimates the downstream task performance of a machine learning solution without actual execution.

10 Case Studies↩︎

In this section, we present a representative case study to illustrate the prediction capabilities of DSWorld on real-world machine learning tasks. The example shows that DSWorld can effectively predict both execution outcomes and downstream task performance without actual code execution.

Specifically, DSWorld correctly predicts that the generated solution can execute successfully and produce a valid submission file. In addition, DSWorld accurately estimates the performance, achieving a predicted score of 0.528 compared with the ground-truth score of 0.543. The generated reasoning trajectory further demonstrates that DSWorld can analyze multiple aspects of the machine learning pipeline, including dataset characteristics, preprocessing strategies, feature representations, model selection, and potential performance limitations. For example, DSWorld recognizes that the TF-IDF and Logistic Regression pipeline provides a strong text classification baseline while also identifying its limitations in handling complex linguistic phenomena such as negation and sarcasm. These results demonstrate that DSWorld can capture high-level relationships between code implementations and downstream task performance, which is important for efficient autonomous data science agent planning and search.

References↩︎

---

1. Corresponding author.↩︎