NVIDIA's Open Agent Trajectories Just Tripled to 920,000

What you need to know

• Three trajectory corpora sit in NVIDIA's Hugging Face org, totalling 920,208 live rows on 26 August 2026.
• The licence is CC BY 4.0 on all of them — an open content licence with an attribution obligation, not an OSI open-source software licence.
• This is a programme, not a launch. The repositories date from March and April 2026; the newest expansion landed on 21 August.
• Only about 31% of documented Open-SWE-Traces trajectories are marked resolved. The headline count is not the usable count.
• Records carry tool calls and environment observations — the part you cannot reconstruct from prompt-completion data.
• Contamination against SWE-bench is a live risk, but the source corpora are named, so you can check it.

For two years the open-model conversation has been an argument about weights: who released them, under what licence, at what parameter count. A useful argument, and one that quietly obscured the fact that for one increasingly important class of model — agents that call tools — the weights were never the expensive part.

NVIDIA put the point plainly in a Hugging Face post on 8 July 2026: "Open weights matter. But for agents, weights are only part of the story. Reproducibility also depends on the datasets, curation choices, training recipes, and evaluation methods behind the model." The same post has the sharpest one-line framing of the problem we have read this year: "An agent that can't recover from a broken API call, or a workflow it has never seen, is not really an agent."

Recovery is a learned behaviour. You learn it by watching something fail and then choosing a next step. And to record that, somebody has to run a real agent against real repositories, thousands of times, and keep everything the environment sent back.

What is actually on the table

Four datasets are relevant. Three are software-engineering trajectory corpora; the fourth is general tool use. We pulled the live split sizes from the Hugging Face datasets server on 26 August 2026 rather than trusting the prose on the cards, and the difference turned out to matter.

Two of those cells deserve a second look. Open-SWE-Traces still describes itself as "200k+ agent trajectories" and its distribution tables add to exactly 207,489. Those tables cover the June release. Commits dated 21 August 2026 added four more splits, and the live row counts now total 567,824. The prose has not caught up with the parquet.

The other is the licence. Every one of these cards names the Creative Commons Attribution 4.0 International Licence. That is an open content licence with an attribution obligation attached, not an OSI-approved open-source software licence, and the distinction is not pedantry when your compliance reviewer asks what you trained on.

Why a trajectory beats an instruction pair

If you have only ever fine-tuned on prompt-completion pairs, the shape of these records is the interesting part. The schema is public, so we can be concrete about what each format gives you.

Note that the last three rows apply to Open-SWE-Traces only. SWE-Zero and SWE-Hero expose instance_id, repo, license, trajectory_id, trajectory, model_patch and dataset, with no success flag in the schema. If your plan involves filtering to trajectories that worked, that plan only runs on one of the three corpora.

The number that matters is not 920,208

Here is the figure nobody puts in a headline. Work through the Open-SWE-Traces distribution tables and the 207,489 documented trajectories break down as roughly 65,200 resolved, 95,500 unresolved and 46,800 unknown — a resolved rate of about 31%, with a further 23% where the outcome could not be determined.

That is not a criticism. Failed trajectories are valuable, arguably the most valuable rows in the set, since they are where recovery behaviour lives. But if your plan is "SFT on successful agent runs", your effective corpus is a fraction of the advertised size and you should budget accordingly.

Language distribution is the second thing to check. Across those 207,489 documented trajectories: Python 48,179, Go 46,834, TypeScript 36,897, JavaScript 29,360, Rust 21,735, Java 13,176, PHP 10,323 — and then a cliff. C accounts for 683 trajectories and C++ for 302, under half a percent combined.

The transfer question, honestly answered

Most teams reading this are not building a coding agent. They are building something that queries an internal API, reads a document store and writes to a ticketing system. Does SWE trajectory data help?

Partly, and it is worth being precise about which part. The structural skills transfer well: emitting a syntactically valid call against a supplied schema, reading a tool response and deciding whether it answered the question, recognising an error return and trying a different approach, and holding a multi-step plan together across a dozen turns. Those are format and control-flow behaviours, largely domain-independent.

The domain reasoning does not transfer. A model trained heavily on repository navigation brings repository-shaped assumptions to your CRM: it expects a filesystem, expects to read before writing, and expects errors shaped like stack traces. Your tools return JSON error envelopes with business meanings, and nothing here teaches that.

