---
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](https://doi.org/10.5281/zenodo.23624799)
- **Code, harness, run logs, analysis scripts:** [github.com/vahit19/longhaul-bench](https://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.

```python
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

```bibtex
@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}
}
```