---
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train.jsonl
  - split: dev
    path: data/dev.jsonl
license: apache-2.0
task_categories:
- text-generation
language:
- en
tags:
- dpo
- preference
- swe-agent
- code
- reasoning
size_categories:
- n<1K
---

# vinhable/vinhable_single

Preference pairs for DPO on multi-turn software-engineering agent trajectories from the Albedo
subnet (Bittensor SN97): **GLM-5.2 regenerated with its own reasoning vs the reigning King 127**
on the same task. This is the **single** variant (one pair per task: the comparison with the largest score gap); its sibling is
[`vinhable/vinhable_double`](https://huggingface.co/datasets/vinhable/vinhable_double). Both share the same tasks
and the same task-level train/dev split, so they can be compared directly.

| | rows | train | dev | pairs | GLM chosen | King chosen | tasks |
|---|---:|---:|---:|---:|---:|---:|---:|
| single | 1218 | 1127 | 91 | 214 | 159 | 55 | 218 |

Median score gap 0.326 (minimum 0.15); mean GLM score
0.696, mean King score 0.483 over the pairs.

## Turn groups

Rows follow the turn-group layout of
[`vinhable/gen_vinhable`](https://huggingface.co/datasets/vinhable/gen_vinhable): each side needs at
least four assistant turns (0 pairs dropped) and is
cut into the same number of behaviour groups, `min(6, turns)`. Unlike `gen_vinhable`, the first
groups of the two sides need **not** share a behaviour: the sides come from different models and
may open differently. A pair yields one row per prefix length `k` (`sample_uid` = `pair_id#k<k>`,
`prefix_groups`, `group_count`, `is_full_trajectory`): both sides hold their first `k` groups and
**only group `k`'s assistant turns carry `loss: true`**, so each turn is a target exactly once
across a pair's rows; a turn's own `loss: false` (see below) is kept. Rows whose last group has no
supervisable turn on a side are dropped (88 rows).
Filter `is_full_trajectory == true` for one trajectory-level row per pair.

## How the data was made

* **Tasks.** Production evaluation samples of King 127 in the graded-judge era (runs finished
  2026-09-23 to 09-26), taken from Albedo's public artifacts. 90% were picked where the published
  GLM-5.2 reference beat both King rollouts by a wide margin, 10% where the King clearly beat every
  reference run (so that some pairs prefer the King and "looks like GLM" cannot become a shortcut).
* **GLM side.** GLM-5.2 continues the production prompt turn by turn with reasoning enabled
  (OpenRouter, provider Baidu). Each turn is stored exactly as a Qwen3.6 candidate writes it:
  `reasoning` + `\n</think>\n\n` + action. Later turns see earlier turns the way production
  renders history (actions only). Environment observations come from production's simulator with
  repository grounding (real snapshot of the task's repo; commands run against it where possible).
  At generation time only, a short instruction appended to the latest observation asked GLM to
  reason before every turn; it is **not** in the stored data.
* **King side.** The King's own two production rollouts of the task, with their production scores.
* **Scores.** Albedo's graded A-T judge (GLM-5.2, top-20 logprobs) on the task's own published
  checklist. The King's scores are production's; the GLM rollout was scored locally with the same
  judge code. 25 pairs have a GLM score read with a
  whitespace-tolerant logprob alignment (the provider's token stream dropped a space that the
  content kept; verdict letters are unaffected).
* **Pairs.** GLM is compared with each King rollout; a comparison qualifies when the gap is at least
  0.15. The higher score is `chosen`. Ties are dropped.

## Row schema

| Field | Meaning |
|---|---|
| `prompt` | production context up to the cut point; every message `loss: false` |
| `chosen`, `rejected` | continuations: assistant turns and environment observations (`role: user`) |
| `direction` | `glm_over_king` or `king_over_glm` |
| `chosen_side`, `rejected_side` | `glm` or `king#r1` / `king#r2` |
| `glm_score`, `king_score`, `margin` | scores of the two compared rollouts; `margin` = GLM - King |
| `king_scores_both_rollouts` | both King rollouts' production scores |
| `task_role` | `main` (GLM reference beat the King) or `contrast` (King beat the reference) |
| `sample_uid`, `prefix_groups`, `group_count`, `is_full_trajectory` | position of the row in its pair's group split |
| `chosen_behavior_sequence`, `rejected_behavior_sequence`, `aligned_groups`, `aligned_fraction` | behaviour labels of the groups so far |
| `split`, `task_id`, `eval_run_id`, `sample_id`, `source`, `sample_phase`, `question_mode`, `king_version` | provenance |
| assistant turn: `content`, `loss`, `think_closed`, `tokens` | text after `<think>\n`; supervise?; closes `</think>`; Qwen3.6 tokens incl. `<|im_end|>` |
| assistant turn flags | `harness_text` (truncation notice), `empty_think`, `over_turn_limit` (> 4,096 tokens), `nudge_echo` (see below) |

## Loss and rendering contract

* Render every completion turn verbatim as `<|im_start|>assistant\n<think>\n` + `content` +
  `<|im_end|>`; do not pass it through the chat template.
* When a turn is supervised, its context should hold earlier turns **as production renders them**:
  the chat template drops earlier reasoning, so the model never sees its past thinking.
* `loss: false` on the prompt, observations, harness notices, turns with an empty think block,
  turns over 4,096 tokens, and `nudge_echo` turns: GLM turns (254 of
  2875) whose visible answer repeated the headings of the generation-time
  reasoning instruction.

## Thinking audit

| | GLM turns | King turns |
|---|---:|---:|
| assistant turns | 2875 | 2837 |
| supervised | 2618 | 2832 |
| close the think block | 100.0% | 99.7% |
| empty think block | 2 | 0 |
| median turn length (Qwen3.6 tokens) | 521 | 534 |

GLM reasons longer than the King on average (about 490 vs 360 reasoning tokens per turn on these
tasks).

## Caveats

* Small: meant as a signal test before scaling up.
* GLM was scored by a local run of the judge, the King by production; on re-judged King rollouts
  the local judge differed from production by about 0.06 on average, hence the 0.15 margin.
* Observations are simulated (grounded where the command could be executed on the snapshot).
* In `vinhable/vinhable_double`, pairs of the same task share the GLM side.