DEFER: the judgment-boundary dataset

Data for Where Rules End and Judges Begin: Measuring the Judgment Boundary in Multi-Agent Systems Security (arXiv:2610.07657). Code: github.com/shaswata09/DEFER.

The paper asks how much of the decision to allow an LLM agent's action can be made by deterministic checks and how much needs an LLM judge. DEFER is a cascade of 28 checks over five principles (authorized interface, capability scoping, verified execution, memory integrity, access-controlled isolation) that denies what it can deterministically and defers the remainder to a panel of four open-weight judges. This dataset holds the attack and benign suites it was measured on, the outcome of every trial, the raw logs, and every judge vote.

Contents

Config / path	Rows	What it is
attacks	324	Attack variants in four domains (CyberOps, healthcare, finance, legal): 15 attack paths × 5 variants per domain (AP-4 seven, AP-15 three) = 300 reported variants, plus the 24 rule-evading siblings (set = sibling)
benign	35	Benign scenarios (20 CyberOps, 5 per other domain) using the same tools, stores and consequential actions
reported_attack_trials	7,844	Outcome and first interceptor of every reported attack trial: the four-domain boundary, the leave-one-out arms and two further primaries
reported_benign_trials	1,425	Tool proposals and denials of every reported benign incident
all_trials, all_trials_local4		Every trial of every run group as run, and with judged configurations re-adjudicated under Local4 (includes superseded and diagnostic runs; select groups by the group column)
results/		The summary files the paper's tables are generated into (reported_boundary.json is the main table)
cache/validators/		Every judge's vote on every logged panel input, keyed by message hash
cache/replay*/		The logged panel inputs (messages.jsonl) and the rounds that use them (rounds.jsonl)
logs/		Raw per-trial JSON Lines event logs: each proposal with its arguments before any check ran, each decision, the deciding check and tier, per-check latency and tokens

Attack variants

Each row is one variant as the harness delivers it.

• channel: C1 task input, C2 tool response, C3 memory content, C4 handoff, C5 proposal justification.
• attacker_tier: T1 (content attacker) or T2 (compromised agent).
• intent: the attack description. This lives in a metadata block that no model sees.
• incident: the alert or request that starts the run. For C1 the adversarial text is in its description.
• injection: the content delivered through C2 to C5 (a forged tool response, planted records, a replaced handoff, or an appended proposal rationale).
• canaries: attacker-chosen values that the harmful action must carry.
• success_criteria.effects: what the oracle scores as success.
• payload: the complete original JSON.

The payloads are prompt-injection strings, poisoned records and forged tool responses aimed at a stub environment. They contain no working exploit against any real product, and comparable material is already public in the benchmarks the suite builds on (ASB, InjecAgent).

Reported trials

config takes one of five values:

• Flat: no checks.
• ACL: connectivity limits only.
• NoJudge: every rule; anything undecided is escalated.
• DEFER: rules first, judges last.
• JudgeOnly: the panel judges every proposal.

run takes one of these values:

• boundary: the four domains, with Qwen3-235B as the primary.
• minus_P1 … minus_P5: CyberOps, DEFER with one principle removed.
• gpt-oss-120b and Llama-3.1-8B: CyberOps, with that model as the primary.

JudgeOnly and DEFER outcomes are the direct outcome under the Local4 panel (Mistral-Small-3.2-24B, Gemma-4-31B-it, gpt-oss-120b and Llama-4-Scout; 3 of 4 must approve), re-adjudicated from the logged inputs. The other configurations are as run. outcome is not_attempted, blocked or executed. tier is the tier of the first interceptor: content_independent, content_dependent, similarity or panel.

Attack success is the share of executed trials. Pooled over run == boundary, it is 34.6% under Flat and 6.1% under DEFER, as in the paper.

from datasets import load_dataset
t = load_dataset("shaswatamitra/DEFER", "reported_attack_trials", split="train").to_pandas()
b = t[t.run == "boundary"]
print(b.groupby(["domain", "config"]).outcome.apply(lambda s: round(100 * (s == "executed").mean(), 1)))

Citation

@article{mitra2026rules,
  title   = {Where Rules End and Judges Begin: Measuring the Judgment Boundary in Multi-Agent Systems Security},
  author  = {Mitra, Shaswata and Patel, Raj and Neupane, Subash and Mittal, Sudip and Rahman, Md Rayhanur and Rahimi, Shahram},
  journal = {arXiv preprint arXiv:2610.07657},
  year    = {2026}
}