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