samatv256/jev-decisions-v1

Jev Decisions v1

12M canonical agent-decision records for tool selection, routing, value prediction, completion, and local agent control.

Jev Decisions v1 is a derived, decision-oriented corpus built from public agent trajectory datasets. It canonicalizes heterogeneous trajectories into a shared learning interface:

state + available candidate decisions -> target / outcome / eligibility

mini-Jev is a related open decision-model project. Its earlier v1 baseline was not trained on Jev Decisions v1; the newer interim step 10,626 checkpoint uses decision supervision derived in part from this dataset. The dataset can also be used independently.

The purpose is to make agent-control training easier without requiring each researcher to independently acquire and normalize several large, structurally different sources. The corpus is designed for action selectors, tool and function routers, model routers, next-action predictors, completion policies, value models, verification systems, and small local decision models. It is not primarily a conversational language-model pretraining corpus, and ordinary assistant prose is not the target.

General CLEAN-50K

general-clean-50k is a 50,000-decision, Choice-only training subset derived from this repository's public train partition at revision d063f00b9178a3a08558c20d5cbce0d0f2f5d3f2. It contains no Open-SWE records. This is a sanitized public derivative of the exact CLEAN-50K training selection: credential/token-shaped strings, email addresses, home-directory paths/usernames, and sensitive identifier patterns in model-visible text are replaced with neutral placeholders. Decision IDs, option order, and targets remain the same. Public text and exact branch lengths may therefore differ from the private training copy after privacy redaction. Load it with load_dataset("samatv256/jev-decisions-v1", "general-clean-50k", split="train"). The five Parquet shards contain the state, a fixed Choice question, finite answer options, and the correct option index. The separate compact manifest records public source, split, candidate-count, and exact serialized-length metadata.

Selection required supported Choice training labels, at least two distinct options, one unambiguous target within the option set, unique canonical content, and zero overlap with this dataset's validation/test partitions by content hash, task identity, or trajectory identity. Each trajectory contributes at most eight decisions; no source exceeds 60% of the subset. Only state, question, and symmetric option fields (type, name, description, parameter schema) are intended as model input. Target arguments, candidate payloads/metadata, and evaluation labels are not included in this subset.

Lengths use the exact Qwen3-0.6B tokenizer after the 8,192-token branch policy. The question, all candidate definitions, user goal when present, current environment, and most recent observation are protected; earlier history may be shortened. The sanitized public rows were re-tokenized with the same policy; the manifest records each decision's new longest serialized branch. Every published branch passed the 8,192-token limit. The validated selection manifest SHA256 is 03e074aafa63bf443b6dc4af62fab44c4cc86dbcff2b650d55113f6fa110c740; the sanitized compact public manifest SHA256 is bc8be6650e635eea46a334742075530359896d453c8692c46ab5f16ebeeabab6. It distinguishes source-content hashes from hashes of the public model-visible decisions.

Public source	Decisions	Share
nvidia/Nemotron-SFT-Agentic-v2	30,000	60.00%
nvidia/Nemotron-RL-Agentic-Conversational-Tool-Use-Pivot-v1	17,217	34.43%
nvidia/Nemotron-RL-Agentic-Function-Calling-Pivot-v1	2,783	5.57%

Longest branch length	Decisions	Candidate count	Decisions
0–2,048 tokens	15,023	2	5,388
2,049–4,096	20,083	3–4	15,733
4,097–6,144	9,910	5–8	11,451
6,145–8,192	4,984	9–16	9,000
		17+	8,428

All 50,000 source decisions are unique by decision ID and canonical source-content hash. Across 28 groups, 32 additional rows serialize to the same model-visible text and target as another row (60 rows in those groups total). These repeats were present before privacy redaction because omitted source fields distinguished the underlying records. They are retained to preserve the selected decision identities. The public text was redacted in 11,368 rows. This shifts the exact length buckets slightly from the original 15,000 / 20,000 / 10,000 / 5,000 selection; candidate counts are unchanged. The 9+ candidate share reflects the supplied candidate sets in the public source data; candidate-count targets were soft. This subset is derived from Jev Decisions v1 and the three NVIDIA-developed public datasets above. The dataset-level license is CC BY 4.0. Retain attribution and comply with applicable source and component terms in SOURCE_LICENSES.md; NVIDIA is not the publisher or endorser of this subset.

