harrrshall/bam-scientific-tool-use

BAM Scientific Tool Use

Inspect real welding measurement files, calculate a precisely specified result, and cite the evidence used. BAM Scientific Tool Use is a small, auditable dataset for evaluating language models with Python tools. It contains 160 tasks over 30 welding passes from five physical workpieces: 130 answerable calculations and 30 constructed cases where a required file is withheld.

The measurements come from Chaurasia et al., Tandem-GMAW: advanced pulsed and short-circuiting process mode experimental data, v2.0.0, 7 August 2026. This derivative packages a selected raw-file subset, task definitions, deterministic references, an external scorer and an execution harness. It is independently prepared and does not imply endorsement by the source creators or BAM.

Version: 0.1.0. Measured model results: RESULTS.md. Evaluation settings: protocol. Exact calculation contracts: task specification.

Measured difficulty: DeepSeek V4 Flash 0731, Qwen3.8 27B FP8 and GLM-5.3 each solved all 32 test tasks in all three repeats. The observed scores are at the ceiling. This is an auditable reference and regression suite; these results do not establish a challenging frontier benchmark. The DeepSeek control without file access solved only the six explicit withheld-evidence cases (6/32). Full coverage comprises 320 task runs.

The current tasks use recorded sensor values and file availability. Every row has requires_video: false. The source archive also contains video and scans, but this release does not measure visual understanding, camera-to-sensor grounding, weld quality or robot-policy performance.

Load the dataset

Install the optional Hugging Face loading libraries:

python -m pip install datasets==4.8.5 huggingface_hub==1.32.0

import json
from datasets import load_dataset

tasks = load_dataset(
    "harrrshall/bam-scientific-tool-use",
    "scientific_tasks",
    split="test",
)

# The public distribution includes reference answers for reproducibility.
# Remove gold before constructing model inputs.
inputs = tasks.remove_columns("reference_response_json")
row = inputs[0]
task_input = {
    key: row[key]
    for key in ("task_id", "workpiece_id", "split", "family", "prompt")
}
task_input["allowed_files"] = json.loads(row["allowed_files_json"])
task_input["response_schema"] = json.loads(row["response_schema_json"])
print(task_input["prompt"])

load_dataset loads the task records; it does not fetch the referenced raw files. Download the repository for local execution:

from huggingface_hub import snapshot_download

snapshot_download(
    repo_id="harrrshall/bam-scientific-tool-use",
    repo_type="dataset",
    local_dir="bam-scientific-tool-use",
)

Record and pin a repository commit with revision= for reproducible use. The bundled source subset occupies 400,184,634 bytes, approximately 400 MB, plus the smaller tasks, tools and reports. It contains 60 original .nc measurement files and the publisher's experiment-list metadata. The original video archive is not included in this benchmark package.

Two configurations

scientific_tasks — 160 raw-file tasks. The model must inspect declared files using tools. Parquet fields are task_id, workpiece_id, split, family, prompt, allowed_files_json, response_schema_json, reference_response_json, source_doi and requires_video. The three *_json fields contain serialized JSON, preserving the different answer schemas without flattening them into ambiguous columns. The reference response is gold and belongs only in the evaluator.

introductory_sft — 480 structured-evidence examples. These supply calculated evidence summaries and role/content messages for introductory supervised fine-tuning. They are not demonstrations of executed analysis programs. Fields include question_id, episode_id, split, messages, source_doi, training_scope and requires_video. Some citations retain publisher video, scan or inventory paths that are not bundled here; the supplied summary is the evidence available in this configuration. Do not treat these citations as verified frame labels.

intro_train = load_dataset(
    "harrrshall/bam-scientific-tool-use",
    "introductory_sft",
    split="train",
)
messages = intro_train[0]["messages"]

Use the introductory training split for training. Its validation/test files contain answers and must remain held out. Do not combine introductory results with raw-file task scores.

What the tasks ask

The six families have explicit units, time conventions, finite-value rules and output schemas:

• Joint recorded-channel statistics: 30 complete tasks plus 30 paired withheld-file cases. Calculate the mean of paired current–voltage products and the product of channel means over a specified middle time window; distinguish the two.
• Recorded-state-gated gas reconstruction: 30 tasks. Integrate finite logged gas-flow values over positive robot-clock intervals with an explicit left-row hold rule and recorded arc_on == 1 gating.
• Sparse recorded-coordinate geometry: 30 tasks. Retain valid active TCP vertices, calculate path segments under a specified time-gap rule, and distinguish the included polyline length from endpoint displacement.
• Endpoint and cadence audit: 30 tasks. Inspect native integer process timestamps, locate the largest positive interval, and report sample and missing-value counts without assigning a physical cause.
• Electrical-statistic ledgers: five tasks. Compute a six-pass table within one workpiece and rank the prescribed leading-minus-trailing statistic with an explicit tie rule.
• Gas-reconstruction ledgers: five tasks. Compute and rank six-pass reconstructed gas quantities while preserving per-pass coverage information.

All answers describe recorded artifacts. An A·V product is not a validated physical-power or deposited-heat label. Logged flow reconstruction is not certified delivered volume, and recorded-coordinate geometry is not a robot action.

