| --- |
| 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](https://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): |
|
|
| 1. **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). |
| 2. **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. |
| 3. **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`. |
| 4. **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): |
|
|
| ```python |
| 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 |
|
|
| ```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}, |
| } |
| ``` |
|
|
