Book a Demo

Trajectory data for AI labs

Coding-agent sessions from real work, including every time the developer said no.

Complete, consented trajectories from live codebases: prompts, tool calls, diffs, the human corrections, and the commits that record what survived.

Request a pilotSee what we license

Coverage today: Claude Code. Codex, Cursor, Gemini CLI and OpenCode are captured through the same layer and added as they pass acceptance.

session_9c2e.jsonl · claude-code · claude-sonnet-4-6repo: private · go
  1. 00:00userrate limiter lets bursts through right after a restart
  2. 00:07tool_useread src/ratelimit/bucket.go
  3. 00:24tool_useedit bucket.go +11 −3 persist counters to redis on shutdown
  4. 00:39assistantCounters now survive restarts.
  5. 00:58userno, that's not it. refill uses wall clock, so after a restart it thinks a whole window passed. clamp the refill instead.
  6. 01:16tool_useedit bucket.go +5 −9 clamp elapsed to window on first tick
  7. 01:29tool_usebash go test ./...
  8. 01:52tool_resultok ratelimit 0.41s
  9. 02:10commit7d21f4a fix: clamp token refill after restart
1 correction turn, labeled5 of 16 agent lines survived to commitcommit linked

What you can’t get from a public dataset or a vendor’s task farm

Free research corpora prove the demand. Staged-task vendors prove the budget. Neither can hand you the moment a developer rejects the agent’s plan inside a codebase that matters to them.

Public research datasetsVendor-staged tasksTrajector
Where sessions come fromOpen-source repos, opt-inTasks written by the vendor, performed for payLive codebases, including private ones, work that would have happened anyway
Human correctionsPresent, unlabeledRare — tasks are designed to be completedLabeled, with the developer’s own reason where they gave one
Outcome verificationCommit-linkedGrader-scoredCommit-linked, line-level survival, test results
Dead ends and abandoned sessionsPresent, unfilteredFiltered outKept and labeled as their own product
FreshnessContinuous, publicBatch, on deliveryContinuous, with model-version slices on request
LicenseResearch termsCommercialCommercial training and evaluation, consent chain attached

Where sessions come from

Public research datasets
Open-source repos, opt-in
Vendor-staged tasks
Tasks written by the vendor, performed for pay
Trajector
Live codebases, including private ones, work that would have happened anyway

Human corrections

Public research datasets
Present, unlabeled
Vendor-staged tasks
Rare — tasks are designed to be completed
Trajector
Labeled, with the developer’s own reason where they gave one

Outcome verification

Public research datasets
Commit-linked
Vendor-staged tasks
Grader-scored
Trajector
Commit-linked, line-level survival, test results

Dead ends and abandoned sessions

Public research datasets
Present, unfiltered
Vendor-staged tasks
Filtered out
Trajector
Kept and labeled as their own product

Freshness

Public research datasets
Continuous, public
Vendor-staged tasks
Batch, on delivery
Trajector
Continuous, with model-version slices on request

License

Public research datasets
Research terms
Vendor-staged tasks
Commercial
Trajector
Commercial training and evaluation, consent chain attached
  • Full
  • Partial
  • Missing

What we license

Three products, each built on the one below it. Buy the layer your pipeline needs.

Base layerRaw sessions

The complete record of a developer working with a coding agent: every prompt, file read, edit, command, and output, in order. Consented, scrubbed, and deduplicated JSONL. Every product below is cut from this.

Priced per token
For SFT and mid-training

SFT data

The same recording, with a label on every line the agent wrote: it survived to the commit, or it was thrown away.

  • Nothing removed. Wrong attempts, failing test runs, and retries stay in, because the loop is what the model has to learn.
  • Survival label on every agent edit: kept, rewritten, or discarded, at line level.
  • Session outcome attached: test results and the linked commit where present.
  • Slice by label: accepted lines only, whole sessions, or the error-and-recovery loop on its own.

Raw data you have to grade yourself. This arrives graded.

Priced per session

Volume tiers. Filterable by language, repo visibility, agent, and model version.

For preference training and reward models

Preference data

The moment the agent said “done” and the developer said “no”, cut out and placed side by side.

  • Rejected attempt and accepted attempt, aligned as one pair.
  • The developer’s own words, plus a labeled reason. In the session above: misdiagnosed root cause, persistence vs. refill math.
  • Rejections from developers on their own projects, on their own deadlines. Not paid raters on staged tasks.
  • Teaches the model which plans a real person turns down, and when it should have asked.

