Annihi/dumate_bench

DuMateBench Dataset

Dataset Summary

DuMateBench is a benchmark dataset for evaluating AI agents on realistic computer-based work tasks.

Each task provides an instruction, a sandboxed workspace, task-specific resources, and an evaluator. The agent must inspect the workspace, use available tools, produce the required artifact, and recover from environmental or tool failures when necessary.

The dataset contains 200 tasks covering software development, web research, document processing, spreadsheet workflows, file organization, and multimedia content generation.

Unlike conventional text-generation datasets, DuMateBench evaluates interactive agent behavior. Agents are evaluated on both the final artifact and the trajectory that leads to it.

Dataset Statistics

Property	Value
Number of tasks	200
Approximate size	3.8 GB
Primary language	Chinese
Secondary language	English
Execution environment	Docker
Task format	Instruction, workspace, evaluator, metadata
Evaluation style	Artifact checks, recovery checks, optional LLM judge

Task Coverage

The tasks cover the following capabilities:

• Text generation
• Code writing and software development
• Web retrieval and information extraction
• PDF, DOCX, PPTX, and spreadsheet processing
• File organization and cross-application workflows
• Image, video, and audio generation or editing
• Network and API failure recovery
• Missing-tool and dependency recovery
• Resource-constrained execution
• Multi-step artifact production

The approximate capability distribution is:

Capability	Number of tasks
Text generation	160
Code writing	88
Web retrieval	86
File organization	34
DOCX reading	27
DOCX editing	26
Image generation or editing	25
Excel editing	18
PDF reading	15
Video generation or editing	15
Excel reading	13
Audio generation or editing	6
PPTX editing	5
PPTX reading	3
PDF editing	3

These capabilities are compositional rather than mutually exclusive. A single task may require several capabilities at the same time.

Dataset Structure

The local task collection is organized as follows:

final_dataset_clean/
  task_1/
    instruction.md
    task.yaml
    task_type_feature.json
    workspace_seed/
    evaluator/
    web_reference/
  task_2/
    ...

Each task contains:

• instruction.md: the task prompt shown to the agent
• task.yaml: task metadata and execution configuration
• task_type_feature.json: capability annotations
• workspace_seed/: initial workspace files
• evaluator/: task-specific grading logic and checks
• web_reference/: optional web or reference material

The task data is consumed by the DuMateBench evaluation framework. The task directories in this collection are task materials and are not intended to be executed as standalone scripts without the accompanying runtime environment.

Evaluation Protocol

During an evaluation, the agent operates inside a Docker-based sandbox.

The interaction loop is:

Task instruction
  -> agent returns one JSON action
  -> runner executes the action in Docker
  -> tool output is returned to the agent
  -> agent chooses the next action
  -> evaluator checks the final artifact and task logs

An action must contain exactly one next action, for example:

{
  "command": "find /workspace -maxdepth 3 -type f",
  "reason": "Inspect the available workspace files"
}

The agent may finish with:

{
  "finish": true,
  "reason": "The requested artifact has been verified"
}

The evaluator may check:

• Whether the required artifact exists
• Whether the artifact satisfies task-specific requirements
• Whether injected failures were observed
• Whether the agent recovered from tool or network errors
• Whether the final output was written to the expected location
• Optional LLM-judge criteria when enabled

A successful orchestration run does not necessarily mean that the task passed. The evaluator result is the source of truth.

Featured Task

task_1 · Web Retrieval, Coding, and Spreadsheet Synthesis

International Cooperative Education Program Data Collection

Field	Description
Task ID	task_1
Domain	Web research, data extraction, coding, spreadsheet editing
Language	Chinese
Required output	An .xlsx workbook and crawler source code
Execution	Sandboxed Docker workspace
Evaluation	Artifact checks, recovery checks, and optional LLM judge

Task Objective

The agent must read a prepared project list, retrieve project details from the provided web references, implement a resumable crawler, and generate a structured Excel workbook.

Agent Workflow

