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

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},
}