README.md

---
license: cc-by-4.0
language:
- en
task_categories:
- question-answering
tags:
- agents
- benchmark
- workspace-agents
- data-agents
- rag
- tables
- knowledge-graphs
- tool-use
pretty_name: WorkSurface-Build
size_categories:
- 100<n<1K
configs:
- config_name: task_units
  default: true
  data_files:
  - split: test
    path: task_units.jsonl
- config_name: persona_units
  data_files:
  - split: test
    path: persona_units.jsonl
---

# WorkSurface-Build

**WorkSurface-Build evaluates whether an agent can turn a raw workspace into a
reusable data surface *before* it sees the downstream questions.**

It complements
[WorkSurface-Bench](https://huggingface.co/datasets/lhpku20010120/WorkSurface-Bench):
WorkSurface-Bench asks whether an agent can use existing RAG, table, and graph
surfaces, while WorkSurface-Build asks whether an agent can build useful
surfaces from the corresponding raw Workspace-Bench files.

The central protocol is:

```text
raw workspace + role brief + build budget
                    ↓
               free-form Builder
                    ↓
       RAG index / SQL DB / graph / any artifacts
                    ↓
              freeze and hash
                    ↓
        release downstream questions
                    ↓
                fixed Worker
                    ↓
       answer quality + evidence + efficiency
```

There is deliberately **no gold database, chunking policy, ontology, graph
schema, or canonical ingestion output**. A build is good only when the frozen
surface helps a fixed Worker answer future questions accurately and
efficiently.

## Why this benchmark?

Most data-agent evaluations start after the useful representation already
exists: documents have been chunked, tables normalized, schemas selected, and
graphs constructed. Real workspace agents must make those decisions under
uncertainty and should create assets that remain useful across multiple future
requests. WorkSurface-Build moves evaluation upstream from question answering
to **workspace organization, ingestion, and reuse**.

The benchmark supports research on:

- workspace-native data agents;
- autonomous RAG, SQL, and knowledge-graph construction;
- representation selection and cross-surface routing;
- build-cost/query-quality trade-offs;
- amortization: whether one build pays off across many future queries.

## Release at a glance

- **100 task workspaces** aligned to Workspace-Bench-Lite source tasks
- **1,151 downstream questions** reused from WorkSurface-Bench
- **5 persona workspaces** for longer-horizon, cross-task reuse
- **1,034 persona-track held-out questions** and **19 public calibration episodes**
- **760 raw workspace files**, about **258 MB** in the full release
- Question composition: **488 cross-surface**, **279 table-only**, **213 RAG-only**, and **171 graph-only**

No new task-level answers are annotated for this construction. Questions,
answers, evidence, and answer scoring are inherited from WorkSurface-Bench.
This means the construction is **annotation-reusing**, not annotation-free:
the upstream benchmarks include human curation and audit.

## Tracks

### 1. Task-unit track (primary)

Each of the 100 source-task workspaces is built once. The Builder receives the
raw files, role brief, and budget but zero question examples. After the build
artifacts are frozen, every downstream question derived from that workspace is
served to a fixed Worker.

This track gives broad coverage and supports both task-level micro averages and
workspace-level macro averages.

### 2. Persona-unit track (reuse)

Source workspaces are grouped into five roles: Backend Developer, Logistics
Manager, Operations Manager, Product Manager, and Researcher. Calibration and
evaluation are split by complete source workspace, never by randomly splitting
sibling questions from the same workspace.

On the Hub, persona units reference the corresponding folders under
`task_units/` instead of duplicating the same binary files.

## Repository structure

```text
task_units.jsonl                 # index of 100 primary units
task_units/
  task_300/
    unit.json                    # role, hashes, budget policy, commitment
    workspace/                   # raw files visible to the Builder
persona_units.jsonl              # index of five aggregated units
persona_units/
  backend_developer/unit.json    # references task-unit workspace folders
scripts/                         # protocol, validation, and scoring utilities
release_manifest.json            # aggregate release statistics
```

The public repository contains Builder-visible workspaces, unit specifications,
commitments, and calibration examples. Held-out question payloads, answer gold,
and evaluator metadata are intentionally not included in the public tree. An
evaluation runner releases questions only after artifact freezing. This is a
protocol boundary for controlled experiments, not a claim that the upstream
WorkSurface-Bench questions have never been published.

## Loading the unit indexes

```python
from datasets import load_dataset

task_units = load_dataset(
    "lhpku20010120/WorkSurface-Build",
    "task_units",
    split="test",
)
persona_units = load_dataset(
    "lhpku20010120/WorkSurface-Build",
    "persona_units",
    split="test",
)
```

Download the binary workspaces with:

```python
from huggingface_hub import snapshot_download

root = snapshot_download(
    repo_id="lhpku20010120/WorkSurface-Build",
    repo_type="dataset",
)
```

## Evaluation contract

For each unit:

1. Mount only that unit's public workspace and specification for the Builder.
2. Record the build budget and write arbitrary artifacts to a separate output directory.
3. Freeze the artifacts and commit their SHA-256 hashes.
4. Release the unit's questions to a fixed Worker.
5. Record answers, raw-file provenance, token use, latency, and raw-file fallback.
6. Verify that frozen artifacts did not change, then score the predictions.

The source-grounded query utility is:

```text
0.55 × Answer + 0.35 × Source Evidence + 0.10 × Efficiency
```

When an upstream item has no raw-file-addressable evidence, the available
components are renormalized. Builder cost is reported separately and should be
amortized over the number of served questions rather than hidden inside query
utility.

Recommended reporting includes:

- answer, source-evidence, efficiency, and query-utility scores;
- micro average over questions and macro average over source workspaces;
- build time, tokens, storage size, and external-service cost;
- query latency/tokens and raw-workspace fallback rate;
- utility and total cost as the number of future questions increases.

## Suggested baselines

1. Raw-files-only Worker
2. Fixed RAG Builder
3. Fixed RAG + SQL + graph pipeline
4. LLM-planned Builder
5. Workspace-native adaptive Builder

Use the same Worker model and query budget across builders so that the
comparison measures the built data surface rather than a stronger answer model.

## Provenance, scope, and limitations

WorkSurface-Build is an evaluation protocol and repackaging derived from
WorkSurface-Bench and Workspace-Bench-Lite. The 1,151 questions come from 100
source workspaces and are not 1,151 independent workspaces. Question counts are
imbalanced across source workspaces, so macro-by-workspace results are required.

The benchmark measures usefulness for the known WorkSurface question
distribution. It does not establish universal workspace quality, and it should
not be used as training data or as the sole basis for safety-critical deployment
decisions.

## Attribution

- [WorkSurface-Bench dataset](https://huggingface.co/datasets/lhpku20010120/WorkSurface-Bench)
- [WorkSurface-Bench code](https://github.com/haolpku/WorkSurface-Bench)
- [Workspace-Bench: Towards Supervising Generalist Agents in the Workplace](https://arxiv.org/abs/2605.03596)

Please cite the upstream benchmarks and this dataset release when using
WorkSurface-Build.

## License

Derived benchmark data are released under **CC BY 4.0**. Utility code is
released under **Apache-2.0**. Raw canonical resources derive from
Workspace-Bench-Lite and retain applicable upstream licensing and attribution
requirements; see `LICENSE_DATA`.