Read the project list
  -> inspect web references
  -> implement the crawler
  -> handle network and API failures
  -> collect and normalize records
  -> write the Excel workbook
  -> save the crawler source code

Expected Artifacts

/outputs/data/中外合作办学项目完整数据.xlsx
/outputs/code/crawler.py

Capabilities Exercised

• Web retrieval
• Code writing
• Spreadsheet editing
• Cross-application workflow
• Network-error recovery
• Resource-constrained execution
• Multi-file artifact delivery

Why This Task Is Representative

This task requires the agent to combine workspace inspection, web retrieval, program synthesis, data cleaning, failure recovery, and structured file generation. It represents the type of multi-step computer work targeted by DuMateBench.

The public version of this example should be sanitized before release. Credentials, private keys, personal information, and unverified third-party materials must not be included.

Data Processing

The dataset is organized as task bundles rather than as a conventional tabular dataset.

Task-level metadata is stored in YAML and JSON files. Input resources remain in the task workspace, while grading logic is stored separately under the task evaluator directory.

The capability annotations are compositional. They describe the abilities required by each task and should not be interpreted as mutually exclusive dataset subsets.

Environment and Reproducibility

DuMateBench uses Docker to provide an isolated and reproducible execution environment.

Docker is used to:

• isolate agent-generated commands from the host system
• provide consistent tool and dependency versions
• initialize a clean workspace for each run
• inject controlled tool and network failures
• collect outputs and logs in stable locations
• make evaluations comparable across agents

The benchmark runtime, task environment, and evaluator should be used together when reproducing benchmark results.

Running the Deterministic Smoke Test

The deterministic smoke test does not require an API key or an LLM:

bash dumatebench/scripts/run_odyssey_2_12_smoke.sh

A successful run should produce:

{
  "complete_pass": 1,
  "partial_pass": 1.0,
  "environment_recovery": 1,
  "network_recovery": 1
}

The main output can be inspected with:

cat dumatebench/datasets/dev/odyssey_2_12_smoke/run_outputs/reward.json

The smoke test intentionally injects temporary OCR and calendar failures. These failures are part of the evaluation and are expected during a successful run.

Running an LLM Agent

An OpenAI-compatible model can be connected through the provided agent adapter:

export OPENAI_API_KEY="your-api-key"
export OPENAI_BASE_URL="https://your-provider.example/v1"
export DUMATE_MODEL="your-model-id"
export DUMATE_TRUSTED_BASE_URLS="$OPENAI_BASE_URL"

bash dumatebench/scripts/run_odyssey_2_12_agent.sh --max-steps 20

The selected endpoint and model must support:

• temperature: 0
• OpenAI JSON-object response format
• one action per response
• the DuMateBench agent contract

A model response containing multiple concatenated JSON objects is not a valid DuMateBench action.

After an LLM run, inspect:

cat dumatebench/datasets/dev/odyssey_2_12_smoke/run_logs/agent_status.json
cat dumatebench/datasets/dev/odyssey_2_12_smoke/run_outputs/reward.json

A complete local pass requires both:

evaluator_returncode == 0
reward.json: complete_pass == 1

Returning finish: true or reaching the maximum step count does not by itself indicate a passing result.

Limitations

• Tasks vary substantially in domain, modality, and difficulty.
• Capability annotations are not mutually exclusive.
• Some tasks require network access or external service availability.
• Agent performance depends on the model, API compatibility, tool-use behavior, and step budget.
• A valid final artifact may still receive a partial score if required recovery behavior was not observed.
• Local task rewards should not be interpreted as official leaderboard scores unless produced with the canonical evaluation setup.

Privacy and Licensing

This dataset should only be redistributed after all task inputs, reference files, generated examples, and evaluation artifacts have been reviewed for privacy, credentials, private keys, and third-party licensing restrictions.

The Apache-2.0 license should only be applied to the dataset if the dataset contents themselves are covered by that license or have been separately authorized for redistribution.

Citation

If you use this dataset, please cite the DuMateBench repository and the corresponding benchmark publication, when available.