For each constructed withheld case, the required process file is absent from the allowed set and the same pass's robot file remains as a distractor. The correct response identifies insufficient evidence and the missing variables. Complete and withheld cases share prompt and schema alternatives; construction metadata is excluded from model inputs. File availability is deliberately simple to inspect, so these cases do not establish sophisticated uncertainty reasoning or natural missing-data rates.

Partitions

Partitions keep whole workpieces, all six passes and every constructed pair together:

• Train: WID615, WID617 and WID630 — 96 scientific tasks and 288 introductory examples.
• Validation: WID631 — 32 scientific tasks and 96 introductory examples.
• Test: WID632 — 32 scientific tasks and 96 introductory examples.

The independent physical unit is the workpiece. The 160 related questions do not constitute 160 independent experiments. Each held-out split contains only one workpiece.

Local evaluation

Run commands from the downloaded repository. The scientific calculations were validated with Python 3.12.14, NumPy 2.3.5 and h5py 3.16.0:

python3.12 -m venv .venv
.venv/bin/python -m pip install -r requirements.txt

Check the installation without a model call

demo_reference.py selects the first answerable training task, runs its supplied reference program through the OS sandbox, and grades the result outside that sandbox. It uses no API or credentials. On macOS, after installing the scientific environment above:

.venv/bin/python -B tools/demo_reference.py --root . \
  --sandbox-backend macos-seatbelt \
  --sandbox-python .venv/bin/python \
  --sandbox-extra-lib "$(.venv/bin/python -c 'import sysconfig; print(sysconfig.get_paths()["purelib"])')"

A successful run prints task_success: true, passed isolation checks, the calculated response and its source references, with model_calls: 0 and api_calls: 0. This checks the installation and supplied reference, not learned-model performance. --task-id accepts training tasks only; --help reads no data or executes any task. Linux users with the image built below can run .venv/bin/python -B tools/demo_reference.py --root . --sandbox-backend docker; that backend remains untested in the recorded release environment.

Evaluate model predictions

For blind evaluation, use benchmark/{split}.inputs.jsonl. Provide each model only that record and copies of exactly its allowed_files. Hashes and byte counts are verified by the supplied runner. Keep benchmark/tasks.jsonl, all answer files, reference programs, introductory summaries, results and audit records outside the model's task environment. Public distribution and runtime access are separate: the scorer may read gold; the task process may not.

Published model traces are held-out test-run artifacts. Training on them, test answers or test reference programs contaminates this test partition. Filter reference programs by the canonical task split before using training demonstrations.

Each final prediction is a JSONL row of this shape, using an actual task ID and that task's answer schema:

{"task_id":"<task ID>","response":{"status":"ok","answer":{},"evidence_files":[]},"execution_status":"answered"}

The empty answer above shows the wrapper only; it is not a valid solved example. Score a completed prediction file outside the model sandbox:

.venv/bin/python tools/score_benchmark.py \
  --tasks benchmark/tasks.jsonl \
  --predictions predictions.jsonl \
  --split test \
  --out scores.json

The output path must not already exist. Task success requires the correct response shape, status, all answer values and exact evidence paths. Floating-point fields use absolute tolerance 1e-4 and relative tolerance 1e-6; integer values, booleans and strings compare exactly. The scorer also reports answer-field accuracy, family/workpiece aggregates, answerable and withheld groups, and a top-level-shape invalid/missing rate. That last diagnostic checks the three response keys; nested content errors are captured by answer, status and task-success scores. List order matters for ledgers and rankings.

The provided hosted-model runner is configured by model-catalog.json; see run_models.py and the protocol before running paid calls. Provider configuration and its externally supplied API key stay in the trusted parent process, never in the Python task environment. --mode no_tools selects the tool-free control. Preserve run IDs, settings hashes, failures and completed coverage when reporting results.

The release preserves historical request accounting as results/request-accounting.json; it does not ship an active results/budget-ledger.json. A fresh downloaded release therefore starts a new spend ledger. Choose an unused run ID to preserve the published runs. Once JARVISLABS_API_KEY is supplied externally to the parent environment, this paid macOS command runs one test repeat with explicit runtime settings:

.venv/bin/python -B tools/run_models.py --root . \
  --inputs benchmark/test.inputs.jsonl \
  --model deepseek-v4-flash-0731 \
  --run-id local_deepseek_test_r1 \
  --sandbox-backend macos-seatbelt \
  --sandbox-python .venv/bin/python \
  --sandbox-extra-lib "$(.venv/bin/python -c 'import sysconfig; print(sysconfig.get_paths()["purelib"])')"

Repeat with unused IDs such as local_deepseek_test_r2 and local_deepseek_test_r3; retain the same input and settings. Score each results/<run-id>/predictions.jsonl externally with the command above. The configured spend ceiling is shared across runs within that checkout and is an application-side estimate. For Linux, replace the macOS runtime options with --sandbox-backend docker after building its image. The frozen run_evaluation.py records the coordinator used on the original host; it does not forward custom macOS runtime settings. Use the explicit per-run command for portable reproduction.

Execution isolation

