README.md

---
license: mit
task_categories:
- question-answering
- text-generation
language:
- en
pretty_name: FlowBench
size_categories:
- n<1K
tags:
- agents
- tool-use
- benchmark
- harbor
- data-orchestration
---

# FlowBench

Dataset ID: `jwu323/FlowBench`

FlowBench is a tool-use benchmark for deterministic business operations
workflows. Each task asks an agent to compose Python tools over synthetic
customers, products, orders, returns, inventory, support tickets, FX rates, and
SLA policies.

Scope note: this dataset is a business-operations tool-composition benchmark. It
is unrelated to prior workflow-guided planning or workflow-generation benchmarks
that also use the FlowBench name.

This repository contains the public `test` split. It is answer-free by design:
fixed gold labels, oracle solutions, and strict verifier expected files are not
included. The public files are suitable for task inspection, agent integration,
and reproducible smoke tests. Official scoring should use a private evaluator
pack or a freshly generated held-out split with hidden answers.

## Splits

`test` contains 300 public task specifications:

| depth | tasks | description |
|---:|---:|---|
| 1 | 50 | single-step lookups such as region currency or top-selling product id |
| 2 | 50 | filtered order and customer counts |
| 3 | 50 | revenue and refund-rate aggregations |
| 4 | 50 | local-currency conversion and margin-after-refund calculations |
| 5 | 50 | replenishment shortfall and delayed-order revenue workflows |
| 6 | 50 | delayed fulfillment plus SLA breach burden, and at-risk revenue from breached tickets |

There are 12 task families with 25 tasks per family. The `currency_lookup`
family is a depth-1 diagnostic and intentionally repeats the four region
currency facts across task ids. Treat it as a tool-wiring sanity check, not as a
leaderboard difficulty signal. The public `test` split is closed-world and
deterministic, but it is not a public-answer leaderboard split.

## Files

- `data/test.jsonl`: answer-free task records.
- `tools/flowbench_tools.py`: deterministic tool implementation visible to agents.
- `harbor/`: Harbor-compatible public task pack with a smoke verifier. The smoke
  verifier checks output shape only; it is not official scoring.
- `RUN.md`: instructions for wiring the public split to an LLM agent and writing
  prediction files.

Each JSONL record includes:

- `task_id`
- `depth`
- `family`
- `region`, `category`, `month_start`, `month_end`
- `instruction`
- `answer_format`

No record contains a gold answer.

## Training Trace Companion

A separate companion dataset, `jwu323/FlowBench-GPT55-Traces`, may be used for
supervised training or trace analysis. It contains real `gpt-5.5` multi-turn
REPL-submit traces on regenerated salted tasks whose parameter tuples are
excluded from this public test split. It contains final answers by design, so it
must not be mixed into FlowBench evaluation prompts, public-test scoring, or
leaderboards.
Its turn-level SFT files are prefix-target slices from those multi-turn
episodes, not independent single-turn traces.
Link: https://huggingface.co/datasets/jwu323/FlowBench-GPT55-Traces

## Where the Data Comes From

There is no separate CSV, database dump, or network service to download. The
benchmark data are generated deterministically inside
`tools/flowbench_tools.py` and inside each Harbor task's
`/app/flowbench_tools.py`. Importing that file builds in-memory tables for 72
customers, 48 products, 720 orders, 180 returns, 260 support tickets, inventory,
FX rates, and SLA policies from SHA-256 keyed generators. The same task and tool
file therefore produce the same data on every machine.

Because those deterministic tools are public, anyone can recompute answers for
the public task records. This is intentional for transparency and agent
integration, but it means the repository is not a secure fixed-answer
leaderboard package. Official scores should come from a private evaluator or a
freshly salted held-out split.

When running without Harbor, load `tools/flowbench_tools.py` into the agent
runtime and expose its functions as the tool API. When running with Harbor, the
task container already places the same tool file at `/app/flowbench_tools.py`.
Agents should solve tasks by calling the provided tools; the public release does
not ship gold answers or a strict answer checker.

## Running an Agent

For public agent evaluation, give the agent one task record from
`data/test.jsonl`, expose only the functions listed in
`tools/flowbench_tools.py::TOOLS`, and ask the agent to return only the final
answer in the record's `answer_format`. The task record supplies the question
and parameters; the tool module is the data source and builds all tables
deterministically at import time.

Recommended public prediction format:

```json
{"task_id": "example_task_id", "answer": "<model-output>", "model": "your-model-name"}
```

`RUN.md` has a fuller harness contract, adapter skeleton, prompt template, and a
worked tool plan for a depth-6 task. The public split has no labels, so
predictions from this repository alone are for inspection, integration testing,
or private scoring; do not report them as official FlowBench scores.

## Evaluation Boundary

The task records and deterministic tool code in this repository are public.
Repeated prompt or adapter tuning on `data/test.jsonl` can overfit to the
released task surface. Treat public-only runs as integration or smoke-test
evidence, not as an official leaderboard.

For paper, leaderboard, or cross-model claims, freeze the prompt and tool
adapter before scoring, use private labels or a freshly generated held-out split,
report the scoring setting, and reject task-id-specific lookup logic.

## Running the Harbor Smoke Pack

```bash
harbor run -p harbor -a <agent> -l 1
```

The Harbor pack in this repository is a public smoke pack. It verifies that an
agent writes an output with the required shape. It deliberately does not contain
the private expected answers.

## Task Families

- `currency_lookup`
- `top_product_lookup`
- `order_count`
- `unique_customer_count`
- `net_revenue_usd`
- `refund_share_bp`
- `local_net_revenue`
- `margin_after_refunds`
- `reorder_shortfall`
- `delayed_net_revenue`
- `delay_sla_burden`
- `breached_ticket_revenue`

## Evaluation Notes

FlowBench is designed to compare how agent interfaces express the same tool
capabilities: function-calling style, command style, and code/REPL style
substrates can all call the same tools. For public release, do not evaluate by
matching against labels embedded in this repository; there are none. Use a
private evaluator or generate a held-out split with hidden answers.

## Citation

If you use FlowBench, cite the associated paper or this dataset repository once
the paper is released.