Datasets:

Fektor
/

OnCallVal

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:

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.
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.
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:

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. Design rationale and positioning: 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

@dataset{Fektor2026oncallval,
  title  = {OnCallVal: Agentic On-Call Operations with Verified End States},
  author = {Fektor},
  year   = {2026},
  version = {0.1.0}
}