Others sell ratings. We sell the moment a real person said no on a real project.

Priced per pair

Human-audited subset available at a premium, with reported label accuracy.

For reinforcement learning

RL environments

The same recording, turned into a level the model can play again and again.

  • Repo reset to the commit before the agent touched it, in a container that builds.
  • The developer’s original prompt as the task statement.
  • The tests that gated the real commit as the verifier: pass scores, fail does not.
  • Resettable and repeatable. Each environment hand-checked for a clear task and a verifier that actually covers the change.

Other environments are invented problems. Ours are bugs that actually happened.

Priced per environment, plus per rollout

One-time license for the task set; usage fee for managed rollouts.

  1. 1
    Raw sessions

    You see the process, not what was right.

  2. 2
    SFT data

    You know what was right.

  3. 3
    Preference data

    You know why a person said no.

  4. 4
    RL environments

    The model tries it and is scored automatically.

Each layer is one step closer to going straight into your training pipeline, and priced one step higher. Every product can be scoped by distribution: private repos only, a language or stack, sessions with at least one correction, or sessions on a named model version.

What moves the price

Volume is the smallest lever. These are the ones that matter.

Distribution scarcity

Private repos over public. Uncommon languages and stacks over mainstream. Enterprise-scale monorepos over side projects.

Signal density

Sessions with corrections over clean runs. Failure-and-recovery over first-try success. Abandoned sessions priced on their own.

Freshness

Sessions on a model version from its first 30 days carry a premium: that is when labs most want to see real behavior.

License scope

Non-exclusive by default. Time-boxed exclusivity on a slice, or full exclusivity, priced accordingly.

Targeted collection

Name the distribution you need. We raise contributor incentives on it and deliver a scoped batch. Quoted per project.

Verification depth

Automated labels by default. Human-audited subsets and hand-verified environments as paid upgrades.

No list prices, on purpose. Pilot batches are quoted against the scope above. A pilot is typically a few thousand SFT sessions or a few hundred preference pairs in a distribution you choose, delivered in two weeks, with the option to extend to a standing subscription.

Start with the sample

300 preference pairs from public repos, fully scrubbed, under a research license. Run your own analysis before anyone books a call.

Request the sample

If you publish on it, cite the dataset card. If you want the private-repo version, that is the pilot.

{
  "pair_id": "9c2e-t4",
  "session_id": "9c2e",
  "agent": "claude-code", "model": "claude-sonnet-4-6",
  "repo_visibility": "public", "language": "go",
  "rejected":  { "turn": 3, "diff": "...", "survived_lines": 0 },
  "accepted":  { "turn": 5, "diff": "...", "survived_lines": 5 },
  "correction": {
    "user_text": "no, that's not it. refill uses wall clock...",
    "stated_reason": // contributor-supplied, optional
      "the elapsed calc assumed continuous uptime",
    "inferred_reason": "wrong root cause: persistence vs refill math",
    "confidence": 0.86,
    "failure_mode": "misdiagnosed_root_cause",
    "intent": "fix"
  },
  "outcome": { "commit": "7d21f4a", "tests": "pass" },
  "audited": false
}

Accepted before it reaches you

Every session passes five gates. What fails, you never see and never pay for.

01Capture

Uploads signed with per-device keys from reproducible CLI builds.

02Scrub

Keys, tokens, env vars, and internal hosts removed on the contributor’s machine, checked again server-side.

03Validate

Schema, event ordering, and timing checked against real API latency.

04Dedupe

Exact and near-duplicate detection across the whole corpus.

05Score

Every session scored for resolution; a sampled subset human-reviewed and the accuracy reported.

Rights you can build on

Explicit, per-project consent

Capture is opt-in for each repository. Nothing is collected from a project the contributor hasn’t enabled.

Rights attestation at onboarding

Contributors attest that shared sessions cover code they own or that is open source. Recorded and attached to every delivery.

Perpetual commercial license

Delivered datasets carry a perpetual license for model training and evaluation. Deliveries are not recalled.

Contributor control, going forward

Contributors can pause capture, exclude repositories, and delete local buffers at any time. This stops future collection; it does not unwind delivered data.

Start with a scoped pilot

Tell us the distribution and the training stage. We come back with a batch size, a delivery date, and a quote.

Request a pilotSee the sample first