--- license: mit language: - en - zh tags: - data-engineering - benchmark - agent - sql - text2sql - pyspark - flink - llm-evaluation size_categories: - n<1K task_categories: - text-generation configs: - config_name: default data_files: - split: train path: tasks.jsonl - config_name: hivesql data_files: - split: train path: hivesql.jsonl - config_name: mysql data_files: - split: train path: mysql.jsonl - config_name: prestosql data_files: - split: train path: prestosql.jsonl - config_name: pyspark data_files: - split: train path: pyspark.jsonl - config_name: flinksql data_files: - split: train path: flinksql.jsonl --- # DataClawEval [![Tasks](https://img.shields.io/badge/Tasks-100-blue)](tasks) [![Evaluated Models](https://img.shields.io/badge/Evaluated_Models-16-green)](#paper-results) [![License](https://img.shields.io/badge/License-MIT-yellow)](LICENSE) [![Paper](https://img.shields.io/badge/📄_Paper-PDF-red)](DataClawEval__A_Benchmark_for_Data_Engineering_Agents_in_Real_Industrial_Harness.pdf) [![arXiv](https://img.shields.io/badge/arXiv-2607.28033-b31b1b.svg)](https://arxiv.org/abs/2607.28033) **An executable benchmark for end-to-end data-engineering agents in industrial environments.** DataClawEval measures an autonomous agent's ability to inspect data, implement and debug pipelines, and materialize correct artifacts in realistic data-engineering workflows. It contains 100 production-grounded tasks across five execution engines: PySpark, MySQL, HiveSQL, PrestoSQL/Trino, and FlinkSQL. Each task runs in an isolated Docker sandbox and is evaluated by a case-specific, deterministic, rule-based grader. --- ## What's Inside - **Production-grounded tasks** — 100 end-to-end tasks reconstructed from production-grade implementations written by professional enterprise data engineers and validated through execution checks, expert perturbations, and expert review. - **Batch and streaming coverage** — batch transformations in PySpark, MySQL, HiveSQL, and PrestoSQL/Trino, plus streaming-oriented FlinkSQL tasks involving event time, watermarks, windows, joins, and aggregations. - **End-to-end agent workflows** — schema inspection, data exploration, implementation, execution, debugging, output validation, and artifact materialization. - **Artifact- and process-oriented grading** — task-specific graders assess executable outputs and engineering behaviors such as exploration, execution efficiency, and self-verification. - **Reproducible environments** — every run starts in a fresh container with task-specific data, services, execution engines, and deterministic initialization. - **Flexible agent integration** — run evaluations with the `codebuddy`, `claude-code`, or `codex` backend. The paper evaluates 16 model configurations through a unified CodeBuddy scaffold. - **Batch experiments** — evaluate one or more engines in parallel and generate combined reports. ### Task Suite | Execution engine | Workload | Tasks | |------------------|----------|------:| | PySpark | Batch (`offline-compute`) | 20 | | MySQL | Batch (`offline-compute`) | 20 | | HiveSQL | Batch (`offline-compute`) | 28 | | PrestoSQL/Trino | Batch (`offline-compute`) | 12 | | FlinkSQL | Streaming (`online-compute`) | 20 | | **Total** | | **100** | The suite is also balanced between 50 English and 50 Chinese task prompts and covers five business domains: Ops & Resource Governance (30), Data Analytics & User Growth (30), Security & Risk Control (16), Content, Community & Dev-Efficiency (14), and Advertising & Marketing (10). Each task lives in `tasks////` and contains: - `task.md` — the natural-language request and metadata such as timeout and engine - `init/` — initialization or verification assets; batch tasks initialize tables here, while FlinkSQL tasks generally define generated streaming inputs in the submitted SQL - `gt/` — the reference implementation and task-specific `grade.py` used during evaluation --- ## How It Works For every model–task run, the harness: 1. Starts a fresh Docker container from the configured `DOCKER_IMAGE`. 2. Starts the services required by the selected engine and initializes task-specific inputs. 3. Prepares the agent workspace with the task prompt and engineering tools. 4. Runs the selected agent backend and records its execution trajectory. 5. Loads `gt/` after agent execution and runs the task-specific grader in the same container. 6. Collects the submitted solution files, workspace snapshot, scores, usage data, and execution transcript into `output/`, then removes the container. --- ## Requirements | Component | Requirement | |-----------|-------------| | Docker | Docker CLI and a running daemon | | Python | Python 3.11 on the host; the scripts invoke `python3.11` | | Storage | Enough free space for the multi-engine image and task outputs | | Model access | Credentials and network access for the selected agent backend | The evaluation image provides a ready-to-use multi-engine environment with Spark 3.5.0, Flink 1.18.1, Trino 435, MySQL, a Hive Metastore, Python 3.11.13, and the supported agent runtimes. --- ## Quick Start ### 0. Verify prerequisites Make sure Docker is installed and running, and that Python 3.11 is available. ```bash docker version # verifies the Docker CLI and daemon connection python3.11 --version # Python 3.11 is required ``` ### 1. Install Python dependencies ```bash python3.11 -m pip install -r requirements.txt ``` ### 2. Get the evaluation image You have two options. **Option A — Pull the prebuilt image (recommended)** Skip the local build and pull the ready-made image from the registry: ```bash docker pull dicemy/dataclaweval:v1.0 docker tag dicemy/dataclaweval:v1.0 dataclaw-eval:v1.0 # match DOCKER_IMAGE in .env ``` > The default `DOCKER_IMAGE` in `.env` is `dataclaw-eval:v1.0`. Either retag the pulled image > as shown above, or set `DOCKER_IMAGE=dicemy/dataclaweval:v1.0` in your `.env`. **Option B — Build locally** `prepare.sh` vendors the installed CodeBuddy Agent SDK and builds the `dataclaw-eval:v1.0` evaluation image. ```bash bash script/prepare.sh ``` ### 3. Configure credentials Copy the example env file and fill in the values for the agent backend you plan to use. ```bash cp .env.example .env ``` Then edit `.env`: ```ini DOCKER_IMAGE=dataclaw-eval:v1.0 # CodeBuddy auth (required for the `codebuddy` harness) CODEBUDDY_AUTH_TOKEN= CODEBUDDY_API_KEY= CODEBUDDY_INTERNET_ENVIRONMENT=ioa # public | internal | ioa # OpenRouter (required for `claude-code` and `codex` harnesses) OPENROUTER_API_KEY= OPENROUTER_BASE_URL=https://openrouter.ai/api/v1 ``` > Get a CodeBuddy API key: overseas → · > China → · iOA (Tencent staff) → > . Set > `CODEBUDDY_INTERNET_ENVIRONMENT` to match your account type. ### 4. Run the evaluation ```bash # Run a single execution engine bash script/run_batch.sh -P # PySpark bash script/run_batch.sh -M # MySQL bash script/run_batch.sh -H # HiveSQL bash script/run_batch.sh -F # FlinkSQL bash script/run_batch.sh -PR # PrestoSQL/Trino # Run workload groups bash script/run_batch.sh -offline # PySpark + MySQL + HiveSQL + PrestoSQL/Trino bash script/run_batch.sh -online # FlinkSQL bash script/run_batch.sh -all # all 100 tasks ``` Use `script/run_batch.sh -all` to evaluate the complete 100-task suite. Results and a combined report are written to `output/`. --- ## Usage Reference `run_batch.sh` options: | Flag / Option | Description | |---------------|-------------| | `-P` `-M` `-H` `-F` `-PR` | Select PySpark / MySQL / HiveSQL / FlinkSQL / PrestoSQL/Trino | | `-offline` `-online` `-all` | Run predefined workload groups | | `--parallel N` | Number of tasks to run concurrently (default: 10) | | `--harness NAME` | Agent backend: `codebuddy` (default), `claude-code`, `codex` | | `--model MODEL` | Model name (repeatable, `codebuddy` only) for multi-model runs | Examples: ```bash # PySpark with 5 workers bash script/run_batch.sh -P --parallel 5 # Use the Claude Code harness bash script/run_batch.sh -P --harness claude-code # Compare two CodeBuddy models on PySpark bash script/run_batch.sh -P --model model_a --model model_b ``` To run a single task directly (bypassing batch mode): ```bash python3.11 eval/run_batch.py \ --agent-backend codebuddy \ --task tasks/offline-compute/PySpark/pyspark_001/task.md \ --model deepseek-v4-flash-ioa ``` --- ## Output & Scoring Each run is saved under `output/////` with the submitted solution, workspace snapshot, transcript, usage statistics, and `score.json`. DataClawEval evaluates both the final data product and the engineering workflow: - **Artifact quality** — executability, schema correctness, row-level alignment, numerical accuracy, and categorical or business correctness. - **Process quality** — exploration adequacy, execution efficiency, and self-verification. The overall score combines both dimensions: \[ S = \alpha S_{artifact} + (1-\alpha)S_{process} \] The artifact weight \(\alpha\) is configured per task, with 0.7 as the most common value. Repository outputs normalize `overall_score` to 0–1, while the paper presents scores on a 0–100 scale. Batch runs aggregate model and engine summaries into `output/experiment_report_.json` and report the average score and the number of tasks with `overall_score >= 0.5`: ``` Category/Model Tasks Avg Score Pass(>=0.5) offline-compute/PySpark/model_a 20 0.7350 15/20 ``` --- ## Paper Results The paper evaluates 16 model configurations from eight families on all 100 tasks: 1,600 primary runs in total. Every model uses the same fixed Tencent CodeBuddy scaffold, and only the underlying LLM changes. The primary table uses one run per model–task pair; task prompts are evenly split between English and Chinese (50 each). | Model | Overall score (0–100) | Avg. tokens/task | |-------|----------------------:|-----------------:| | GPT 5.5 | **74.9** | 299.8k | | Claude Opus 4.8 | 74.3 | 318.3k | | Claude Sonnet 5 | 73.8 | 457.9k | | Gemini 3.1 Pro | 73.7 | 292.4k | | Gemini 3.5 Flash | 73.3 | 973.8k | | DeepSeek V4 Flash | 73.0 | 419.6k | | MiniMax M3 | 71.8 | 714.1k | | GLM 5.1 | 71.6 | 355.4k | | DeepSeek V4 Pro | 70.6 | 359.3k | | Kimi K2.6 | 69.0 | 428.8k | | GLM 5.2 | 68.8 | 403.9k | | Kimi K2.7 | 68.1 | 407.5k | | GPT 5.3 Codex | 66.4 | **271.4k** | | Hy3 | 66.0 | 468.7k | | MiniMax M2.7 | 63.7 | 501.0k | | GLM 5V Turbo | 60.3 | 287.8k | Research highlights: - GPT 5.5 achieves the highest overall score at 74.9. - Engine-level results reveal complementary strengths: Claude Opus 4.8 leads PySpark; GPT 5.5 leads HiveSQL and MySQL; DeepSeek V4 Pro and Gemini 3.5 Flash tie on PrestoSQL/Trino; and DeepSeek V4 Flash leads FlinkSQL. - Token and tool-call analyses identify models that combine strong task performance with efficient agent execution. - Repeated-run experiments add execution consistency as a first-class evaluation dimension. - Execution-grounded, rule-based graders provide stable, case-specific assessment of both generated artifacts and engineering processes. See the [paper](DataClawEval__A_Benchmark_for_Data_Engineering_Agents_in_Real_Industrial_Harness.pdf) for complete engine-level results, efficiency and stability analyses, bilingual performance, and all task listings. --- ## Project Structure ``` DataClawEval/ ├── Dockerfile # Self-contained sandbox (Spark, Flink, Trino, MySQL, Python 3.11) ├── requirements.txt # Host-side Python dependencies ├── .env.example # Credentials template ├── eval/ │ └── run_batch.py # Evaluation entry point ├── script/ │ ├── prepare.sh # Vendor SDK + build the Docker image │ ├── run_batch.sh # Batch runner + report generator │ ├── run.sh # Thin wrapper around run_batch.py │ └── ... # Metastore / Trino / entrypoint helpers ├── src/ │ ├── agents/ # Agent backends: codebuddy, claudecode, codex, common │ └── utils/ # Docker orchestration, DB init, grading, task parsing └── tasks/ ├── offline-compute/ # PySpark, MySQL, HiveSQL, PrestoSQL └── online-compute/ # FlinkSQL ``` --- ## Citation If you use DataClawEval in research, cite the project using [`CITATION.cff`](CITATION.cff). The archived software release is available at . --- ## License Released under the [MIT License](LICENSE).