README.md

---
license: other
language:
  - en
task_categories:
  - text-generation
size_categories:
  - n<1K
pretty_name: Ox Alpha Coding Reasoning (preview)
tags:
  - code
  - reasoning
  - chain-of-thought
  - distillation
  - synthetic-data
configs:
  - config_name: default
    data_files:
      - split: train
        path: train.jsonl
---

# Ox Alpha Coding Reasoning (preview)

Raw chain-of-thought traces on coding prompts, generated with `stealth/ox-alpha`
through OpenRouter and filtered down to the rows where the model actually thought.

This is a **preview slice**, not the finished dataset. Generation is still running.

## Why this exists

`stealth/ox-alpha` returns its reasoning **unsummarized**. That is unusual — most
hosted reasoning models either hide the CoT or replace it with a post-hoc summary.
Four checks confirmed it is the real trace:

1. **Hidden arithmetic.** Asked for `83729 * 45193 * 7` with "reply with ONLY the
   number", the CoT contained every intermediate (`83729*45 = 3,767,805`,
   `997*355 = 353935`) and a self-check line, while the answer was just the digits.
   None of those intermediates appear in the output, so they cannot have been
   reconstructed by a summarizer.
2. **Execution tracing.** Given a Python loop and asked for the final integer only,
   the CoT held all nine iterations plus a mid-sentence self-correction
   (`... wait return a after loop ends`).
3. **Texture.** Long traces carry dead ends, hedges, and recall attempts
   (`Actually I recall: in fabric v6/v7, there was a commit ...`), plus planning
   notes for the answer (`Write the final solution rigorously with lemmas.`).
4. **Streaming.** Reasoning arrives token-by-token, averaging 5.8 characters per
   delta, interleaved ahead of the content in the same stream.

## Filtering

The teacher uses an adaptive thinking budget: on easy prompts it emits little or no
reasoning at all. Roughly 51% of raw generations were discarded — down from 68% in
earlier revisions, because generation is now ordered to favour the domains that
actually elicit long reasoning.

| stage | rows |
|---|---|
| generated | 1,557 |
| dropped, reasoning under 500 chars | 643 |
| dropped, no reasoning emitted | 143 |
| dropped, truncated before finishing | 10 |
| dropped, empty answer | 4 |
| **kept** | **757** |

Kept rows also require `finish_reason == "stop"` and a non-empty answer.

Reasoning length among kept rows: min 504, median 4,329, mean 9,969, max 124,342 characters.

| domain | rows |
|---|---|
| repository_engineering | 503 |
| algorithmic_reasoning | 127 |
| general_implementation | 78 |
| debugging | 17 |
| c_cpp_systems | 8 |
| refactoring_optimization | 5 |
| sql_databases | 4 |
| backend_api | 4 |
| ml_data_engineering | 3 |
| testing | 3 |
| javascript_typescript_frontend | 2 |
| java_csharp_apps | 1 |
| rust_go | 1 |
| code_review_explanation | 1 |

Domain predicts trace length sharply, which makes it a cheap pre-filter: skipping the
low-CoT domains avoids spending generations on prompts the teacher answers without
thinking. `repository_engineering` (regressions in real repositories) is an order of
magnitude above everything else. Medians over all 1,557 raw generations, before filtering:

| domain | raw rows | median reasoning chars |
|---|---|---|
| repository_engineering | 578 | 5,218 |
| algorithmic_reasoning | 298 | 391 |
| c_cpp_systems | 20 | 278 |
| ml_data_engineering | 20 | 213 |
| testing | 13 | 201 |
| refactoring_optimization | 26 | 200 |
| backend_api | 18 | 190 |
| debugging | 72 | 187 |
| code_review_explanation | 3 | 186 |
| rust_go | 13 | 182 |
| sql_databases | 14 | 168 |
| javascript_typescript_frontend | 15 | 127 |
| shell_docker_cicd | 5 | 122 |
| general_implementation | 454 | 106 |
| java_csharp_apps | 8 | 84 |

Only `repository_engineering` clears the 500-character filter on its median. Every other
domain sits below it, so most of their rows are dropped no matter how many are generated.

## Schema

| field | description |
|---|---|
| `id` | seed id, inherited from the prompt source |
| `domain` | task domain label from the prompt source |
| `messages` | the prompt, OpenAI chat format |
| `reasoning` | raw CoT, exactly as returned |
| `answer` | final response |
| `messages_think` | `messages` plus an assistant turn with `<think>…</think>` inlined, ready for SFT |
| `reasoning_chars` | length of `reasoning` |
| `completion_tokens` | reported by the API |

## Generation config

| setting | value |
|---|---|
| teacher | `stealth/ox-alpha` (OpenRouter) |
| reasoning effort | `high` |
| max tokens | 32,768 |
| temperature | provider default |
| concurrency | 12 |
| prompt order | domains sorted by measured median CoT length, highest first |

## Prompt source

Prompts are the `input` field of
[trjxter/Kimi-K2.7-CodingTraces-9000x](https://huggingface.co/datasets/trjxter/Kimi-K2.7-CodingTraces-9000x),
reused here as seeds. Only the prompts were taken; every reasoning trace and answer in
this dataset was generated fresh. Credit for the prompt collection belongs to that
dataset's author.

## Caveats

- The teacher's identity beyond the `ox-alpha` label is undisclosed. It self-reports as
  "ox-alpha, developed by an undisclosed organization" and does not claim any other identity,
  including inside its own reasoning.
- `usage.completion_tokens_details.reasoning_tokens` is reported as `0` by the API even when
  reasoning text is present, so token-level accounting of the CoT is not available.
- No correctness verification has been run on the answers. Traces are unfiltered for
  factual accuracy — the only filter applied is reasoning length.
- Preview size. Treat it as a sample of the generation distribution, not a training corpus.