Datasets:

TanmaySah
/

undobench

@@ -28,258 +28,104 @@ configs:
 **Separating Task Competence from Recovery Capability in Tool-Using AI Agents**
-**Dolly Sah** · **Tanmay Sah** · **Harshul Jain** · **Tanya Sah**
-*(Hosted under personal namespace `TanmaySah/undobench`; scholarly authorship belongs to all four authors).*
----
 ## Overview
-Can an AI agent recover when a tool operation may have succeeded, but the agent never received the acknowledgment?
-If it retries blindly, it may duplicate a payment, repeat an update, or leave an external system in an inconsistent state.
-UndoBench measures whether tool-using AI agents can recover safely from execution failures without duplicating, losing, or corrupting externally visible effects.
-### Task Competence ≠ Recovery Capability
-Widely used AI agent benchmarks primarily evaluate nominal task completion, conflating baseline planning competence with operational fault recovery. When an agent fails during a task with transport faults, standard evaluation cannot distinguish whether the agent lacked the planning ability to solve the task or lacked the operational resilience to recover from failure.
-UndoBench decouples task competence from recovery capability via **counterfactual paired evaluation**: every workflow is evaluated under identical seeds—once under nominal conditions (**CONTROL**) and once under transport fault injection (**FAULT**). This establishes **Conditional Recovery Success Rate (CRSR)** as a competence-conditioned measure of recovery success.
----
 ## Benchmark at a Glance
-* **36** Canonical Enterprise Workflows
-* **8** Enterprise Operational Domains
-* **3** Standard Splits:
-  * **14** `dev` workflows
-  * **10** `validation` workflows
-  * **12** `test` workflows
-* **Benchmark Freeze Version**: `v1.0.1`
----
-## Conceptual Failure Lifecycle
-```text
-Agent
-  │
-  │ tool request
-  ▼
-External System
-  │
-  ├── mutation commits
-  │
-  X acknowledgment lost
-  │
-  ▼
-Agent sees uncertainty
-  │
-  ├── blind retry → possible duplicate effect
-  │
-  └── safe recovery → verify / deduplicate / abstain
-```
----
-## Illustrative Example: Lost Payment Acknowledgment
-Consider an agent managing an accounts-payable workflow:
-1. An agent requests a payment.
-2. The payment provider commits the payment.
-3. The acknowledgment is lost before the agent receives it.
-4. The agent sees an apparent failure and must decide what to do.
-* **Unsafe recovery**: Retry blindly → the payment may be executed twice.
-* **Safe recovery**: Determine whether the original effect already occurred, use an idempotent operation where available, or abstain rather than create an unsafe duplicate.
-*(This is an illustrative UndoBench-style scenario. UndoBench spans 8 enterprise domains, including cloud, database, git, CRM, messaging, ticketing, and storage operations).*
----
-## Quickstart & Loading
 ```python
 from datasets import load_dataset
-# Load all 3 splits of UndoBench
 ds = load_dataset("TanmaySah/undobench")
-print(ds)
-# Inspect sample test workflow
 print(ds["test"][0])
 ```
-Expected split counts:
-```text
-dev        14
-validation 10
-test       12
-```
----
 ## What Does One Row Represent?
-Each Hugging Face row represents **one canonical UndoBench workflow specification**.
-The 36 rows are benchmark task definitions, **not** 36 individual model executions and **not** aggregate experimental results.
-* **Workflow specification**: Canonical task and environment definition (domain, objective, callable tools, initial state setup).
-* **Fault metadata**: Where and how transport-level execution failures are injected across boundaries.
-* **Experimental execution**: A specific (model × recovery method × framework × seed × condition) execution trajectory.
-The Hugging Face dataset publishes the workflow specifications and fault/oracle metadata. Full experimental trajectories, execution logs, and multi-model benchmark results remain reproducibility artifacts in the GitHub repository.
----
-## Dataset Splits
-| 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 |
-| **Total** | **36** | **Comprehensive enterprise recovery evaluation** |
-### Status of the TEST Split
-The `test` split was strictly held out from method development and hyperparameter tuning during the reported frozen evaluation experiments. Now that the benchmark has been publicly released, the `test` specifications are released in this dataset for transparency and community reproducibility. This public availability does not retroactively alter the held-out experimental protocol under which baseline and model evaluations were performed.
----
-## Dataset Schema
-Each row contains the following 17 fields:
 | 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 |
