File size: 6,686 Bytes
a6c60d7
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
79bfbc7
a6c60d7
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
79bfbc7
a6c60d7
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
---
license: cc-by-4.0
language:
- en
pretty_name: Intelligence Ladder
size_categories:
- 1K<n<10K
task_categories:
- text-generation
tags:
- code
- benchmark
- evaluation
- llm-evaluation
- edge-ai
- python
configs:
- config_name: results
  data_files:
  - split: train
    path: data/results.jsonl
- config_name: leaderboard
  data_files:
  - split: train
    path: data/leaderboard.jsonl
---

# Intelligence Ladder

Per-trial results and frozen task files for a seven-rung, behaviourally graded Python coding benchmark.
It measures how far up a ladder of harder task families a model climbs under one fixed protocol, and
how consistently, for hosted API models and a 4B model on an owned edge NPU node.

## Dataset summary

- **1309 trials** across 8 models: 28 tasks (7 rungs x 4) x (3 productive + 3 trap repeats) = 168 per
  model; `qwen-plus` has 133 (stopped during R6, R7 not run).
- **Grading is behavioural only**: hidden asserts run under pytest, planted mutants, existing and feature
  test suites. No LLM judge, no text similarity.
- **Traps**: an impossible variant of each task whose only correct answer is `UNKNOWN`. Traps are reported
  separately and never rescue productive failures.
- **Solved task**: at least 2 of 3 productive repeats pass.

| Rung | Family |
|---|---|
| R1 | Simple functions |
| R2 | Edge cases / Unicode / nonmutation |
| R3 | Three-file package repairs |
| R4 | Tool-mediated debugging (simulated `read` tool, exact call accounting) |
| R5 | Bounded two-turn revisions (revised spec must reject the old behaviour) |
| R6 | Implementation plus self-authored tests that kill at least 4 of 5 planted mutants |
| R7 | Multi-file package feature (three required source files changed; existing and feature tests green) |

## Configurations

### `results` (`data/results.jsonl`)

One row per trial.

| Field | Type | Meaning |
|---|---|---|
| `id` | string | `<task>-<code|trap>-<repeat>` |
| `task`, `rung`, `repeat`, `trap` | string, int, int, bool | Task id (e.g. `R4-C`), rung 1–7, repeat 1–3, trap flag |
| `model` | string | Result label; see `data/models.json` for model ref, route and hardware class |
| `freeze_sha256` | string | sha256 of the freeze manifest the trial ran under (both shipped in `frozen/`) |
| `score.pass` | bool | Trial verdict |
| `score.*` | mixed | Structural fields by rung: `returncode`, `kind` (trap), `tool_exact`, `actual_calls`, `initial`/`final`/`obsolete_rejected` (R5), `behavior`/`tests_on_reference`/`mutants`/`mutants_killed`/`mutation_kill_rate` (R6), `existing`/`feature`/`changed_paths` (R7), `error` (harness rejection message only) |
| `wall_s` | float | Trial wall time, seconds, including transport and scoring |
| `turn_metrics[]` | list | Per model turn: `wall_s`, `ttft_s`, `tok_s`, `inference_s` (RK1), `output_tokens`, `usage.{prompt,completion,total,reasoning,cached}_tokens` where the route reports them, `metric_source` |
| `evaluation_repair` | string | Present on 3 rows re-scored from the saved answer with the frozen evaluator (no new model call) |

`score` has a rung-dependent shape; load with `json` if your tooling needs a fixed schema.

### `leaderboard` (`data/leaderboard.jsonl`, same rows as `results/leaderboard.csv`)

One row per model, generated by `reproduce.py --write` from `data/results.jsonl`: tasks solved with
cluster-bootstrap 95% CI, productive pass rate with CI, eligible families, ladder height, trap abstention,
coverage, token totals, median and p90 trial wall time, median TTFT and median tok/s (non-reasoning turns).

## Frozen files

`frozen/` holds byte-identical copies of the task files (`rungs/R1–R7.json`, which include the grading
asserts, reference solutions for R6 and package files), the prompt builder, both evaluators, the protocol
and the freeze manifests. `reproduce.py` checks every shipped file against the manifests. Reserved
held-out variants and the site-specific runner are **withheld**; their hashes stay in the manifest so a
later release can prove they were not changed (see `frozen/WITHHELD.md`).

## Models

| Label | Model ref | Route | Hardware class |
|---|---|---|---|
| `astra` | openai/gpt-6-astra | OpenRouter, streaming | hosted API |
| `deepseek-v4-flash` | deepseek/deepseek-v4-flash | OpenRouter, streaming | hosted API |
| `glm-4.7-flash` | z-ai/glm-4.7-flash | OpenRouter, streaming | hosted API |
| `gpt-5-nano` | openai/gpt-5-nano | OpenRouter, streaming | hosted API |
| `qwen3.7-flash` | qwen/qwen3.7-flash | OpenRouter, streaming | hosted API |
| `alibaba/qwen-flash` | qwen-flash | Alibaba Cloud Model Studio, buffered, thinking off | hosted API |
| `alibaba/qwen-plus` | qwen-plus | Alibaba Cloud Model Studio, buffered, thinking off | hosted API |
| `RK1-Qwen3-4B` | Qwen3-4B-Instruct-2507, RKLLM W8A8, context 2048 | local NPU via RKLLM runtime 1.3.1 | edge SoC: Turing RK1, Rockchip RK3588, 3-core NPU, 32 GB |

Output caps: 512 tokens on R1–R5 and 2048 on R6–R7 for hosted routes; RK1 kept its native 512-token output
and 2048-token context on every rung.

## Intended uses

- Compare where on the ladder different models stop under a fixed, small output cap.
- Compare an edge NPU model with hosted models on identical tasks and grading.
- Study trap abstention and reasoning-token exhaustion under a fixed cap.
- Template for adding a model with the public runner (`harness/run_model.py`).

## Limitations and biases

- 28 tasks and 3 repeats at temperature 0: intervals are wide and repeats are not independent.
- The task files are now public. Any model trained after this release may have seen them; treat new
  results as contaminated unless checked against the withheld variants.
- Resource caps differ between RK1 and hosted routes on R6/R7.
- Latency comes from different instruments per route and includes transport; it is not a serving
  benchmark. Hosted serving hardware is not disclosed. Power was not metered.
- `qwen-plus` coverage is incomplete. Hosted models can change behind a stable model ref; results describe
  the runs made on 2026-10-27 and 2026-10-28.
- English-only prompts; Python-only tasks.

## Personal and sensitive information

None. The dataset holds synthetic programming tasks and machine-generated scores. Model answer text,
evaluator logs and all operator or infrastructure details were removed before release.

## Licence

Data, task files and documentation: CC BY 4.0. Code in the companion repository: MIT.

## Citation

```
@misc{intelligence_ladder_2026,
  title  = {Intelligence Ladder: a frozen, behaviourally graded coding ladder for hosted and edge models},
  author = {cloudlabworks},
  year   = {2026},
  note   = {Dataset and reproduce scripts}
}
```