File size: 7,265 Bytes
6655381 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 | ---
license: cc-by-4.0
task_categories:
- other
language:
- en
size_categories:
- n<1K
pretty_name: OnCallVal
configs:
- config_name: default
data_files:
- split: test
path: test.parquet
tags:
- agentic
- agents
- benchmark
- operations
- sre
- incident-response
- tool-use
- evaluation
---
# OnCallVal
**One alert page in. One verified remediation out.**
OnCallVal is a benchmark for the part of operations that demos usually skip: being on call. The agent gets one alert page, a simulated production fleet, and a finite action budget. It must diagnose the root cause, apply the minimal correct mitigation, and submit a report without touching anything that was healthy.
Scoring inspects the **final state of the world**, not the agent's prose or transcript. An agent that fixes the broken service but rolls back a healthy one fails. An agent that fixes nothing but writes a confident report fails.
## At a glance
| | |
|---|---|
| Episodes | **200** |
| Fault families | **8** × 25 |
| Difficulty | **80 medium**, **80 hard**, **40 severe** |
| Decoy types | **3** (irrelevant deploy, known-issue noise, cosmetic slow endpoint) |
| Interface | **15-action API** (7 reads, 7 mutations, submit_report); reads cost budget |
| Primary metric | **resolved** (binary): root cause ∧ mitigated ∧ no collateral |
| Diagnostics | report_valid, faults_still_active, collateral_violations, actions_used, budget_exhausted |
## Why it exists
Tool-agent benchmarks score end state (τ-bench scores a database), but they score customer-service edits where the blast radius of a mistake is one order record. Real operational work is defined by blast radius: the fix that solves your incident and takes down checkout is worse than no fix. OnCallVal makes collateral damage a first-class, scored dimension.
Three properties define the difficulty:
1. **End-state verification, not transcript review.** The scorer reads only the final world state and the submitted report. No output repair, no partial credit. Two agents that reach the same fixed world by different routes both score 1.
2. **Causal difficulty tiers.** Every episode declares its injected faults and decoys with weights; tier is a pure function of the weight (`medium` 2–4, `hard` 5–7, `severe` 8+). Severe episodes carry two disjoint faults, both of which must be mitigated.
3. **Collateral damage is scored.** Every healthy service must end untouched: version, config, replica count, secrets unchanged. The time-correlated innocent deploy is the standard trap.
## What's in a row
| Column | Type | Meaning |
|---|---|---|
| `task_id` | string | stable id, e.g. `oncallval-bad_deploy-0000` |
| `family` | string | one of the eight fault families |
| `difficulty` | string | `medium` / `hard` / `severe`, derived from declared weights |
| `tier_weight` | int | declared fault + decoy weight |
| `budget` | int | action budget (26 / 32 / 40) |
| `alert` | string | the page the agent starts from |
| `spec` | string | JSON world definition consumed by the environment |
`spec` contains the fault declarations the environment needs to simulate the world deterministically. Scoring truth is derived from `spec` by `code/oncallval/score.py`. There is no answer file. **The agent must never see `spec`**: it sees only the alert and the observations its actions return. Any harness that shows the agent the row is measuring nothing.
## Running and scoring it
The bundle ships the environment and the scorer, so this is self-contained:
```bash
pip install pyarrow # only for reading the parquet; the code itself is stdlib-only
python - <<'PY'
import json, pyarrow.parquet as pq
from code.oncallval.env import Episode
from code.oncallval.score import score_episode, truth_from_spec
rows = pq.read_table("test.parquet").to_pylist()
task = dict(rows[0]); task["spec"] = json.loads(rows[0]["spec"])
ep = Episode(task)
print(ep.system_prompt()) # the page + the action API
ep.step({"action": "list_services"})
ep.step({"action": "submit_report", "cause": "bad_deploy:public-gw", "fix_summary": "guess"})
print(score_episode(ep, truth_from_spec(task)))
PY
```
For any OpenAI-compatible endpoint, `code/oncallval/harness.py` runs the full multi-turn loop (greedy, no output repair).
## Baselines
Nine episodes per family, 72 total (24 medium / 32 hard / 16 severe):
| Model | resolved | root_cause | mitigated | no_collateral | actions/episode |
|---|---:|---:|---:|---:|---|
| Qwen2.5-7B-Instruct | **2/72 (2.8%)** | 8/72 | 2/72 | 72/72 | 5–13 |
| Qwen2.5-3B-Instruct | 0/72 | 16/72 | 0/72 | 72/72 | 2–8 |
| Qwen2.5-1.5B-Instruct | 0/72 | 10/72 | 1/72 | 72/72 | 0–4, or loops to budget |
By tier at 7B: medium 1/24, hard 1/32, severe 0/16. Only `capacity_shortfall` was solved (2/9).
Where they fail:
- Diagnosis is not the bottleneck; action is. The 7B named the right fault 8 times and mitigated twice. The 3B named it 16 times and attempted one fix. On `bad_deploy` the 7B restarts or scales in all 9 episodes and never rolls back.
- They stop early. The 7B submits after 5–13 actions against a 26–40 budget. It is not running out of room; it stops investigating.
- Nothing breaks. `no_collateral` passes 72/72 for all three models: weak agents fail by doing too little, not too much.
- The failure changes shape with size. The 1.5B cannot sustain the protocol, the 3B diagnoses but never acts, and the 7B stops short of the correct fix.
## Fault families
`bad_deploy`, `memory_leak`, `config_drift`, `dependency_outage`, `capacity_shortfall`, `secret_expiry`, `poison_message`, `host_failure`, and three decoy types. Full signatures, minimal fixes and weights: [`docs/TAXONOMY.md`](docs/TAXONOMY.md). Design rationale and positioning: [`docs/DESIGN.md`](docs/DESIGN.md).
## Limitations
- The fleet is small (≤7 services, ≤6 hosts). Real incidents span hundreds of services.
- Metrics are instantaneous state derivations with light noise, not time series; agents cannot trend a metric over an hour.
- The action API is deliberately small: no canary deploys, feature flags, or traffic shaping.
- One defensible fix per fault, but any remediation that makes the fault's state predicate pass scores.
- Severity is simulated; nothing here measures incident communication with humans.
## Contamination policy
The public split is frozen. A held-out split with identical families and tier balance exists under a private seed and is never published. The generator is not published, so the split cannot be regenerated or extended from this bundle. Standard caveat: a held-out split prevents answer memorization, not style overfitting to the generator.
## Usage policy
- Do not train on the test split and report the result as held-out performance. Disclose training use.
- Do not use this benchmark as evidence that an agent is safe for production on-call duty.
## Citation
```bibtex
@dataset{Fektor2026oncallval,
title = {OnCallVal: Agentic On-Call Operations with Verified End States},
author = {Fektor},
year = {2026},
version = {0.1.0}
}
```
Code is Apache-2.0, data is CC BY 4.0. Copyright Fektor.
|