For non-SWE work, NVIDIA's own Nemotron line and the Nemotron-SFT-Agentic-v2 collection are the better starting point: its customer-service subset covers multi-turn conversations across 838 domains with authentication, lookup and booking flows, which is closer to what most business agents do. If your target is tool-call accuracy rather than code editing, our guide to fine-tuning for tool-call accuracy covers building the evaluation before the training set.

What a small team can realistically do

The economics are the whole story. Generating close to a million trajectories means running an agent framework against thousands of repositories, in isolated containers, with a large model in the loop for every turn. The compute bill is significant; the engineering time to build the harness is larger. That has been out of reach for a fifteen-person team in Pune or a two-person spin-out from a UK university lab, and it is why agent fine-tuning stayed a lab activity.

Consuming trajectories is a different order of cost. Filter to a few thousand rows matching your language, your approximate tool shape and, where the flag exists, a resolved outcome. Rewrite the tool schemas in those trajectories to your own tool names and argument structures, so the model learns your interface rather than OpenHands'. Then train a LoRA or QLoRA adapter on a small open-weight base — our eval-driven LoRA and QLoRA recipe sets out the ordering. Two rented 80GB cards, or an academic allocation through a UK university cluster or IndiaAI Mission compute, puts that inside a week.

Establish whether you need to fine-tune at all first. A better system prompt and a cleaner tool schema fix more tool-call failures than an adapter does, and the fine-tuning decision ladder exists because most teams reach for training when the cheaper rung would have worked.

Three limitations worth naming

First, these are synthetic trajectories and they inherit the generating model's habits. Every trace in SWE-Zero and SWE-Hero came from Qwen3-Coder-480B-A35B-Instruct. If that model has a characteristic way of getting stuck, you are about to teach it to yours. Mixing generators helps, which is presumably why Open-SWE-Traces now spans four — the general problem is the one we covered in generating and filtering synthetic data without collapse.

Second, distribution mismatch. Your agent has between five and fifteen tools with names your team invented; these trajectories use a coding agent's toolset. No amount of data volume closes that gap.

Third, contamination. The cards state that issue statements came from SWE-Gym, SWE-Gym-Raw, R2E-Gym-Subset, SWE-Fixer-Train-110K, SWE-rebench and SWE-rebench-V2, and that the sets are curated to improve performance on SWE-bench style tasks. Disclosed rather than hidden — but it means a public benchmark number from a model trained on this data is uninterpretable without an overlap analysis. Run one, using detecting contamination and keeping evaluations clean, and hold out a set from your own repositories that could not appear upstream.

Is this actually news?

Partly, and we would rather say so. Nemotron-SFT-Agentic-v2 lists a creation date of 1 December 2025 and its repository dates from March 2026. The SWE-Zero and SWE-Hero repositories were created on 17 April 2026, with a technical report on arXiv from early April. Open-SWE-Traces was created on 16 April 2026 and its card describes an initial release in June. This is a programme running for the better part of a year, not an announcement made this week.

What is genuinely recent is the scale. Commits dated 21 August 2026 added trajectories from DeepSeek-V4-Flash and Qwen3.6-27B plus a third agent scaffold, taking Open-SWE-Traces from roughly 207,000 documented trajectories to 567,824 live rows. Nearly tripling a corpus is a material change, and it is why the total across the three SWE datasets now sits above 900,000.

The wider context is a stated position. In a post from 10 March 2026, NVIDIA said it has "shared more than 2 petabytes of AI-ready training data across more than 180 datasets and 650+ open models", with training recipes and evaluation frameworks on GitHub. Whatever your view of a chip vendor lowering the cost of training on its own hardware, the artefacts are real and the licence is checkable.

What to do this week

Open the distribution tables before you open a terminal. Count how many trajectories exist in your language and, where the flag exists, how many are marked resolved. If the answer is a few hundred, this is not your dataset and you have saved yourself a fortnight.

If it is workable, read the licence section properly and write down your attribution plan while that is still cheap. Then build the evaluation before the training set, because a tool-use adapter that improves nothing is indistinguishable from one that improves everything until you can measure it.

The larger shift is worth sitting with. When weights were the bottleneck, open weights were the story. For agents the bottleneck moved to the recordings — and a corpus of nearly a million of them, licensed for commercial use, changes who is permitted to attempt this work at all. That now includes a team in Bengaluru with two rented GPUs and a clear question. A year ago it did not.