Datasets:

JevAgentHarness
/

AgentDecision-train

license: cc-by-nc-4.0
pretty_name: AgentDecision-train
language:
  - en
task_categories:
  - multiple-choice
  - text-classification
tags:
  - agents
  - llm-agents
  - tool-use
  - function-calling
  - decision-making
  - distillation
size_categories:
  - 10K<n<100K
configs:
  - config_name: v1
    default: true
    data_files:
      - split: train
        path: v1/train.parquet
      - split: dev
        path: v1/dev.parquet
      - split: dev_knockout
        path: v1/dev_knockout.parquet
      - split: dev_recovery
        path: v1/dev_recovery.parquet
  - config_name: v1_replay_when2call
    data_files:
      - split: train
        path: v1/replay_when2call.parquet
  - config_name: v0
    data_files:
      - split: train
        path: v0/train.parquet
      - split: dev
        path: v0/dev.parquet
  - config_name: v0_extra
    data_files:
      - split: dev_when2call
        path: v0/dev_when2call.parquet
      - split: mc_standin
        path: v0/mc_standin.parquet

AgentDecision-train

Training data for decision models, from the paper JevAgentHarness: Benchmarking, Deploying and Training Decision Models That Share Control with LLMs. Code: github.com/JevAgentHarness/JevAgentHarness (research code in research/). Benchmark: AgentDecisionBench.

A decision model answers a multiple-choice question about an LLM agent's next step: which tool to call, which value an argument takes, whether the task is done. Each row here is one such question, asked at a state the agent actually reached, with a probability target over the options. v1 is the agent-state SFT data of the paper's training recipe (Section 5 and Appendix D). It was used for the SFT stage of AgentDecision-4B v1 (code name JevAgentRL-4B), on which AgentDecision-4B was built. v0 is the earlier starter set; its train rows are also part of v1/train.

How the data was built

v1 (research/scripts/train/make_data_v1.sh, module research/src/jevharness/training/data_v1.py; recipe notes in research/docs/TRAINING_RECIPES.md §18):

Episodes. DecisionGym (code name JevGym) tasks in the evaluation setting (customer-service tasks, 60 near-miss distractor tools, 20 noise lines per tool result) on training seeds 30000-30599, which never overlap the evaluation seeds. The agent LLM was Gemini 3.5 Flash-Lite (temperature 0), in three behaviour arms: lite_shadow (Flash-Lite acts, the decision points are only recorded, 250 episodes), nearmiss_replace (a simulated decision model that follows the canonical plan with injected near-miss errors acts, which produces recovery states, 600 episodes) and lite_guard (Flash-Lite proposes, guards check tool calls and the stop, 150 episodes).
Harvest. Every decision point with a gold label from the task's canonical plan: tool choice (tool_select), tool arguments (tool_params) and stop / guard questions (stop; yes / no questions have kind noul). Duplicates across arms were removed, the frequent "no" answers of the stop trigger were down-sampled, and the data was split by task (15 % of tasks to dev). Guard questions about wrong calls the agent actually executed were added with the label "no" (source syn_guard:<arm>), because the guard arms logged almost only correct proposals. Hold-out checks: no evaluation seed, none of the 299 development items of the L1 benchmark, and an 8-gram decontamination against BFCL v4 and the When2Call test split. Added to train: the 1,225 v0 train rows and 2,133 knock-out variants (meta.augment): a tool-choice row cut down to the gold tool and its three hardest distractors, the final round that a served model with a limited number of options sees in the harness's knock-out over many options.
Teacher labels. Jev (typesafe/jev-1.13, a commercial decision model by TypeSafe, called through OpenRouter) answered every train row. The target is q = 0.3 x gold + 0.7 x p_Jev; where Jev's top answer disagreed with the gold label, the target is the gold label alone (864 rows, label_source gold). Dev targets stay gold; Jev's accuracy on dev is in v1/dev_teacher.summary.json.
Cost. $5.28 in all (episodes $4.65, teacher $0.63; v1/MANIFEST.json).

v0 (research/scripts/train/make_data_v0.sh): JevGym training seeds 10000-10029 and 12000-12059, agent Gemini 3.5 Flash, decision points recorded in shadow mode, gold labels. Jev was not reachable when v0 was built, so the teacher was a stand-in: Gemini 3.5 Flash-Lite's verbalised distributions (target_teacher_standin). mc_standin holds 24 rows with counterfactual Q-values from short rollouts.

The When2Call rows (v1_replay_when2call, v0_extra/dev_when2call) are converted items of When2Call's train split (only the "ask" and "cannot answer" cases), replayed during training to keep the model's behaviour on public questions. v0 also had a replay file with 15 more rows, which v1's decontamination removed; it is not included.