Scale and supervision

Measure	Count
Usable canonical records	11,978,080
Choice-supervised decisions	6,214,185
Value-supervised records	9,369,747
Completion-supervised records	48,293
Score-supervised records	0
Unique trajectories/tasks	1,066,352
Original canonical Parquet artifact	48,763,693,033 bytes (45.415 GiB)

The deterministic group-aware split is approximately 94/3/3:

Repository split	training_split value	Records
train	train	11,269,408
validation	val	354,037
test	test	354,635

All rows from a trajectory/task stay in one partition. Verified trajectory/task overlap across train, validation, and test is zero. The repository uses the conventional validation/ directory; the preserved field value is val.

Source composition

The corpus currently derives from four NVIDIA-developed upstream dataset repositories:

• nvidia/Nemotron-SFT-Agentic-v2, configs/splits default/interactive_agent, default/search, and default/tool_calling.
• nvidia/Nemotron-RL-Agentic-Conversational-Tool-Use-Pivot-v1, default/train.
• nvidia/Nemotron-RL-Agentic-Function-Calling-Pivot-v1, default/train.
• nvidia/Open-SWE-Traces, version v1.0, openhands and sweagent.

The card does not declare an English-only language tag. Open-SWE records include a repository programming-language field, and this corpus combines natural-language agent states with code and tool schemas; the description language should not be read as a claim that every source example is English-only.

Choice supervision is composed of:

Source	Choice-eligible rows	Share
Open-SWE-Traces	3,605,852	58.03%
Nemotron-SFT-Agentic-v2	2,537,900	40.84% (~41%)
Nemotron Pivot datasets, combined	70,433	1.13% (~1%)

Open-SWE supplies all current Value supervision. As a result, uniform multi-objective training is heavily weighted toward software engineering.

Dataset balance warning

The complete dataset intentionally preserves the natural source distribution and is NOT source-balanced. Open-SWE represents 78.22% of usable records, 58.03% of Choice supervision, and 100% of Value supervision. For general-purpose tool selection or routing, source-balanced or domain-balanced sampling may be preferable. Keep source and domain provenance when sampling.

Schema

The Parquet schema is preserved in every shard. JSON-shaped payloads whose actual schema type is string remain strings; parse those fields explicitly if structured objects are needed. The schema does not contain one generic source_config field at the top level: source config and raw split are under provenance.

Field	Actual Parquet type / location	Meaning
id	string	Canonical record ID.
source	string	Upstream dataset ID.
decision_type	string	Record kind, including tool_choice, completion, and unsupported.
status	string	Canonical record status.
unsupported_reason	nullable string	Reason an otherwise preserved record is unsupported.
content_hash	string	Canonical content fingerprint.
state.system	nullable string	System instructions available before the decision.
state.user_goal	nullable string	User/task request available before the decision.
state.history	list of structs {role: nullable string, payload_json: string}	Prior conversation/environment history. Each payload is serialized JSON text.
state.environment_json	nullable string	Serialized environment state available before the decision.
candidates	list of structs {id: string, name: string, description: nullable string, parameters_json: string, metadata_json: string}	Actions actually available at the decision. Parameter and metadata payloads are JSON strings.
target	nullable struct {candidate_id: nullable string, action_name: string, arguments_json: nullable string, label_json: nullable string}	Single target action and its arguments/label where represented.
ordered_targets	list of structs with the same four fields as target	Source-ordered target(s); use the single-choice eligibility flag before treating these as atomic Choice targets.
labels.complete	nullable boolean	Completion label when supported by source evidence.
labels.trajectory_success	nullable boolean	Verified trajectory outcome; null means unknown.
labels.value_target, labels.reward, labels.score, labels.source_pass_rate	nullable float64	Value/reward/score and source-native pass rate when present. These quantities are not interchangeable.
labels.outcome_evidence	nullable string	Evidence supporting outcome labels.
provenance.dataset_id	string	Exact upstream dataset ID.
provenance.dataset_revision	string	Source revision/version recorded by canonicalization.
provenance.source_config, provenance.raw_split	string	Upstream configuration and split.
provenance.source_row_index	int64	Row index in the source shard/split.
provenance.source_identity, provenance.trajectory_id	string	Original source/task identity and trajectory grouping key.
provenance.step_index, provenance.decision_ordinal	int64	Step and canonical decision order.
provenance.adapter_version	string	Adapter version recorded during canonicalization.
provenance.license_metadata_json, provenance.source_metadata_json	string	Serialized source license and other source metadata.
training.choice_eligible	boolean	Whether the row has supported Choice supervision.
training.completion_eligible	boolean	Whether completion supervision is supported.
training.value_eligible	boolean	Whether value supervision is supported.
training.score_eligible	boolean	Whether score supervision is supported.
training.boolean_eligible, training.arguments_eligible	boolean	Eligibility for those auxiliary targets.
training.use_for_bc, training.use_for_value	boolean	Canonical training-use flags.
training.supervision_evidence	string	Evidence category for the available training target.
training.choice_ineligible_reason	nullable string	Reason Choice supervision is ineligible.
training.quality_weight	float64	Canonical record quality weight.
training_split	nullable string	Existing deterministic assignment: train, val, or test.

