Datasets:

TanmaySah
/

undobench

pretty_name: UndoBench
license: cc-by-4.0
tags:
  - agentic-ai
  - llm-agents
  - ai-agents
  - agent-evaluation
  - recovery
  - reliability
  - fault-tolerance
  - tool-use
  - ai-safety
  - benchmark
papers:
  - 2610.05622
configs:
  - config_name: default
    default: true
    data_files:
      - split: dev
        path: data/dev.parquet
      - split: validation
        path: data/validation.parquet
      - split: test
        path: data/test.parquet

UndoBench

Separating Task Competence from Recovery Capability in Tool-Using AI Agents

UndoBench is an open benchmark for measuring recovery capability and side-effect safety in tool-using AI agents under execution failures. Widely used agent benchmarks primarily evaluate nominal task completion, conflating baseline planning competence with operational fault recovery. UndoBench decouples task competence from recovery capability via counterfactual paired trials under identical seeds alongside wire-level effect-history and environment-state oracles.

The benchmark spans 36 base enterprise workflows and 36 fault scenarios across 8 enterprise software domains, evaluating agents across multiple execution boundaries (pre-mutation, during-mutation, and post-mutation / lost-acknowledgment).

Authors

Dolly Sah
Tanmay Sah
Harshul Jain
Tanya Sah

(Note: Hosted under personal Hugging Face namespace TanmaySah for dataset discovery; scholarly authorship belongs to all four authors in the canonical order listed above).

Paper & Links

Paper (arXiv): https://arxiv.org/abs/2610.05622
Hugging Face Paper Page: https://huggingface.co/papers/2610.05622
alphaXiv: https://www.alphaxiv.org/abs/2610.05622
Code & Benchmark Execution Framework: https://github.com/tradertanmay/undobench

The Hugging Face repository contains the task-oriented dataset representation of UndoBench. The complete benchmark execution framework, CLI, fault injection engine, recovery baselines, evaluation harness, and reproduction code are available on GitHub.

Benchmark Structure

UndoBench consists of 36 canonical workflows stratified across 3 splits and 8 enterprise operational domains:

Split	Workflows	Purpose
`dev`	14	Open development, prompt tuning, and strategy formulation
`validation`	10	Hyperparameter calibration and recovery policy validation
`test`	12	Frozen held-out evaluation for zero-shot recovery benchmarking
Total	36	Comprehensive enterprise recovery evaluation

The 8 Enterprise Domains

Cloud Infrastructure (Autoscaling, VPC routing, IAM policies, Blue-green deployment cutover)
Customer Relationship Management (CRM) (Lead conversion, account reassignment, deal stage transitions, SLA renewal)
Database Transactions (Balance transfers, multi-table orders, tier upgrades, schema migration, RMW dividend allocations)
Git Version Control (Fast-forward merge, hotfix commits, squashed merges, release tag cut and cherry-picks)
Messaging Systems (Direct dispatch, channel topics, broadcast announcements, pager callouts, webhook fanout)
Payments & Billing (Card tokenization, invoice capture, refund authorization, subscription renewal, cross-border wires)
Storage & Blob Management (File checksum uploads, lifecycle expiration, CORS rules, bucket replication, atomic object swaps)
Ticketing & Incident Management (Priority escalation, ticket assignment, incident resolution, SLA policy cascades)

Dataset Row Schema

Each row in the dataset represents a canonical UndoBench workflow task:

Column	Type	Description
`task_id`	`string`	Unique benchmark task identifier (e.g., `RB-DB-001`, `RB-CLOUD-004`)
`split`	`string`	Split membership (`dev`, `validation`, or `test`)
`domain`	`string`	Enterprise software domain (e.g., `database`, `cloud`, `payments`)
`workflow_name`	`string`	Formal workflow name with failure scenario context
`workflow_description`	`string`	Human-readable baseline workflow description
`objective`	`string`	Exact natural-language task prompt provided to the agent
`fault_scenario`	`string` (JSON)	Structured fault scenario specification (boundary, perturbation, target tool)
`fault_boundary`	`string`	Execution boundary (`PRE_MUTATION`, `POST_MUTATION_PRE_ACK`, etc.)
`reversibility`	`string`	Action reversibility classification (`REVERSIBLE`, `COMPENSATABLE`, `IRREVERSIBLE`)
`idempotency_support`	`bool`	Whether the underlying environment natively supports server-side idempotency keys
`tools`	`list[string]`	Set of callable environment tools available to the agent
`initial_state`	`string` (JSON)	Environment state prior to task execution
`expected_outcome`	`string` (JSON)	Acceptable final environment states required for nominal completion
`required_effects`	`string` (JSON)	Wire-level state mutations that must occur exactly once
`oracle_spec`	`string` (JSON)	Complete oracle specification (final states, forbidden effects, invariants)
`benchmark_version`	`string`	Benchmark freeze version (`v1.0.1`)
`source_path`	`string`	Relative path to task implementation in the canonical GitHub repository

Usage

from datasets import load_dataset

# Load all 3 splits of UndoBench
ds = load_dataset("TanmaySah/undobench")
print(ds)

# Inspect splits
print(f"Dev tasks: {len(ds['dev'])}")
print(f"Validation tasks: {len(ds['validation'])}")
print(f"Test tasks: {len(ds['test'])}")

# Access a test task
sample = ds["test"][0]
print("Task ID:", sample["task_id"])
print("Domain:", sample["domain"])
print("Objective:", sample["objective"])
print("Tools:", sample["tools"])

To run full agent evaluations with fault injection, wire-level oracle verification, and CRSR metrics, clone the GitHub repository:

git clone https://github.com/tradertanmay/undobench.git
cd undobench
pip install -e .
undobench run --split test --model <your-model> --recovery naive_retry

Licensing

Dataset & Task Specifications: Creative Commons Attribution 4.0 International (CC BY 4.0)
Software, CLI & Execution Harness: Apache License 2.0

Citation

@article{undobench2026,
  title   = {UndoBench: Separating Task Competence from Recovery Capability in Tool-Using AI Agents},
  author  = {Dolly Sah and Tanmay Sah and Harshul Jain and Tanya Sah},
  journal = {arXiv preprint arXiv:2610.05622},
  year    = {2026},
  url     = {https://arxiv.org/abs/2610.05622}
}