All measured models shared one trusted runtime. It included additional installed libraries beyond the promised NumPy/h5py interface: xarray 2026.7.0, pandas 2.2.3 and h5netcdf 1.8.1. GLM used xarray in an import probe; the reviewed final calculations use NumPy/h5py. See the supplemental inventory and optional baseline extras. The minimal requirements reproduce reference calculations, not the complete original host image.

The runner executes Python only after a successful OS-isolation preflight. Every call starts a fresh interpreter with read-only copies of declared assets, temporary scratch space, a clean environment and no network. Variables and scratch outputs do not persist between calls.

On macOS, use --sandbox-backend macos-seatbelt, --sandbox-python for an explicit scientific interpreter and repeatable --sandbox-extra-lib options for specific trusted library directories. A virtual environment's package directory can be found with .venv/bin/python -c 'import sysconfig; print(sysconfig.get_paths()["purelib"])'. The interpreter and library directories must contain trusted runtime code only. Broad home-directory allowances are inappropriate. Runtime setup differs between Python distributions; an unsuccessful preflight prevents task execution.

For Linux reproduction, a Docker recipe is supplied:

docker build -t bam-scientific-python:local -f tools/Dockerfile .

Then use --sandbox-backend docker in the runner. Its local Docker engine must already be available. The harness never pulls an image silently and never falls back to unsandboxed execution. Docker execution was not tested for this release; the recorded runs used macOS Seatbelt. Pin the base image digest when establishing your own reproducible Docker environment.

Per Python call, the default limits are 30 seconds and 16 KiB combined stdout/stderr. macOS RSS and total scratch usage are sampled and terminated above their limits, not enforced as hard allocation quotas; per-file size and CPU/file-descriptor limits use hard rlimits. The Docker configuration uses container memory and scratch limits. See sandbox validation for tested behavior and caveats.

Validation and results

Task prompts and schemas were assembled programmatically from six task-family templates, with AI-assisted software development and review. Reference labels are deterministic calculations from the publisher's arrays, or constructed file-availability labels. No welding expert supplied new defect, quality or control annotations. Here, independent recomputation means a separate calculation implementation within this build; it is not external peer review or third-party certification.

Independent raw-array recomputation matched all 160 targets, including 600 floating-point leaves with a maximum absolute difference of approximately 2.5e-12. The raw calculations were recorded before comparing against builder targets or reference implementations. Independent audit

All 160 reference programs were then executed under actual macOS Seatbelt with only their declared files, passed per-run isolation probes and matched targets using the external scorer. Oracle/harness receipt

Those are implementation checks, not model scores. Consult RESULTS.md for measured model coverage, settings, costs and limitations. A benchmark's difficulty and model discrimination must be established by measured runs; this dataset makes no claim of being frontier-hard or introducing a new evaluation paradigm. Related work places its scope alongside recent scientific-agent evaluations.

Offline harness regression tests are included in tests/test_harness.py.

Limitations and intended use

• Five workpieces, shared task templates, within-workpiece evidence reuse and a single test workpiece severely limit generalization claims. Do not attach an independent-sample confidence interval to the 160 task rows.
• Raw data and answers are public. Workpiece separation and a clean runtime cannot prove absence of prior model contamination or memorization.
• In these inspected files, middle-window paired electrical samples and active gas flows are finite; retained active TCP gaps are all at most 8 ms. The corresponding defensive rules are specified but do not provide broad missingness or irregular-sampling coverage. Audit limitations
• Thirty withheld cases are synthetic availability tests. Their proportion does not estimate missing-file prevalence in industry. Failure to provide an omitted file is not evidence of a physical process failure.
• Tasks do not provide expert weld-defect labels, mechanical outcomes, registered scan changes, calibrated process efficiency or safe robot-control targets. No video is required. These scores cannot certify a weld, a physical system or a control policy.
• The introductory configuration exposes precomputed summaries and has a different evidence burden. It is useful for format familiarization and structured reporting; it is not a substitute for the raw-file benchmark.

Intended uses are reproducible experiments on file inspection, numerical analysis, evidence citations and explicitly bounded abstention, plus introductory structured-evidence SFT. Useful extensions include additional independent workpieces, deliberately exercised numerical edge cases, and separately reviewed expert annotations with clear rights and provenance.

Attribution and license

Source data and the derivative task/annotation data are licensed under CC BY 4.0. Newly authored software in tools/ and tests/ is licensed separately under MIT. See LICENSE, LICENSE-CODE and ATTRIBUTION.md, including the required source citation and description of changes.

Please cite the original source dataset and identify the version or commit of this derivative in any reported results. There is no paper or DOI assigned to this derivative in this release.

@dataset{chaurasia_2026_tandem_gmaw,
  author = {Chaurasia, Prashant Kumar and Fabry, Çağtay and
            Pittner, Andreas and Rethmeier, Michael},
  title = {Tandem-GMAW: advanced pulsed and short-circuiting process mode experimental data},
  year = {2026},
  version = {v2.0.0},
  publisher = {Zenodo},
  doi = {10.5281/zenodo.21824586},
  url = {https://zenodo.org/records/21824586}
}