Eligibility flags are authoritative: do not treat every row or every target as positive supervision. In particular, do not train Choice on failed or unresolved trajectory actions. A failed trajectory alone does not prove each preceding action was wrong.

Usage

Hugging Face Datasets

Loading the whole dataset materializes a large dataset. For selective access without loading every row into RAM, use streaming below.

from datasets import load_dataset

ds = load_dataset("samatv256/jev-decisions-v1")
train = ds["train"]

choice = train.filter(
    lambda row: row["training"]["choice_eligible"]
)

Streaming Choice-eligible rows

from datasets import load_dataset

train = load_dataset(
    "samatv256/jev-decisions-v1",
    split="train",
    streaming=True,
)

for row in train:
    if row["training"]["choice_eligible"]:
        # Consume one row at a time; do not accumulate the entire corpus.
        use_for_choice_training(row)

training_split is retained inside each row and can also be checked while streaming. The loader's train split maps to files under data/train/.

PyArrow

import pyarrow.dataset as pads

dataset = pads.dataset(
    "hf://datasets/samatv256/jev-decisions-v1/data/train",
    format="parquet",
)
eligible = dataset.scanner(
    filter=pads.field("training", "choice_eligible") == True,
    batch_size=1024,
).to_batches()
for batch in eligible:
    consume(batch)

For broad compatibility across PyArrow versions, filtering each scanned batch is also valid:

for batch in dataset.scanner(batch_size=1024).to_batches():
    mask = batch.column("training").field("choice_eligible")
    consume(batch.filter(mask))

Polars

import polars as pl

lf = pl.scan_parquet(
    "data/train/*.parquet",
    hive_partitioning=False,
)
choice = lf.filter(pl.col("training").struct.field("choice_eligible"))
for batch in choice.collect_batches(chunk_size=1024):
    consume(batch)

For the hosted repository, use the Hub parquet URLs returned by the Hub API, or download the selected split first. scan_parquet is lazy; avoid calling .collect() on all rows unless the available memory is sufficient.

Training guidance

Choice, tool selection, and routing

Filter on training.choice_eligible == true. The conceptual input is the state plus the available candidate set; the target is the correct candidate/action in target (or the source-ordered target representation where the row is eligible). Candidate names, descriptions, and parameter schemas are part of the decision problem. This supervision supports tool selection, function/API routing, and next-action prediction. Model routing can use the same form after adding candidate models and model-performance labels.

Value

Filter on training.value_eligible == true. All current value-eligible records come from Open-SWE. The numeric target is source-supported trajectory outcome supervision, not a generally calibrated probability across all domains.

Completion

