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
(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) andCURRENT OBSERVATION:.options: the tool names to choose from (69 on the common states, 129 on the shift).descriptions: one description per option.map(shift_nosurfonly): 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(allok),dp(tool_select),stratum(on_plan, orafter_off_planwhen an earlier action of the trajectory left the canonical plan),label_provenance.
Answers (*_answers)
model: the model id (seemodels).variant(shift only):main,nosurfornodist.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>orwhen2call:<subset>),dp(tool_selectortool_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 setshard_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_keyandtex_file(the macro in the research repository'spaper/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).
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
@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},
}