Blame for README.md

---
language:
  - en
size_categories:
  - n<1K
pretty_name: GTA-Workflow
tags:
  - agent
  - tool-use
  - workflow
  - multimodal
  - benchmark
  - evaluation
  - gta-2
viewer: false
---

# GTA-Workflow: Benchmarking General Tool Agents with Open-Ended Workflows

<div align="center">

[📃 [Paper](https://arxiv.org/pdf/2604.15715)]
[</> [Code](https://github.com/open-compass/GTA)]
[🤗 [GTA-Atomic](https://huggingface.co/datasets/Jize1/GTA)]
</div>

<div align="center">
 <img src="https://huggingface.co/datasets/Jize1/admin/resolve/main/gta2-sample.png" width="800"/>
</div>


**GTA-Workflow** is a benchmark of **132 long-horizon, open-ended productivity tasks** for evaluating general tool agents. Introduced in **GTA-2**, it assesses an agent's ability to complete realistic workflows and produce usable final deliverables, such as analytical reports, presentations, spreadsheets, web pages, images, and videos.

Each task includes a user request, associated resources when applicable, a workflow category, and a hierarchy of weighted evaluation requirements. The benchmark supports evaluating both language models and the agent execution frameworks that coordinate planning, tool use, and artifact creation.

- **Paper:** [GTA-2: Benchmarking General Tool Agents from Atomic Tool-Use to Open-Ended Workflows](https://arxiv.org/abs/2604.15715)
- **Code and evaluation framework:** [open-compass/GTA](https://github.com/open-compass/GTA)
- **Dataset archive:** [GTA-Workflow release](https://github.com/open-compass/GTA/releases/download/v0.2.0/gta_workflow_dataset.zip)

## Dataset overview

GTA-Workflow focuses on end-to-end task completion: agents must interpret a request, work with relevant resources, coordinate tools, and assemble the requested outputs. Tasks may combine information retrieval, quantitative reasoning, document processing, and multimodal content generation within a single workflow.

GTA-Workflow complements **GTA-Atomic**, the original GTA benchmark for atomic tool-use evaluation. This dataset card describes the GTA-Workflow release only.

| Property | Description |
| --- | --- |
| Tasks | 132 |
| Workflow categories | 6 |
| Task language | English |
| Tool definitions | 37 in `toolmeta.json` |
| Tasks with a non-empty `files` field | 46 |
| Input resources | Documents, spreadsheets, text, images, audio, video, and Reddit post data |
| Evaluation annotations | Hierarchical requirements with importance weights |
| Packaging | One task collection in `end.json`, tool metadata, and accompanying resources |

### Task categories

The following counts are computed from `workflow_category_6class` in this release.

| Category | Tasks |
| --- | ---: |
| Data Analysis & Quantitative Reasoning | 34 |
| Educational & Instructional Content | 31 |
| Planning & Decision Support | 21 |
| Business & Marketing Strategy | 16 |
| Creative Design & Expressive Generation | 16 |
| Information Retrieval & Knowledge QA | 14 |
| **Total** | **132** |

Representative workflows include comparing travel policies across PDF documents and producing HTML and CSV outputs; creating physics demonstration videos with an HTML presentation; researching products and assembling a Word report with a chart; and planning a trip with route maps and an illustrated travel handbook.

## Dataset structure

```text
gta_workflow_dataset/
├── README.md
├── end.json                 # Task requests, resource references, and evaluation requirements
├── toolmeta.json            # Tool descriptions and input/output schemas
└── resources/
    ├── files/               # Documents, spreadsheets, and other file inputs
    ├── images/              # Image inputs
    ├── audio/               # Audio inputs
    ├── video/               # Video inputs
    └── reddit_data/         # Post data and associated media
```

The release contains a single collection of 132 tasks; no separate training, validation, or test splits are provided. Task IDs are the original string keys in `end.json` and are not consecutive. Preserve these IDs when saving predictions and evaluation results.

### Task schema

`end.json` is a JSON object mapping task IDs to task records, rather than a JSON Lines file or a top-level list.

| Field | Type | Description |
| --- | --- | --- |
| `tools` | List | Task-level tool entries. Empty for all tasks in this release; the shared tool catalog is provided separately in `toolmeta.json`. |
| `files` | List | File references associated with the task. Most entries are objects with `type`, `path`, and `url`; one task uses filename strings. |
| `dialogs` | List of objects | Conversation messages. Each task in this release contains one user message with `role`, `content`, and `resources`. |
| `sub_tasks` | List of objects | Hierarchical evaluation requirements for the requested workflow and deliverables. |
| `workflow_category_6class` | String | One of the six workflow categories listed above. |

Resource objects in `files` and `dialogs[].resources` contain a resource type, a path, and an optional URL, which may be `null`. Resolve bundled paths such as `resources/files/2-1.pdf` relative to the dataset root. Inspect individual entries before processing them: task `126` uses the strings `LatencyReport.pdf` and `LatencyData.csv` in its `files` field rather than resource objects, and those names do not identify bundled files.

Each evaluation node in `sub_tasks` contains:

| Field | Type | Description |
| --- | --- | --- |
| `id` | String | Requirement identifier, for example `cp1` or `cp1-1`. |
| `requirements` | String | The criterion describing the expected result. |
| `weight` | Number | Importance weight used by the evaluation framework. |
| `sub_tasks` | List of objects, optional | Child requirements with the same recursive structure. |

For example, task `2` asks an agent to compare four travel-policy PDFs and produce `TravelPolicyComparison.html` and `TravelPolicyComparison.csv`. Its evaluation hierarchy covers information extraction, the comparative table, policy summaries, CSV generation, and output validity. These annotations specify expected outcomes; they are not reference tool-call trajectories or completed deliverables.

### Tool metadata

`toolmeta.json` maps tool names to definitions containing `name`, `description`, `inputs`, and `outputs`. Parameter descriptions include types, names, optional flags, defaults, and file-type information where available.

The 37 definitions cover web search, calculation and symbolic reasoning, document reading and generation, image understanding and editing, audio processing, and video understanding and generation. Tool metadata describes the tool interface; implementations, services, and evaluation code are maintained in the [GTA repository](https://github.com/open-compass/GTA).

## Loading the dataset

After downloading the dataset repository or extracting the release archive, use Python's standard library to read the original structure:

```python
import json
from pathlib import Path

root = Path("gta_workflow_dataset")  # Set this to your local dataset directory.

tasks = json.loads((root / "end.json").read_text(encoding="utf-8"))
tool_metadata = json.loads((root / "toolmeta.json").read_text(encoding="utf-8"))

print(f"{len(tasks)} tasks, {len(tool_metadata)} tool definitions")

task_id = "2"
task = tasks[task_id]
print(task["dialogs"][0]["content"])
print(task["workflow_category_6class"])

for resource in task["dialogs"][0].get("resources", []):
    if resource.get("path"):
        resource_path = root / resource["path"]
        print(resource_path, resource_path.exists())

# Keep the evaluation annotations separate from the agent's task input.
evaluation_requirements = task["sub_tasks"]
```

To obtain a list of records for downstream processing while retaining task IDs:

```python
records = [{"task_id": task_id, **task} for task_id, task in tasks.items()]
```

The nested, ID-keyed JSON and accompanying resource directory should be preserved when distributing or loading the benchmark. The examples above read the release directly and do not require a Hugging Face Datasets loading script.

## Intended use and evaluation

GTA-Workflow is intended for research on general tool agents, long-horizon planning, multimodal tool use, and artifact generation. It can be used to compare language models under a shared agent framework or to evaluate complete agent systems through their final outputs.

For a benchmark run:

1. Provide the agent with the user request from `dialogs` and the associated input resources, preserving resource paths or explicitly mapping them into the execution environment.
2. Configure the tools and execution environment needed to complete the task.
3. Collect the agent's final response and all generated artifacts.
4. Evaluate the outputs against the weighted requirements in `sub_tasks` using the GTA evaluation framework.

Keep `sub_tasks` as evaluator annotations when measuring task completion, and report the model, agent framework, available tools, execution budget, and evaluation configuration. The dataset does not include an executable evaluator or tool server. Refer to the [GTA repository](https://github.com/open-compass/GTA) for the evaluation pipeline, custom agent integration, and evaluation of external agent outputs.

## Data collection and annotation

GTA-Workflow was constructed from real-world workflow tasks through a human-in-the-loop collection and rewriting process. Sources described by the project include:

- Agent platforms and systems: Manus, Kortix, Flowith, Minimax Agent, and CrewAI.
- User needs from online communities: Reddit and Stack Exchange.

The released records pair workflow requests with categorized tasks and hierarchical evaluation requirements. Source-platform attribution is not included as a dedicated field in each task record.



## Citation

If you use GTA-Workflow, please cite the GTA-2 paper. The original GTA paper is also included below for reference.

```bibtex
@article{wang2024gta,
  title={GTA: a benchmark for general tool agents},
  author={Wang, Jize and Ma, Zerun and Li, Yining and Zhang, Songyang and Chen, Cailian and Chen, Kai and Le, Xinyi},
  journal={Advances in Neural Information Processing Systems},
  pages={75749--75790},
  year={2024}
}
@article{wang2026gta2,
  title={GTA-2: benchmarking general tool agents from atomic tool-use to open-ended workflows},
  author={Wang, Jize and Liu, Xuanxuan and Li, Yining and Zhang, Songyang and Wang, Yijun and Shan, Zifei and Le, Xinyi and Chen, Cailian and Guan, Xinping and Tao, Dacheng},
  journal={arXiv:2604.15715},
  year={2026}
}

```