Filter on training.completion_eligible == true for completion control. In v1 these are success-backed terminal finish examples; the corpus has no currently eligible verified-failure continue examples, so this head is positive-only and should not be treated as a balanced continue/finish classifier. Do not infer completion from an agent merely stopping. Do not treat unknown-outcome or failed-trajectory actions as positive Choice labels.

Integrity and exclusions

• Original canonical artifact SHA256: c4c19101d0a7e5a0e57428704214b73eed8fb559cdb4db70293b16bec1231593
• Raw canonical records processed: 15,251,846
• Usable records: 11,978,080
• Excluded/preserved ineligible records: 3,273,766
• Exact duplicate IDs: 0
• Conflicting duplicate IDs: 0
• Train/validation/test trajectory overlap: 0

Excluded or preserved ineligible examples include unknown/unresolved trajectory outcomes, reasoning-only turns, multi-action records unsupported by the current atomic Choice target, non-generative targets, and targets missing from candidate sets. The build preserved these as ineligible records in its reconciliation; this public v1 contains the usable canonical artifact only. No failed or unresolved trajectory actions were silently promoted to positive Choice supervision.

The shards are a deterministic re-encoding of the original Parquet rows, partitioned only by the existing training_split. They preserve all columns and nested schema, every record exactly once, and row order within each split. There is no resampling or rebalancing. Most full training shards are about 1.3–2.8 GB; source record-size variation creates a few larger-than-target shards, and the final 19,408-row remainder is kept as a small shard rather than inflating its neighbor. Validation and test are each one shard. See publication_manifest.json for per-shard row counts, byte sizes, split assignments, and SHA256 values. The manifest also contains matching ordered record-ID hashes per split; canonical IDs were verified unique before publication, so this checks that no record was omitted, duplicated, or reordered. During the build, each full shard was also re-read with PyArrow to verify its file hash, schema, row count, and split purity. The writer routes unmodified Arrow table slices, preserving all remaining field values.

The canonicalizer constructs each visible state from the ordered history prefix ending before its target decision. Current/future tool actions, tool results, evaluator outcomes, reference patches, and resolution fields are kept in targets, labels, or provenance. It mechanically scans state for forbidden evaluator/reference keys, and publication validation confirms that sharding did not alter row content or order. training_split is a separate top-level field, not part of state; consumers should select a split before model input construction and must not feed labels or provenance into the model.

Attribution and license

This is a derived transformation/canonicalization corpus. NVIDIA is the developer of the four upstream datasets listed above, not of Jev Decisions v1. This repository is independently prepared and published by samatv256; it is not endorsed by or affiliated with NVIDIA.

At publication time, all four upstream Hugging Face dataset cards identify CC BY 4.0 as their dataset license. Their cards additionally identify Apache 2.0 and/or MIT licensing information; Open-SWE-Traces also carries MIT, Apache 2.0, BSD-2-Clause, and BSD-3-Clause additional licensing information and a per-repository SPDX license field. These terms are retained as provenance and are not replaced by this corpus's dataset-level attribution. In particular, the Open-SWE provenance.source_metadata_json / license_metadata_json fields preserve source metadata, including the repository license. Users must retain CC BY attribution and meet any applicable component, repository, and upstream terms when using or redistributing source-derived content. See SOURCE_LICENSES.md.

This dataset card does not grant rights beyond the upstream terms. NVIDIA's inclusion as a source developer does not imply endorsement or affiliation.

Repository contents

• data/train/, data/validation/, data/test/: publication-friendly Parquet shards.
• publication_manifest.json: machine-readable shard inventory, checksums, schema and row-content reconciliation.
• input_shards_manifest.json: source shard inventory from the frozen canonical build.
• audit_sample_100.md: deterministic 100-row human-readable audit sample; long fields are clipped for display only.
• source_revisions.json and SOURCE_LICENSES.md: canonical source pins and pre-publication license metadata.
• clean50k/data/ and clean50k/manifest.jsonl: the separate General CLEAN-50K training config and compact provenance/length manifest.

This repository contains the dataset, its data card, source and license metadata, integrity manifests, the separate General CLEAN-50K training subset, and a small audit sample. It does not publish model checkpoints or private research reports.