README.md

---
pretty_name: Agent Tool Decisions 180K
license: other
license_name: mixed-upstream-terms-see-source-cards
language:
- en
task_categories:
- text-classification
- text-ranking
tags:
- agents
- tool-calling
- tool-use
- function-calling
- decision-models
- routing
- structured-prediction
- preference-data
size_categories:
- 100K<n<1M
configs:
- config_name: default
  data_files:
  - split: train
    path: "train-*.parquet"
  - split: validation
    path: "validation-*.parquet"
  - split: test
    path: "test-*.parquet"
---

# Agent Tool Decisions 180K

**180,000 typed decisions that sit behind every agent step.** Should the agent call a tool, or
answer in text? Which tool? Are the arguments complete? Which tool-using response is better?

An agent spends most of its time making these small decisions, and a frontier LLM is an
expensive way to make them. They are **typed**: a question, a fixed set of choices, one correct
answer. That makes them a good fit for small, fast decision models (encoders, classifiers,
Jev-style typed decision models, GLiNER2.5-Decide-style heads) that answer in milliseconds on a
CPU.

This dataset turns NVIDIA's open agentic data into exactly that format: 180K clean, labeled,
split-safe decision rows, ready to train or evaluate a tool router today.

> **Built on NVIDIA's open data:** `nvidia/Nemotron-SFT-Agentic-v2` and `nvidia/When2Call`.
> Every label comes from the upstream data (programmatic or automated). **No output from Jev,
> TypeSafe or any other proprietary model is included.** It contains no clinical or medical
> data.

## Update:

I used HuggingChat+ML Intern to train ModerBERT on this dataset. Everything to run it yourself, prompt, recipe and receipts: 
https://huggingface.co/MaziyarPanahi/ModernJEV-Decide-Preview


## At a glance

| | |
| --- | ---: |
| Rows | **180,000** |
| Train / validation / test | 171,056 / 2,713 / 6,231 |
| Decision groups | 101,786 |
| Upstream source rows | 41,809 |
| Leakage | none: no decision group or source row crosses splits |
| Format | flat Parquet, 35 columns, works with `datasets`, DuckDB, Polars and pandas |

## The six decisions

| Task family | Question the model answers | Rows |
| --- | --- | ---: |
| `agent_next_action_type` | What type of action should the assistant take next? | 79,238 |
| `tool_selection` | Which available tool should be called next? | 37,233 |
| `tool_argument_completeness` | Do the proposed tool calls include every required argument named by the tool schemas? | 37,233 |
| `tool_or_text_action` | Should the assistant call a tool or produce a text response next? | 14,349 |
| `tool_response_preference` | Which response better uses or declines the available tools? | 8,295 |
| `when_to_call_tool` | When2Call-style: should a tool be called at all? | 3,652 |

Two answer types (`primitive`): `choice` (one label from the criteria, 142,767 rows) and
`noul` (a bounded 0–1 value, 37,233 rows).

## Quick start

```python
from datasets import load_dataset

ds = load_dataset("MaziyarPanahi/AgentToolDecisions-180K")
row = ds["train"][0]

print(row["question_text"])   # e.g. "Which available tool should be called next?"
print(row["state_preview"])   # the agent state: conversation + available tools
print(row["criteria_json"])   # the allowed answers
print(row["gold_label"] if row["gold_label"] is not None else row["gold_score"])
```

Train a tool router on a single task family:

```python
tool_sel = ds["train"].filter(lambda r: r["task_family"] == "tool_selection")
# inputs: question_text + state_json, labels: gold_label (one of the keys in criteria_json)
```

## What you can build with it

- **Tool routers:** pick the next tool in milliseconds instead of spending a full LLM call.
- **"Should I call a tool?" gates:** cut useless tool calls and the latency they add.
- **Argument checkers:** catch missing required arguments before the call fails.
- **Reward and preference models** for tool-using responses.
- **Evaluation:** measure your agent's decision accuracy per task family, on a leakage-free test
  split.
- **Race Jev:** every row's `request_json` is a ready-to-send Jev API request (`"model": "jev-1.13.0"`,
  typed questions with criteria, and the agent state). Run Jev, or any typed decision model, on
  exactly the same requests and compare against the gold labels.

## How to read a row

| Need | Columns |
| --- | --- |
| Identity and split | `row_id`, `group_id`, `output_split` |
| Decision task | `priority`, `task_family`, `primitive`, `question_key` |
| Model input | `state_json`, `state_preview`, `question_text`, `criteria_json` |
| Ready-to-send Jev request | `request_json` |
| Reference answer | `gold_label`, `gold_score`, `gold_json`, `label_source` |
| Provenance | `source_dataset`, `source_revision`, `source_row_id`, `source_license`, `source_url`, `transformation`, `transform_version` |

Nested payloads are canonical JSON strings, so the Parquet schema stays stable across tasks.

## Where the labels come from

| Label source | Rows |
| --- | ---: |
| `programmatic_next_message` | 79,238 |
| `programmatic_schema_check` | 37,233 |
| `programmatic_tool_call` | 37,233 |
| `programmatic_message_format` | 14,349 |
| `automated_preference_gold` | 8,295 |
| `automated_verified_mcq_gold` | 3,652 |

| Source | Rows |
| --- | ---: |
| `nvidia/Nemotron-SFT-Agentic-v2` | 153,704 |
| `nvidia/When2Call` | 26,296 |

## Validation

An independent audit checks:
- 180,000 rows with unique row IDs;
- no decision group or upstream source row crosses splits;
- valid canonical JSON for state, request, criteria, gold and metadata;
- choice labels inside the declared criteria, and scores within bounds;
- a pinned source revision, license, URL and transformation on every row;
- no proprietary-model prediction, probability, raw-response, usage or latency columns.

## Limitations

- Labels are programmatic or automated upstream labels. They can be noisy or ambiguous, so keep
  `label_source` and `task_family` with every prediction you evaluate.
- Tool schemas and domains vary across the upstream agent episodes.
- The typed request format is a normalized transformation, not the original upstream schema.
- This is a general agent-decision dataset, not a clinical one.

## License and attribution

Derived from pinned revisions of `nvidia/Nemotron-SFT-Agentic-v2` and `nvidia/When2Call`. When2Call
is marked CC BY 4.0. The Nemotron card lists CC BY 4.0, Apache 2.0 and MIT terms across its
components. Every row keeps its recorded source license. Please review and follow the upstream
dataset cards when you use or redistribute the data. Thanks to NVIDIA for releasing the source data
openly.