README.md

---
license: cc-by-4.0
pretty_name: AgentDecisionBench
language:
- en
task_categories:
- multiple-choice
- text-classification
tags:
- agents
- llm-agents
- tool-use
- function-calling
- decision-making
- benchmark
size_categories:
- 100K<n<1M
configs:
- config_name: common_states
  default: true
  data_files:
  - split: test
    path: common_states/questions.jsonl.gz
- config_name: common_states_answer_key
  data_files:
  - split: test
    path: common_states/occurrences.jsonl.gz
- config_name: common_states_answers
  data_files:
  - split: test
    path: common_states/answers_*.jsonl.gz
- config_name: shift
  data_files:
  - split: test
    path: shift/questions.jsonl.gz
- config_name: shift_answer_key
  data_files:
  - split: test
    path: shift/occurrences.jsonl.gz
- config_name: shift_nosurf
  data_files:
  - split: test
    path: shift/questions_nosurf.jsonl.gz
- config_name: shift_nodist
  data_files:
  - split: test
    path: shift/questions_nodist.jsonl.gz
- config_name: shift_answers
  data_files:
  - split: test
    path: shift/answers_*.jsonl.gz
- config_name: isolated_answers
  data_files:
  - split: test
    path: isolated/answers.jsonl.gz
- config_name: tasks
  data_files:
  - split: test
    path: tasks/decisiongym_tasks.jsonl.gz
- config_name: leaderboard
  data_files:
  - split: test
    path: leaderboard/headline_numbers.jsonl.gz
- config_name: models
  data_files:
  - split: test
    path: models.jsonl.gz
---

# AgentDecisionBench

