Datasets:

renderfy
/

longhaul-bench

license: mit
language:
  - en
pretty_name: LongHaul-Bench
size_categories:
  - 1K<n<10K
task_categories:
  - text-generation
  - question-answering
tags:
  - agents
  - llm-agents
  - agent-memory
  - benchmark
  - long-horizon
  - industrial
  - fault-diagnosis
  - edge-ai
  - synthetic
configs:
  - config_name: v0-standard
    default: true
    data_files:
      - split: test
        path: longhaul-v0-standard/episodes.jsonl
  - config_name: v0-hard
    data_files:
      - split: test
        path: longhaul-v0-hard/episodes.jsonl
  - config_name: v1-standard
    data_files:
      - split: test
        path: longhaul-v1-standard/episodes.jsonl

LongHaul-Bench

Does a self-improving LLM agent get better or slowly rot over ~1,000 sequential tasks? LongHaul-Bench is a seed-reproducible synthetic industrial fault-diagnosis environment for measuring the long-horizon reliability of agents that learn from their own experience, under edge constraints (quantized small model, hard memory budget, offline).

Paper (preprint): doi:10.5281/zenodo.23624799
Code, harness, run logs, analysis scripts: github.com/vahit19/longhaul-bench

Dataset structure

Each release is one synthetic plant (five machine types, 15 component types, 16 failure modes) plus a stream of 1,000 diagnostic episodes, generated from seed 42.

Config	Episodes	Difficulty	Notes
`v0-standard` (default)	1,000	log dropout 0.3, symptom dropout 0.3	all paper results use this tier
`v0-hard`	1,000	log dropout 0.7, symptom dropout 0.5
`v1-standard`	1,000	standard knobs	fault frequencies calibrated to the AI4I 2020 dataset

An LLM-free 91-line heuristic scores 99.9% / 86.3% / 73.3% exact accuracy on the easy / standard / hard tiers.

episodes.jsonl (loaded by the configs above), one episode per line:

Field	Description
`episode_id`	e.g. `E00001`; episodes are meant to be run in order
`machine_id`	machine the fault occurs on
`alarms`	list of `{code, message}`
`log_excerpt`	HMI/PLC-style log lines (subject to dropout)
`operator_note`	free-text note
`ground_truth`	`{component, failure_mode, repair}`: for scoring only, never show it to the agent

world.json (per release, not loaded by the configs): the agent's tool corpus, with the alarm-code table, per-machine troubleshooting manual excerpts (the retrieval corpus), and maintenance history. The three releases share the same world file.

from datasets import load_dataset
from huggingface_hub import hf_hub_download
import json

episodes = load_dataset("renderfy/longhaul-bench", "v0-standard", split="test")
world = json.load(open(hf_hub_download("renderfy/longhaul-bench", "longhaul-v0-standard/world.json",
                                        repo_type="dataset")))

File integrity: SHA256SUMS matches the canonical files in the GitHub repository.

Protocol

The agent sees alarms, the log excerpt, and the operator note; it may call alarm_lookup, manual_search, and maintenance_history over world.json, and must output a JSON diagnosis (component + failure mode), scored by exact match. After each episode the environment returns outcome feedback that an improvement operator may write into a bounded experience memory (100 records in the paper). Feedback can be corrupted with plausible wrong diagnoses to test knowledge rot. The full harness is in the GitHub repository.

Reference results (paper, Qwen2.5-3B-Instruct Q4_K_M, five worlds)

Arm	Exact accuracy (mean over 5 worlds)
frozen (no learning)	58.2%
append memory	62.0%
reflect memory	61.3%
reflect + 40% plausible corrupted feedback	55.3%
same, with manual-consistency gates	61.3%
manual oracle (correct manual row given)	76.8%

Memory helps only when recall surfaces the correct precedent often enough: in the paper's recall-precision decomposition the break-even recall precision is about 0.7, and plausible corruption causes rot mainly by lowering that precision (0.81 → 0.72 → 0.65 at 0/20/40% corruption).

Limitations

The environment is template-generated: fault frequencies can be calibrated to public data (v1), but symptom and log text are synthetic, and on the standard tier the LLM-free heuristic floor exceeds the 3B agent's oracle ceiling. Results characterize memory dynamics, not absolute diagnostic competence. No proprietary or employer data is used.

Citation

@misc{feryad2026longhaul,
  title     = {LongHaul-Bench: A Reproducible Benchmark for Long-Horizon Reliability of Self-Improving LLM Agents Under Industrial Edge Constraints},
  author    = {Feryad, Vahit},
  year      = {2026},
  publisher = {Zenodo},
  doi       = {10.5281/zenodo.23624799},
  url       = {https://doi.org/10.5281/zenodo.23624799}
}