---
license: apache-2.0
task_categories:
  - text-generation
language:
  - en
tags:
  - agent
  - tool-use
  - function-calling
  - synthetic
  - methodology
size_categories:
  - n<1K
---

# Execution-Verified Agent Trajectories — Format & Method

This repository documents a **method and data format** for building supervised fine-tuning sets from agent
trajectories that are verified by *running the code*, not by asking a model whether the answer looks right.

**This is a specification plus synthetic examples, not a corpus.** The trajectories that trained
[Luthor 8B](https://huggingface.co/IAMIbrahim/luthor-8b) were generated against a private repository and cannot be
released. Everything needed to rebuild an equivalent set against your own repositories is here.

## Why verification-first

The usual way to build an agentic SFT set is to have a strong teacher model attempt tasks and keep the attempts
that look good — judged by another model, or by nothing at all. That trains fluency at *appearing* to fix code.

The approach here keeps a trajectory only if it ends in a patch that turns a **failing test suite green**, checked
by executing the suite in a per-task container. In the run that produced Luthor, 296 attempts yielded **138
verified trajectories** across 64 of 74 tasks — so roughly **54% of confident-looking attempts were wrong** and
were discarded. That discard rate is the entire argument for the method.

## Pipeline

```
mine tasks        real commits that fix a failing test  ->  fail-to-pass task specs
build images      one Docker image per task, pinned to the parent commit
roll out          N attempts per task with a teacher model driving real tools
verify            run the suite in the image; keep only green runs
window            trim, cap, and window to the trainer's context limit
```

Each stage is independently checkable, and the verifier is the test — there is no separate labelling step to
trust.

### Task mining

A task is a commit where a test that **failed at the parent commit passes at the commit**. This gives a
ground-truth patch and an objective success signal for free. The agent is shown the failing test and the repo at
the parent commit; it never sees the real fix.

### Verification

A trajectory passes only if all hold:

1. The extracted patch applies cleanly to the parent commit.
2. The previously-failing test passes after applying it.
3. No host-machine paths leaked into the transcript **as evidence in tool output** (a path appearing inside a repo
   file is not a leak; a path appearing in a command's output is).
4. The run terminated on its own rather than hitting the turn cap.

## Data format

ShareGPT-style JSONL. One line per **window**.

```json
{
  "conversations": [
    {"from": "system", "value": "...<tools>[{...}]</tools>..."},
    {"from": "human",  "value": "The failing test and what to fix"},
    {"from": "gpt",    "value": "<think>...</think>\n<tool_call>\n{\"name\": \"bash\", ...}\n</tool_call>"},
    {"from": "tool",   "value": "<tool_response>\n...\n</tool_response>"},
    {"from": "gpt",    "value": "Summary of the fix"}
  ],
  "luther": {
    "task_id": "repo:sha:prompt_style",
    "repo": "toy-examples",
    "sha": "a1b2c3d4e5f6",
    "n_turns": 8,
    "tool_errors": 0,
    "recovered_from_error": false,
    "verified": true,
    "window": 0,
    "loss_from": 0
  }
}
```

| Role | Meaning |
|---|---|
| `system` | Tool declarations in a Hermes-style `<tools>` block |
| `human` | The task statement |
| `gpt` | Assistant turn — reasoning and/or `<tool_call>` — **the only turns carrying loss** |
| `tool` | Tool output, wrapped in `<tool_response>` |

`loss_from` is an index into `conversations`: assistant turns **before** it are overlap context carried from the
previous window and must be masked out. Turns at or after it carry loss.

See [`examples/synthetic_trajectories.jsonl`](examples/synthetic_trajectories.jsonl) for two complete, runnable
examples in this exact schema — one clean fix, one that hits a tool error and recovers. They are invented toy
Python tasks.

## Windowing — the part that is easy to get wrong

Raw trajectories are large: a median of roughly **61k tokens**, dominated by tool output (~40k) and reasoning
blocks (~25k). Three transforms make them trainable at a 16k context:

1. **Truncate tool outputs** to ~4,000 characters. Directory listings and test logs are mostly noise past that.
2. **Cap `<think>` blocks** at ~12,000 characters.
3. **Window to the context limit with one-turn overlap** — do *not* tail-truncate.

Point 3 matters more than it looks. Tail-truncating a trajectory to fit the context removes its **end**, which is
precisely where the successful fix and the green test run are. A trainer that does this silently learns to
explore and never to finish. Windowing with `loss_from` keeps every part of the trajectory trainable while never
computing loss twice on the same tokens.

## Splitting

Split **by commit**, never by trajectory. Multiple attempts at one task share the same underlying fix, so a
trajectory-level split leaks the answer across the train/eval boundary and inflates eval scores.

## Reference statistics

From the run that produced Luthor 8B, for calibration:

| | |
|---|---|
| Tasks mined | 74 |
| Attempts | 296 (4 × 74) |
| Verified trajectories | 138 (64/74 tasks) |
| Train / eval trajectories | 95 / 16 (5 held-out commits) |
| Train / eval windows | 493 / 78 |
| Error-recovery examples | 12 |
| Mean turns | 24.2 |
| Window tokens (p50 / max) | 13,789 / 16,251 |
| Train tokens per epoch | ~6.39M |

Completed runs had a median of 22 turns and a p90 of 29 — a 30-turn cap truncated ~45% of attempts, so **set the
turn cap to at least 50**.

## Training notes

Loss on assistant turns only, masked to `-100` elsewhere and before `loss_from`. At 16k sequence length with a
~152k-token vocabulary, two things are effectively mandatory on a single 80GB GPU:

- **Fused linear cross-entropy** — an unfused loss materialises and repeatedly copies the logits tensor (~35 GB).
- **FlashAttention-2** — SDPA materialises the full seq² attention matrix per layer during gradient-checkpointed
  recompute (~16 GiB each). FA2 cut peak memory from >75 GB to 24.9 GB.

## Limitations

- **Synthetic examples only.** Two hand-built trajectories, for format illustration. Not a training corpus.
- **Single-domain reference stats.** The numbers above come from one Python data-engineering codebase.
- **Verification is only as good as the test suite.** A patch that games a weak test passes here too.
- **Teacher-dependent.** Trajectories inherit the teacher's habits; the verifier filters correctness, not style.

## License

Apache 2.0. The synthetic examples are original and carry no third-party rights.