agentic-llm-data-science

name	agentic-llm-data-science
title	DeepAnalyze: Agentic LLMs for Autonomous Data Science
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2510.16872
keywords	["agentic LLM","autonomous analytics","data science","curriculum learning","end-to-end workflows"]
description	Train agentic LLMs through curriculum-based learning to autonomously execute full data science workflows from raw data to analysis reports, enabling 8B models to match proprietary systems.

Technique: Curriculum-Based Agentic Data Science Training

Traditional data science workflows require chaining multiple tools (SQL, visualization, statistical testing), but most LLMs lack the emergent ability to coordinate these tools autonomously. DeepAnalyze addresses this by training models through a curriculum that progressively teaches data science competencies: from simple data QA through specialized analytics to open-ended research.

Rather than single-task supervised fine-tuning, the curriculum approach mirrors how human data scientists learn—starting with basic skills, building to intermediate analysis, and finally solving complex research questions. This enables even 8B models to achieve performance comparable to proprietary larger systems.

Core Concept

Curriculum-based agentic training operates on three levels:

• Level 1 (Data QA): Answer specific questions about provided data
• Level 2 (Specialized Analytics): Execute targeted analyses (correlation, clustering, forecasting)
• Level 3 (Open-Ended Research): Conduct comprehensive exploratory analysis without predefined constraints

This progression develops interconnected capabilities: basic QA teaches data handling, specialized tasks teach analysis patterns, open-ended tasks teach hypothesis formation and verification.

Architecture Overview

• Tool Executor: SQL, Python (pandas, sklearn), visualization wrappers
• Query Planner: Decompose user request into tool sequences
• Tool Invoker: Map planned steps to actual tool calls with parameter binding
• Result Interpreter: Parse tool outputs and decide on next steps
• Report Generator: Synthesize findings into clear narrative
• Curriculum Scheduler: Progressively mix training data from three difficulty levels

Implementation Steps

The key insight is structuring training data as progressively harder tasks that build on earlier capabilities. This example shows how to implement the three-level curriculum.

from dataclasses import dataclass
from typing import List, Callable, Dict
import random

@dataclass
class DataScienceTask:
    """Represents a data science training task."""
    level: int  # 1=QA, 2=specialized, 3=open-ended
    question: str
    dataset: Dict  # Data dictionary
    required_tools: List[str]  # SQL, Python, viz, etc.
    expected_output: str
    difficulty_score: float  # 0.0 to 1.0


class CurriculumDataScienceTrainer:
    """
    Trains agentic LLM through curriculum of increasing difficulty.
    """

    def __init__(self, model, tool_executor):
        self.model = model
        self.executor = tool_executor
        self.qa_tasks = []      # Level 1: Basic QA
        self.specialized_tasks = []  # Level 2: Targeted analysis
        self.research_tasks = []     # Level 3: Open-ended

    def create_curriculum_batch(
        self,
        batch_size: int,
        epoch: int,
        total_epochs: int
    ):
        """
        Mix tasks from all three levels with curriculum weighting.
        Early epochs: more QA, mid: more specialized, late: more research.
        """
        
        qa_weight = (,  - epoch *  / total_epochs)
        spec_weight =  * (epoch / total_epochs)
        research_weight =  - qa_weight - spec_weight

        
        batch = []
        num_qa = (batch_size * qa_weight)
        num_spec = (batch_size * spec_weight)
        num_research = batch_size - num_qa - num_spec

        batch.extend(random.sample(.qa_tasks, (num_qa, (.qa_tasks))))
        batch.extend(random.sample(.specialized_tasks,
                                   (num_spec, (.specialized_tasks))))
        batch.extend(random.sample(.research_tasks,
                                   (num_research, (.research_tasks))))

         batch

     ():
        
        task = DataScienceTask(
            level=,
            question=,
            dataset=.sample_dataset(),
            required_tools=[],
            expected_output=,
            difficulty_score=
        )
         task

     ():
        
        task = DataScienceTask(
            level=,
            question=(
                     ),
            dataset=.sample_dataset(),
            required_tools=[, , ],
            expected_output=,
            difficulty_score=
        )
         task

     ():
        
        task = DataScienceTask(
            level=,
            question=(
                     ),
            dataset=.sample_dataset(),
            required_tools=[, , , ],
            expected_output=,
            difficulty_score=
        )
         task

     ():
        
        
        prompt = 

        
        response = .model.generate(prompt)

        
        results = .executor.execute_plan(response, task.dataset)

        
        accuracy = .evaluate_output(results, task.expected_output)

        
        loss =  - accuracy
         loss


 ():
    
    trainer = CurriculumDataScienceTrainer(model, executor)

    
     _  ():
        trainer.qa_tasks.append(trainer.level1_qa_task())
        trainer.specialized_tasks.append(trainer.level2_specialized_task())
        trainer.research_tasks.append(trainer.level3_research_task())

     epoch  (num_epochs):
        
        batch = trainer.create_curriculum_batch(
            batch_size,
            epoch,
            num_epochs
        )

        epoch_loss = 
         task  batch:
            loss = trainer.train_step(task)
            epoch_loss += loss

        ()

The curriculum is key: starting with simple QA teaches basic data handling, specialized tasks teach analysis patterns, and open-ended research forces integration of all skills. This mirrors human learning and produces more capable generalist agents.

Practical Guidance

Task Level	Training Focus	Typical Questions
Level 1 (QA)	Data fluency	"How many records?" "What's the max value?"
Level 2 (Specialized)	Analysis patterns	"Find correlations," "Cluster customers," "Forecast trends"
Level 3 (Research)	Integration	"Conduct comprehensive analysis," "Identify opportunities," "Explain patterns"

When to Use:

• Building autonomous data science agents for enterprise analytics
• You have diverse data science tasks of varying complexity
• You want to develop end-to-end reasoning without orchestration frameworks
• Cost matters (8B models > larger proprietary systems)

When NOT to Use:

• Domain-specific data science (medical, legal) needing specialized tools
• Real-time streaming analytics (curriculum training is offline)
• Single-task optimization (curriculum overhead not justified)

Common Pitfalls:

• Imbalanced curriculum: too much early-stage task repetition → slow convergence
• Curriculum progression too fast → model skips necessary skills
• Task difficulty mismatch with level (Level 2 shouldn't be as hard as Level 3)
• Not validating curriculum order (test different orderings on dev set)
• Over-relying on tool fidelity (poor tool executors → poor training signal)

Reference

DeepAnalyze: Agentic LLMs for Autonomous Data Science