AgentDecisionBench is the benchmark of the paper *JevAgentHarness: Benchmarking, Deploying and Training Decision
Models That Share Control with LLMs*. Code: [github.com/JevAgentHarness/JevAgentHarness](https://github.com/JevAgentHarness/JevAgentHarness)
(the research code is in its `research/` folder).

A **decision model** is a small model that answers a multiple-choice question about an agent's next step, such as
"which tool should the agent call next?", with a probability for each option. A harness can hand that choice to the
decision model when it is confident and let the LLM decide otherwise. AgentDecisionBench measures decision models at
three levels:

| Level | Name | What is scored | In this dataset |
|---|---|---|---|
| L1 | isolated | a standalone question with no agent around it (BFCL v4 tool choice and arguments, When2Call) | every model's answer and its correctness on 3,991 items (`isolated_answers`). The question texts are third-party data and are not copied here (see "L1") |
| L2 | open-loop | answers at states recorded from real agent runs. The answers are not acted on, so errors never compound. Each state is scored against the answer key | two question sets with answer keys and every model's answers: the **common states** (200 new DecisionGym tasks) and **DecisionGym-Shift** (100 shifted tasks) |
| L3 | closed-loop | the decision model's choices drive the running agent, scored by task success | the task lists (`tasks`). L3 is run with the code, because the agent LLM has to act |

DecisionGym is a generator of customer-service tasks (find the customer, look up orders, cancel, ship, refund, ask the
customer when information is missing) with 60 near-miss distractor tools and noisy tool output. Every task has a
canonical plan, from which the **answer key** is derived: the set of tools that are acceptable at each recorded state.
No model sees the answer key.

## Names in the paper and in the code

The code and the files keep the names the study ran with.

| Paper | Code, files and model ids here |
|---|---|
| AgentDecisionBench | JevAgentBench (`jevbench`) |
| DecisionGym, DecisionGym-Shift, DecisionGym-Hard | JevGym (`jevgym`), `shift: true`, `multi_rule: tier` |
| common states (L2) | corpus C, `results/stage2/s23/` |
| AgentDecision-4B | `e12` (the final 4B, trained further on public tool-use data) |
| AgentDecision-4B v1 | `rl` (JevAgentRL-4B, the SFT + GRPO checkpoint frozen before Stage 2) |
| AgentDecision-0.8B | `e28` (StartLux-Decision-0.8B + the recipe) |
| Jev | `jev` (`typesafe/jev-1.13`, the teacher of the training data) |

The `models` config lists every model id with its name, kind (ours, ablation, off-the-shelf, LLM, control) and the
levels it has answers for.

## Configs

| Config | Rows | What it holds |
|---|---|---|
| `common_states` (default) | 3,939 | distinct L2 questions of the common states |
| `common_states_answer_key` | 5,314 | one row per occurrence of a question in a recorded trajectory, with its acceptable tools |
| `common_states_answers` | 153,621 | 39 models x 3,939 answers |
| `shift` | 1,093 | distinct L2 questions of DecisionGym-Shift (renamed tools, 120 distractors, new task kinds) |
| `shift_answer_key` | 1,250 | occurrences with acceptable tools |
| `shift_nosurf`, `shift_nodist` | 1,093 each | the same states with the original tool names (`nosurf`) or without the added distractors (`nodist`), used to split the shift's effect into its parts |
| `shift_answers` | 45,906 | answers of 18 models (42 model-and-variant files); `variant` is `main`, `nosurf` or `nodist` |
| `isolated_answers` | 167,622 | 42 models x 3,991 L1 items |
| `tasks` | 2,200 | DecisionGym task ids and seeds of every evaluation set |
| `leaderboard` | 169 | the paper's numbers per model, copied from the paper's generated tables |
| `models` | 49 | model ids, names and kinds |

The folders `common_states/` and `shift/` have the layout of the research repository's `results/stage2/s23/` and
`results/explore/e21_shift/c/`. Copy them there and the research scripts read them unchanged. `corpus.json` lists the
eligible tasks and the file hashes, and `shift/variants.json` describes the two re-renderings.

## Fields

**Questions** (`common_states`, `shift`, `shift_nosurf`, `shift_nodist`)

- `qhash`: sha256 of the exact state string, options, option descriptions and question text. It joins questions,
  answer keys and answers.
- `state`: what the decision model reads: `TASK:` (the customer's request), `HISTORY:` (earlier tool calls with
  their results, including noise lines) and `CURRENT OBSERVATION:`.
- `options`: the tool names to choose from (69 on the common states, 129 on the shift).
- `descriptions`: one description per option.
- `map` (`shift_nosurf` only): original tool name -> shifted tool name. Map an answer through it before scoring.

The question asked at every state is "Which tool should the agent call next?" (the tool-choice decision point).

**Answer keys** (`*_answer_key`)

- `task`, `source` (the run that recorded the trajectory), `step`, `qhash`.
- `gold`: the canonical next tool. `gold_aux.acceptable_tools`: every tool that is correct at this state (for
  example, asking the customer or looking them up). `gold_aux.acceptable_tools_unfiltered`: the same before tools
  the agent could not yet know about were removed.
- `gold_status` (all `ok`), `dp` (`tool_select`), `stratum` (`on_plan`, or `after_off_plan` when an earlier action
  of the trajectory left the canonical plan), `label_provenance`.

**Answers** (`*_answers`)

- `model`: the model id (see `models`). `variant` (shift only): `main`, `nosurf` or `nodist`.
- `qhash`, `answer` (the chosen option), `confidence` (the model's probability for it), `valid`, `error`,
  `attempts`, `requests`.
- `cost_usd` (API list price of the call, 0 for self-hosted models), `latency_ms`, `wall_ms`.

Every model answered every question once, through one replay path (one question per request, in sorted `qhash`
order, with a cache separate from the runs that recorded the states).

**Isolated answers** (`isolated_answers`)

- `model`, `id` (the BFCL or When2Call item id; argument questions are `<item>/param/<name>`), `source`
  (`bfcl:<category>` or `when2call:<subset>`), `dp` (`tool_select` or `tool_params`), `category`, `param`.
- `pred` (the model's answer), `gold` (the accepted answers, normalised), `correct`, `conf`, `error`, `refusal`.
- `cost_usd`, `latency_ms`, `request_questions` (questions batched in one request), `input_tokens`,
  `output_tokens`, `model_id`.

**Tasks** (`tasks`)

- `set`: `stage1_eval` (500 tasks), `stage2_eval` (500 tasks; the first 200 are the source of the common states and
  of the in-domain closed-loop rows, `in_common_states`), `shift_l2_sources` (100), `shift_l3` (200), and the
  DecisionGym-Hard sets `hard_e7`, `hard_e7b`, `hard_e7c`, `hard_e7e`, `hard_e7f` (100 or 200 each).
- `task_id`, `seed`, `index`, `suite` (the generator settings as JSON), `used_for`, `config` (the run configuration
  in the research repository).

DecisionGym-Hard has no L2 question set; it was evaluated closed-loop only.

**Leaderboard** (`leaderboard`)

- `model`, `model_name`, `level`, `task_set`, `metric`, `value` (as printed in the paper), `value_num`,
  `paper_display` (Table 3, Figure 4b, or the appendix and text), `tex_key` and `tex_file` (the macro in the
  research repository's `paper/generated/` that holds the value).

## How to score

**L2.** An answer is correct when it is one of the state's acceptable tools (trimmed, case-insensitive). A missing,
failed or invalid answer counts as wrong. Accuracy is the mean over the occurrences of each task, then the mean over
the tasks listed in `corpus.json` (`eligible_tasks`: 200 for the common states, 100 for the shift). The shift's
**must-ask** subset contains the occurrences whose only acceptable tool is `request_clarification` (the shifted name
of `ask_user`).

```python
from collections import defaultdict
from datasets import load_dataset

REPO = "JevAgentHarness/AgentDecisionBench"
key = load_dataset(REPO, "shift_answer_key", split="test")
ans = load_dataset(REPO, "shift_answers", split="test")
ans = {r["qhash"]: r for r in ans if r["model"] == "e12" and r["variant"] == "main"}

def correct(occ, a):
    if a is None or a["error"] or not a["valid"] or a["answer"] is None:
        return False
    ok = occ["gold_aux"]["acceptable_tools"] or [occ["gold"]]
    return a["answer"].strip().lower() in {x.strip().lower() for x in ok}

per_task = defaultdict(list)
for occ in key:
    per_task[occ["task"]].append(correct(occ, ans.get(occ["qhash"])))
print(round(100 * sum(sum(v) / len(v) for v in per_task.values()) / len(per_task), 1))   # 94.9 (Table 3)
```

To answer the questions with your own model, serve it in Jev's wire format and run, in the research folder,
`python scripts/stage2_corpus.py replay --corpus <folder> --name <id> --s1 '<backend spec>'`. It writes
`answers_<id>.jsonl` with the fields above. The paper's numbers come from `scripts/explore_e21_shift.py summarize`
(shift), `scripts/stage2_analysis.py` and `scripts/explore_e15_baselines.py summarize` (common states); the scoring
functions are `jevharness.bench.stage2_corpus.answer_correct` and `task_accuracy`.

**L1.** Pooled accuracy is the mean of `correct` over a model's 3,991 rows. "BFCL tool choice" uses only the rows with
`dp == "tool_select"` and a `source` starting with `bfcl`. The items are BFCL v4 (categories `simple_python`,
`multiple`, `live_simple`, `live_multiple`, `irrelevance`, `live_irrelevance`, at most 200 each) and the When2Call
test split (at most 1,000), minus 299 items used during development. To get the question texts, run
`jevbench decide configs/decision/bfcl_when2call.yaml --out runs` in the research folder; the loader
(`src/jevharness/bench/suites/static.py`) downloads both datasets at pinned commits.

**L3.** DecisionGym tasks are rebuilt from `suite` and `seed` by the generator in the research folder
(`src/jevharness/bench/suites/jevgym.py`, `jevgym_shift.py`, `jevgym_hard.py`). Serve the decision model in Jev's
wire format (`python -m jevharness.decision.server` or `python -m jevharness.training.serve_jev`), point a run
configuration at it, and run, for example, `JEV_EVAL_RUNS=1 jevbench run configs/explore/e21_shift/live_e12.yaml
--out runs`. The runner refuses the evaluation seeds unless `JEV_EVAL_RUNS=1` is set. The agent LLM is Gemini 3.5
Flash (about $0.03 per episode at October 2026 list prices).

We recomputed the L1 and L2 values of `leaderboard` from the files in this dataset; all match the paper. The L3
values come from the closed-loop runs, which are not part of this dataset.

## Results in the paper

Values as printed in the paper. Every value is also in the `leaderboard` config with its source macro.

**Table 3: shifted tasks** (L1 = pooled isolated accuracy; L2 = step-level accuracy on DecisionGym-Shift states;
L3 = task success on 200 shifted tasks; all in %).

| Model | id | L1 isolated | L2 all states | L2 must-ask | L3 success |
|---|---|---|---|---|---|
| Qwen3-4B, untrained | `base` | 71.4 | 52.9 | 27.6 | 13.5 |
| + SFT | `sft_v1` | 78.4 | 98.4 | 95.0 | 96.0 |
| + GRPO = AgentDecision-4B v1 | `rl` | 78.8 | 98.6 | 90.8 | 96.0 |
| + public tool-use data = **AgentDecision-4B** | `e12` | 85.1 | 94.9 | 67.4 | 91.5 |
| Jev (teacher) | `jev` | 86.4 | 91.8 | 58.3 | 82.0 |
| Intern-Decision-4B | `intern` | 73.4 | 75.9 | 33.9 | 34.0 |
| StartLux-Decision-4B | `sl4b` | 83.1 | 86.5 | 36.7 | 49.0 |
| StartLux-4B + our recipe | `e12c` | 85.5 | 98.5 | 100.0 | 98.0 |
| StartLux-Decision-0.8B | `sl0.8b` | 70.0 | 51.7 | 27.2 | 13.0 |
| StartLux-0.8B + our recipe = **AgentDecision-0.8B** | `e28` | 80.5 | 95.6 | 93.5 | 82.0 |

**Figure 4b: the three levels** (L1 = BFCL tool-choice accuracy; L2 and L3 on DecisionGym-Shift). StartLux-27B's
closed-loop row covers 164 of the 200 shifted tasks.

| Model | id | L1 BFCL tool choice | L2 all states | L3 success |
|---|---|---|---|---|
| AgentDecision-4B | `e12` | 89.3 | 94.9 | 91.5 |
| AgentDecision-0.8B | `e28` | 87.1 | 95.6 | 82.0 |
| Jev | `jev` | 89.9 | 91.8 | 82.0 |
| OpenAI Decisions API | `oaidec` | 90.6 | 86.1 | 66.0 |
| OpenJev-27B | `openjevhf` | 90.2 | 92.4 | 69.5 |
| StartLux-Decision-27B | `sl27b` | 90.8 | 94.7 | 79.9 |
| StartLux-Decision-9B | `sl9b` | 92.2 | 90.9 | 69.5 |
| StartLux-Decision-4B | `sl4b` | 91.3 | 86.5 | 49.0 |
| Intern-Decision-4B | `intern` | 88.2 | 75.9 | 34.0 |

**Common states** (L2 on the 200 new DecisionGym tasks) and closed-loop success on the same tasks, where the paper
reports them (appendix).

| Model | id | L1 BFCL tool choice | L2 common states | L3 success (200 new tasks) |
|---|---|---|---|---|
| AgentDecision-4B v1 | `rl` | 88.4 | 99.2 | 100.0 |
| AgentDecision-4B | `e12` | 89.3 | 99.1 | 100.0 |
| StartLux-4B + recipe | `e12c` | – | 99.6 | – |
| Jev (typesafe/jev-1.13) | `jev` | 89.9 | 91.5 | 83.0 |
| OpenAI Decisions API (gpt-6-luna) | `oaidec` | 90.6 | 90.9 | 78.5 |
| OpenJev (DiffusionGemma-26B-A4B) | `openjev` | 91.2 | 91.1 | 62.5 |
| OpenJev-27B (HF, FP8) | `openjevhf` | 90.2 | 92.4 | 63.0 |
| StartLux-Decision-27B (Q8_0) | `sl27b` | 90.8 | 93.9 | 63.0 |
| StartLux-Decision-9B | `sl9b` | 92.2 | 91.8 | 74.0 |
| StartLux-Decision-4B | `sl4b` | 91.3 | 89.1 | 60.0 |
| StartLux-Decision-2B | `sl2b` | 89.9 | 68.4 | 6.5 |
| StartLux-Decision-0.8B | `sl0.8b` | 88.2 | 48.3 | 17.5 |
| Intern-Decision-4B | `intern` | 88.2 | 75.2 | 26.5 |
| Imajev-4B | `imajev` | 87.9 | 76.9 | – |
| JevK5 v0.2 (4B) | `jevk5` | 86.4 | 65.0 | – |
| decider-4b v2.1 | `decider` | 90.8 | 63.2 | – |
| Clef-Flash 9B | `clefflash` | 87.5 | 47.7 | – |
| Bosun 3.1 1.7B | `bosun` | 85.8 | 36.3 | – |
| Verdict 1.4 (151M) | `verdict` | 78.3 | 19.0 | – |
| CLM v0.1 (8B) | `clm` | 71.0 | 11.9 | – |
| Laya (421M) | `laya` | 79.8 | 11.0 | – |
| Qwen3-4B (untrained) | `base` | – | 50.1 | – |
| Qwen3-4B + SFT (v1) | `sft_v1` | – | 99.2 | – |
| JevAgentRL-v2 (exploratory) | `v2` | – | 99.4 | – |
| Qwen3.5-0.8B scoring head (agent states) | `e14a` | – | 99.2 | 100.0 |
| Qwen3.5-0.8B scoring head (agent states + generic mix) | `e14ag` | – | 99.1 | – |
| Qwen3.5-0.8B scoring head (generic mix only) | `e14g` | – | 23.9 | 0.0 |
| AgentDecision-4B (mixed+) | `e16a` | – | 99.1 | 100.0 |
| StartLux-9B + recipe | `e16b` | – | 99.3 | 100.0 |
| Qwen3.5-0.8B one-token read-out | `e17gen` | – | 99.0 | – |
| Qwen3.5-0.8B with a trained defer option | `e18f` | – | 99.1 | – |

The agent LLM alone (Gemini 3.5 Flash, no decision model) solved 100.0% of the 200 shifted tasks.

## Licence and third-party content

- **Licence: CC BY 4.0** for what we created: the recorded DecisionGym states, answer keys, task lists, our
  models' answers and the leaderboard.
- **DecisionGym** customers, orders and e-mail addresses are generated from templates. The data contains no personal
  information. The agent text in the states (tool arguments, questions to the customer) was written by Gemini 3.5
  Flash, and some trajectories had their tool choices made by decision models (Jev, Intern-Decision-4B,
  AgentDecision-4B v1). Check Google's terms for Gemini output before you use the states commercially.
- **Answers of third-party models** are outputs of those models: commercial APIs (Jev by TypeSafe, the OpenAI
  Decisions API) and open weights under their own licences (StartLux-Decision and OpenJev-27B weights are
  CC BY-NC 4.0, the others mostly Apache-2.0; see `models`). Check the provider's terms before you use them, for
  example as training targets.
- **L1 item ids and gold labels** derive from BFCL v4 (Berkeley Function Calling Leaderboard, Apache-2.0,
  github.com/ShishirPatil/gorilla) and When2Call (NVIDIA, CC BY 4.0, huggingface.co/datasets/nvidia/When2Call).
  Their question texts are not included.

## Citation

```bibtex
@misc{zhu2026jevagentharnessbenchmarkingdeployingtraining,
      title={JevAgentHarness: Benchmarking, Deploying and Training Decision Models That Share Control with LLMs},
      author={Kunlun Zhu and Tao Feng and Xu Han and Heng Wang and Ling Yang and Xiangru Tang and Jiaxuan You and Heng Ji},
      year={2026},
      eprint={2610.21412},
      archivePrefix={arXiv},
      primaryClass={cs.AI},
      url={https://arxiv.org/abs/2610.21412},
}
```