----
-## Agent-Visible vs. Evaluator-Only Fields
-The dataset distinguishes between information available to evaluated agents and information reserved for benchmark evaluation and scoring:
-* **Agent-Visible Inputs (Runtime)**:
-  * `task_id`: Benchmark task identifier
-  * `domain`: Enterprise domain classification
-  * `objective`: Natural-language task instruction defining the agent's goal
-  * `tools`: Names and callable function signatures of available environment tools
-  * *Runtime Tool Responses*: Ordinary return values and error signals generated by executed tools during the trial
-* **Benchmark & Evaluator Metadata**:
-  * `split`: Dataset partition assignment (`dev`, `validation`, `test`)
-  * `workflow_name`, `workflow_description`: Human-readable task documentation
-  * `fault_scenario`: Evaluator fault injection specification (injected boundary, perturbation type, target tool index). This is benchmark metadata used by the evaluation harness to orchestrate faults, not provided to the agent.
-  * `fault_boundary`: Execution boundary classification
-  * `reversibility`: Reversibility classification of workflow actions
-  * `idempotency_support`: Native environment idempotency support flag
-  * `benchmark_version`, `source_path`: Provenance and reference implementation location
-* **Evaluator-Only Information**:
-  * `initial_state`: Underlying sandbox initial state setup
-  * `expected_outcome`: Target environment state assertions
-  * `required_effects`: Wire-level mutations that must occur exactly once
-  * `oracle_spec`: Invariants, assertions, and forbidden mutation predicates
-> **Important**: Evaluated agents receive only the public task objective, allowed tool interfaces, and ordinary runtime tool responses. They do **not** receive evaluator oracles, expected-outcome assertions, hidden state diffs, or privileged scoring information. Oracle and expected-outcome fields are published here solely for benchmark transparency and evaluation reproducibility.
----
-## Failure Boundaries & Evaluation Scope
-UndoBench defines a formal execution lifecycle for agent tool mutations:
-1. `PRE_MUTATION`: Fault occurs before the external system mutates state (e.g., transient network timeout).
-2. `DURING_MUTATION`: Fault occurs during composite execution (partial multi-step mutation).
-3. `POST_MUTATION_PRE_ACK`: Mutation commits on the external system, but the acknowledgment is dropped before reaching the agent (lost ACK).
-4. `POST_ACK_PRE_CHECKPOINT`: Acknowledgment arrives, but agent worker crashes before local state is persisted.
-5. `DURING_COMPENSATION`: Failure occurs during a compensating backward transaction.
-### Primary Frozen Evaluation vs. Secondary Extensions
-* **Reported Frozen Primary Evaluation**: The primary frozen benchmark study across models, frameworks, and recovery baselines specifically evaluates the `POST_MUTATION_PRE_ACK` boundary—the critical lost-acknowledgment regime where external state is mutated but unacknowledged.
-* **Post-Freeze Secondary Extensions**: Additional targeted experiments evaluate complementary boundaries (`PRE_MUTATION` and `DURING_MUTATION`) to map phase-dependent recovery behavior.
-* **Lifecycle Taxonomy Boundaries**: `POST_ACK_PRE_CHECKPOINT` and `DURING_COMPENSATION` are lifecycle taxonomy boundaries that were not evaluated with the same real experimental sweeps.
----
-## Recovery Mechanisms & Phase-Dependence
-Safe recovery is inherently phase-dependent: no single recovery mechanism resolves all failures:
-* **Idempotency**: Server-side idempotency keys protect against duplicate execution under lost ACKs, but require server-side support.
-* **Reconciliation & Journaling**: Local mutation journals help track intended versus dispatched calls without server privileges.
-* **Non-Mutating Verification**: Read-only observation before retrying can detect whether a previous mutation committed.
-* **Compensation**: Sagas and compensating actions rollback effects, but only where operations are semantically compensatable.
-* **Cautious Abstention**: When ambiguity cannot be resolved safely, abstaining prevents catastrophic duplicate external mutations.
-Which mechanism works depends on the failure phase and what information and interfaces are available.
----
-## Evaluation Methodology & Metrics
-UndoBench evaluates pairs of runs under identical random seeds:
-* Nominal trial: $C_i \in \{0, 1\}$ (Task Competence Oracle)
-* Faulted trial: $F_i \in \{0, 1\}$ (Recovery Success Oracle)
-### Metrics Formalism
-* **Nominal Control Competence ($D$)**: Total trials where the agent successfully completes the task under nominal execution without faults:
-  $$D = \sum_{i=1}^N C_i$$
-* **Unconditional Recovery Success Rate (RSR)**: Overall task completion rate under fault injection across all $N$ trials:
-  $$\text{RSR} = \frac{\sum_{i=1}^N F_i}{N}$$
-* **Conditional Recovery Success Rate (CRSR)**: Recovery success rate strictly among the subset of trials that succeed under nominal CONTROL:
-  $$\text{CRSR} = \frac{\sum_{i=1}^N C_i F_i}{\sum_{i=1}^N C_i} = \frac{\sum_{i=1}^N C_i F_i}{D}$$
-* **Exactly-Once Semantic Effect Rate (EOR)**: Task completion where the intended semantic effect occurs exactly once with zero duplicate or missing effects.
-* **Duplicate Effect Rate (DER)**: Rate of hazardous duplicate mutations (e.g., duplicate payments, duplicate tags).
-* **Missing Effect Rate (MER)**: Rate of abandoned or uncommitted workflow goals.
-* **Unsafe Retry Rate (URR)**: Overall rate of side-effect safety violations.
----
-## Paper & Links
-* **Paper (arXiv)**: [https://arxiv.org/abs/2610.05622](https://arxiv.org/abs/2610.05622)
-* **Hugging Face Paper Page**: [https://huggingface.co/papers/2610.05622](https://huggingface.co/papers/2610.05622)
-* **alphaXiv**: [https://www.alphaxiv.org/abs/2610.05622](https://www.alphaxiv.org/abs/2610.05622)
-* **Code & Benchmark Execution Framework**: [https://github.com/tradertanmay/undobench](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.
----
 ## Citation
 ```bibtex
 @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}
 }
 ```
----
-## Licensing
-* **Dataset & Task Specifications**: [Creative Commons Attribution 4.0 International (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/)
-* **Software, CLI & Execution Harness on GitHub**: [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0)

 **Separating Task Competence from Recovery Capability in Tool-Using AI Agents**
+**Dolly Sah · Tanmay Sah · Harshul Jain · Tanya Sah**
 ## Overview
+UndoBench is a benchmark for evaluating whether tool-using AI agents can recover safely from execution failures without duplicating, losing, or corrupting externally visible effects.
+The benchmark separates **task competence** from **recovery capability** using paired CONTROL and FAULT executions. It includes 36 enterprise workflows across 8 domains, with explicit fault scenarios and state/effect oracles for evaluation.
 ## Benchmark at a Glance
+| | |
+|---|---:|
+| Workflows | 36 |
+| Domains | 8 |
+| DEV | 14 |
+| Validation | 10 |
+| Test | 12 |
+| Benchmark version | v1.0.1 |
+## Quickstart
 ```python
 from datasets import load_dataset
 ds = load_dataset("TanmaySah/undobench")
+print(ds)
 print(ds["test"][0])
 ```
 ## What Does One Row Represent?
+Each row represents one canonical UndoBench workflow specification.
+The 36 rows are benchmark task definitions, not individual model executions or aggregate experimental results.
+Each workflow includes the task objective, available tools, fault metadata, environment/evaluation metadata, and provenance.
+Full benchmark execution code and reproducibility artifacts are available in the GitHub repository.
+## Dataset Structure
+| Split | Workflows |
+|---|---:|
+| `dev` | 14 |
+| `validation` | 10 |
+| `test` | 12 |
+### Schema
 | Column | Type | Description |
+|:---|:---|:---|
+| `task_id` | `string` | Unique workflow identifier |
+| `split` | `string` | `dev` / `validation` / `test` |
+| `domain` | `string` | Enterprise domain |
+| `workflow_name` | `string` | Canonical workflow title |
+| `workflow_description` | `string` | Baseline workflow description |
+| `objective` | `string` | Agent task instruction |
+| `fault_scenario` | `string` (JSON) | Fault-injection specification |
+| `fault_boundary` | `string` | Failure lifecycle boundary |
+| `reversibility` | `string` | Action reversibility class |
+| `idempotency_support` | `bool` | Native idempotency support |
+| `tools` | `list[string]` | Available tools |
+| `initial_state` | `string` (JSON) | Evaluator environment setup |
+| `expected_outcome` | `string` (JSON) | Expected final-state assertions |
+| `required_effects` | `string` (JSON) | Required semantic effects |
+| `oracle_spec` | `string` (JSON) | Evaluation oracle |
+| `benchmark_version` | `string` | Benchmark version (`v1.0.1`) |
+| `source_path` | `string` | Canonical implementation path |
+## Important Evaluation Note
+Fields such as `initial_state`, `expected_outcome`, `required_effects`, `oracle_spec`, and fault-injection metadata are published for transparency and reproducibility. They are evaluator metadata and are **not privileged inputs supplied to the evaluated agent**.
+At runtime, agents receive the task objective, permitted tool interfaces, and ordinary tool responses.
+For the full evaluation protocol, recovery metrics, failure-boundary taxonomy, and experimental results, see the paper and GitHub repository.
+## Paper & Code
+* **Paper:** https://arxiv.org/abs/2610.05622
+* **Hugging Face Paper:** https://huggingface.co/papers/2610.05622
+* **Code:** https://github.com/tradertanmay/undobench
 ## Citation
 ```bibtex
 @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}
 }
 ```
+## License
+Dataset and benchmark specifications: **CC BY 4.0**
+Software and execution framework: **Apache 2.0**