DeepAnalyze-8B runs the whole data science pipeline with no orchestrator

Autonomous data science is an old dream: go from raw tables and files to clean charts and a coherent analytical report without a human steering every step. Large language models (LLMs) moved this forward, but the usual workflow agents run on rules written out in advance. They are brittle: the moment a task steps outside the script, the whole process falls apart. In a new paper the authors propose a different route — not external scripts, but the model itself, trained to act and to improve its own decisions inside a live environment.

What the authors propose

DeepAnalyze-8B is an 8-billion-parameter agentic LLM that covers the whole cycle: data preparation, analysis, modeling, visualization, report writing, and even open-ended research where there is no single right answer. The central idea is to build into the model the two abilities without which autonomy does not happen: orchestrating the process by itself (reading the task, planning, choosing actions) and adaptively optimizing its own steps in light of feedback from the environment.

How the model works

Work with data is expressed through five simple actions that the model drives itself — with no external orchestrator:

• <Analyze> — plan the solution, reason, check its own work.
• <Understand> — make sense of what the sources contain: tables, databases, documents.
• <Code> — generate Python code for analysis, preparation and visualization.
• <Execute> — run the code and read the environment's feedback.
• <Answer> — deliver the final answer or report.

The chain repeats as many times as the task needs. When a new hypothesis comes up, the model writes code, runs it, looks at the results and corrects the plan. That is autonomous orchestration plus adaptive optimization — stitched into the behavior of the model itself.

Training: from simple to hard

The main engineering difficulty is sparse rewards and a shortage of long, realistic solution trajectories. The authors' recipe has two parts.

First, a curriculum. The model begins by building individual skills (reasoning, table understanding, code generation). Then it moves to a multi-module agentic regime with reinforcement learning: generate actions, execute code, receive a score, learn to correct behavior. Training uses GRPO with a hybrid reward: formal checks plus an LLM judge that rates the quality of reports, interactions and final answers.

Second, trajectory synthesis. Good examples of reasoning and of interaction with the environment are needed:

• Reasoning Trajectory Synthesis — chains of thought are distilled and patched up so that they keep returning to the data rather than hallucinating on top of the text.
• Interaction Trajectory Synthesis — multi-turn episodes are generated with interviewer, solver and inspector roles, then filtered by the actual changes they produce in the environment and by the quality of each step.

To make this work at scale, the authors assembled DataScience-Instruct-500K — roughly 500,000 examples, from improved reasoning traces to interaction episodes for cold start and RL. The set is open.

What the tests showed

The model was run across 12 benchmarks — from classic code tasks and TableQA to full-pipeline scenarios and open-ended research.

• Full pipeline (DataSciBench). DeepAnalyze-8B came out best among open agents and beat most proprietary systems built on ready-made pipelines. Only GPT-4o did better. One detail matters: no external frameworks, all orchestration inside the model.
• Applied tasks (DSBench, DABStep). On mixed formats (CSV/JSON/Markdown), and especially on the hard cases, the autonomous strategy consistently beats ReAct prompting and hand-written scripts.
• Deep research (DABStep-Research). On producing reports at the level of a professional analyst, DeepAnalyze-8B holds a steady advantage. Quality does not fall off on open-ended tasks — training in a real environment and rewarding the report do their work.
• Adjacent abilities. On DS-1000 (NumPy/Pandas/Matplotlib) and TableQA the model pulls up its narrower skills: above GPT-4-Turbo and GLM-4.5 on code generation, and a new high on Reasoning-Table.

Why it matters

The paper carefully shifts the emphasis away from multi-agent construction kits and hand-written scripts toward agentic LLMs, where the behavior is wired into the model itself. That saves engineering effort, cuts the dependence on prompts, makes moving between tasks easier and makes data analysis more dependable. Next comes scaling to whole ecosystems: data discovery, governance and transparency, integration into enterprise pipelines. Open code, open data and an open training methodology are a real contribution to the AI community.

💾 Code