Not included: the raw trajectories, the public tool-use data (ToolACE) that AgentDecision-4B and AgentDecision-0.8B were trained on in addition, and the data of the appendix experiments. The research scripts rebuild them.

Configs and files

Config / split	File	Rows	Labels
`v1` / `train`	`v1/train.parquet`	15,694 (587 tasks)	Jev soft labels mixed with gold (14,830), gold only (864)
`v1` / `dev`	`v1/dev.parquet`	2,377 (90 tasks)	gold
`v1` / `dev_knockout`	`v1/dev_knockout.parquet`	656	gold; dev tool-choice rows with knocked-out options
`v1` / `dev_recovery`	`v1/dev_recovery.parquet`	606 (44 tasks)	gold; dev rows after an earlier error (`after_error` > 0)
`v1_replay_when2call` / `train`	`v1/replay_when2call.parquet`	2,685	When2Call label
`v0` / `train`	`v0/train.parquet`	1,225 (77 tasks)	gold (`target`) and the Flash-Lite stand-in teacher (`target_teacher_standin`)
`v0` / `dev`	`v0/dev.parquet`	210 (13 tasks)	gold
`v0_extra` / `dev_when2call`	`v0/dev_when2call.parquet`	300	When2Call label
`v0_extra` / `mc_standin`	`v0/mc_standin.parquet`	24	rollout Q-values

MANIFEST.json, build_info.json and the *.summary.json files are the build records (row counts per decision point, label sources, teacher metrics, cost). Their file names and sha256 values refer to the original JSONL files of the research repository; the Parquet files here hold the same rows (see "Original format").

Fields

id: the task id, the arm and step, and the decision point (for example jevgym-clarify-30036-d60-near-strict/nearmiss_replace:1/tool_select; #ko marks a knock-out variant), or w2ctrain-<hash>/when2call for When2Call rows.
source: traj:<arm> (a recorded state), syn_guard:<arm> (a guard question about a wrong executed call), when2call-train, or mc.
dp: decision point (tool_select, tool_params, stop). kind: choice (pick one option) or noul (yes / no).
state: the text the decision model reads: the task, the recent history of tool calls and results, and the current observation.
question: the question asked, such as "Which tool should the agent call next?".
options: the answer options (tool options are rendered name -- description, as the served model sees them).
target: the training target, one probability per option, aligned with options.
q_values: rollout Q-values aligned with options (mc_standin only).
label_source, arm, jevgym_seed, step, after_error (errors earlier in the episode), episode_success: copied from meta for filtering.
meta: the full metadata as a JSON string: what was logged at the decision (the recorded decision-model and LLM answers), and for teacher-labelled rows the teacher's distribution (teacher_dists), alpha and gold.
v0 / train only: target_teacher_standin and meta_teacher_standin, the stand-in teacher's target and metadata for the same rows.

Original format

The training code in research/src/jevharness/training/ reads JSONL rows whose target is a dict from option to probability and whose meta is an object. This restores them exactly (checked row by row against the originals):

import gzip, json
from datasets import load_dataset

rows = load_dataset("JevAgentHarness/AgentDecision-train", "v1", split="train")
with gzip.open("train.jsonl.gz", "wt") as f:
    for r in rows:
        o = r["options"]
        f.write(json.dumps({"id": r["id"], "source": r["source"], "dp": r["dp"], "kind": r["kind"],
                            "state": r["state"], "question": r["question"], "options": o,
                            "target": dict(zip(o, r["target"])),
                            "q_values": None if r["q_values"] is None else dict(zip(o, r["q_values"])),
                            "meta": json.loads(r["meta"])}) + "\n")

The SFT and GRPO steps are research/scripts/train/12_sft_v1.sh and 70_grpo_online.sh.

Licence and third-party content

Licence: CC BY-NC 4.0 (non-commercial) for the data we created (the states, gold labels, targets and build records), because they contain outputs of commercial models (the Jev decision model and Gemini or OpenAI agent text) whose redistribution terms we cannot extend to commercial use.
Teacher labels come from Jev (TypeSafe's commercial decision model, called through OpenRouter). The v0 stand-in labels come from Gemini 3.5 Flash-Lite. Check TypeSafe's and Google's terms before you use these labels commercially, in particular for training a model that competes with theirs.
Part of the state text was written by Gemini models: the agent's own tool arguments, questions to the customer and final answers in the histories (Gemini 3.5 Flash-Lite in v1's episodes, Gemini 3.5 Flash in v0's). The tasks, customers, orders, tool results and customer replies are generated from DecisionGym's templates and contain no personal information. Check Google's terms for Gemini output before commercial use.
When2Call rows (v1_replay_when2call, v0_extra/dev_when2call) are derived from When2Call (NVIDIA, CC BY 4.0, huggingface.co/datasets/nvidia/When2Call); keep its attribution.

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