# OnCallVal design

## Positioning

| Benchmark | Domain | What is scored | Missing |
|---|---|---|---|
| τ-bench / τ²-bench | airline/retail/telecom customer service | final database state + policy compliance | single-record edits; no blast radius; benign failures |
| TheAgentCompany | generic office work | task completion in a fake company | long-horizon but low-stakes; no systems state |
| SWE-bench | code repair | tests pass on a repo | it is coding, and it is static |
| LifeVal (OpenAI) | everyday life | workflow completion | proprietary, unverifiable, life domain |
| **OnCallVal** | **infrastructure operations** | **final world state: cause + mitigation + side effects** | |

The differentiator is **collateral damage as a scored dimension**. In
customer-service benchmarks a wrong action touches one record. In operations a
wrong action takes down unrelated services. OnCallVal's `no_collateral`
predicate makes the difference between a fix and a lucky fix measurable.

## Design principles

1. **State, not scripts.** Metrics, logs, and alerts are derived from world
   state at query time. There is no scripted incident timeline to memorize;
   the agent that fixes the state sees the metrics recover. This also makes
   every episode replayable and the scorer environment-side.
2. **Declared difficulty.** Faults and decoys are declared per episode with
   weights; tier is a pure function of weight. The tier can never disagree
   with the content of the task (enforced by test).
3. **End-state scoring.** The scorer inspects only the final world and the
   submitted report. It never reads the transcript, never repairs output, and
   never grants partial credit on `resolved`. Path efficiency is reported as
   diagnostics only. Two correct fixes with different routes both score 1.
4. **Fairness through runbooks.** Every service ships a runbook containing the
   recommended config values, the capacity formula, and known issues. Tasks
   never require guessing a magic value: the healthy state is always
   discoverable in-world.
5. **Budget pressure on triage.** Reads cost budget. A model that dumps every
   service's state runs out of actions before it can fix anything. Diagnosis
   must be directed, which is the actual on-call skill.

## Difficulty calibration

No target range is published, because none has been measured. The observed
ladder is 3B at 0/72 and 7B at 2/72 on the 72-task slice. Calibration is a
falsifiable rule rather than a hoped-for number:

- frontier-class agent above ~70% overall -> too easy: more decoys, more
  two-fault episodes;
- below ~10% -> validate the tasks before raising difficulty (is the fix
  discoverable in-world? does the runbook actually contain the healthy value?);
- in between -> tier monotonicity must hold (medium > hard > severe); if it
  breaks, the weights are wrong.

If real baselines land above target, tighten budgets before adding fault
complexity; if far below, add runbook hints before simplifying faults.

## Known limitations

- The fleet is small (≤7 services, ≤6 hosts). Real incidents span hundreds of
  services; context-window economics push back. Scale is the obvious v2 axis.
- Metrics are instantaneous derivations with light noise, not time series.
  Agents cannot trend a metric over an hour; they see now-values and logs.
- The action API is deliberately small (15 actions). Real remediation includes
  canary deploys, feature-flag rollouts, and traffic shaping.
- One defensible fix per fault. A creative but valid alternative remediation
  that defeats the fault's `active()` predicate also scores 1. That is by design.
- Severity is simulated. Nothing here measures whether an agent communicates
  well with humans during an incident.

## Reproducibility

`data/tasks.jsonl` is frozen. Regenerating with the shipped code reproduces it
byte-for-byte (seeded generator, stable SHA-256-derived seeds, no builtin
`hash()`). The held-out split lives under a private seed and is never shipped.