Datasets:

lhpku20010120
/

WorkSurface-Build

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: 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:

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

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

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:

from huggingface_hub import snapshot_download

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

Evaluation contract

For each unit:

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

The source-grounded query utility is:

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

Raw-files-only Worker
Fixed RAG Builder
Fixed RAG + SQL + graph pipeline
LLM-planned Builder
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

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.