digitable-lol/ouroboros-trace-help

Trace Help — does an execution trace help a model answer questions about a run?

In one minute. Twelve small programs in six languages (Python, JavaScript, C, C++, Go, Elixir). Each was run once with a fixed command. Five questions per program ask what actually happened on that one run: how many times a function was called, what a particular call returned, what it was called with, whether a function ran at all, which function raised. Sixty questions in total.

Every record carries the same question in two settings:

setting	what the model is given
prompt_no_trace	the full source, the exact command line, and what the program printed
prompt_with_trace	the same plus the execution trace of that same run

The point of the dataset is the gap between the two. Nothing else changes — not one character of the rest of the prompt, not the sampling seed.

Where the correct answers come from

They are not opinion and not a model's output. Each answer was written by hand while the program was being authored, then checked against the real run: the builder pulls the same quantity out of the trace and refuses to produce the dataset if the two disagree. All sixty agreed. The key_source field of every record says exactly which quantity in the trace the answer is.

What it measures, and what it does not

Measures: whether a recorded call trace lets a model answer factual questions about one concrete execution of code it has not seen before.

Does not measure:

• Code quality, bug finding, or repair.
• Anything about long traces. These programs produce 20-50 trace lines and the trace fits in the prompt whole. Traces of megabytes are a different problem this dataset says nothing about.
• Long-context handling, retrieval, or tool use.
• A model's ability to produce traces — the traces are given.
• General programming skill: the questions are deliberately narrow.

The benefit it shows is narrow, and the labels are there so you can see that. On was_called questions a capable model is already at 100% without the trace, so the trace adds nothing. The gain sits on questions about values.

Size and labels

records	60 (test)
programs	12
languages	6 — python, javascript, c, cpp, go, elixir (2 programs each)
question kinds	5
settings per record	2
model calls for one pass	120 (60 × 2); 600 with the 5 repeats used below

Question kinds (question_kind):

value	question	records
return_value	what did the Nth call of F return	28
call_count	how many times was F called on this run	18
was_called	was F called at all	11
argument_value	what was F called with	2
raised_exception	which function raised	1

The question text is Russian, because that is the language the measurement was taken in; translating it would make the numbers below not apply to the prompts in the file. The programs, the traces and the field names are English.

Fields

field	meaning
id	question id, e.g. orders-1
program	program name, e.g. orders
language	python, javascript, c, cpp, go or elixir
question_kind	see the table above
question	the question, as asked
answers	list of accepted answers (usually one)
key_source	how the answer is derived from the trace: function, call index, argument index
source_code	full source of the program
run_command	the exact command the program was run with
stdout	what the program printed
trace	the execution trace of that run, one JSON object per line
prompt_no_trace	the complete prompt for the control setting
prompt_with_trace	the complete prompt for the trace setting
source_chars, trace_chars, prompt_no_trace_chars, prompt_with_trace_chars	sizes

Trace format: one JSON object per line. "p":"in" is entry into a call — fn name, a arguments, id call number. "p":"out" is the exit of the same call with the same id — r returned value, x raised value, d duration. A function absent from the record was not called on that run.

Across the twelve programs the traces are 3.7× the size of the sources; the prompt grows from a median of 1623 characters to 5919.

Splits — read this before training on it

• test — 60 records, all 12 programs. This is the dataset. Use it for evaluation.
• train — 30 records, 6 programs (one per language).
• validation — 30 records, the other 6 programs (one per language).

train and validation together are exactly the same 60 records as test, cut by program so that no program appears in both. They exist so that anyone who wants a program-disjoint split has one that is not leaky — not because they are enough to train on.

Twelve programs are not a training set. Fine-tuning on 30 or 60 records produces a model that has memorised twelve programs, and its score tells you nothing about traces. A version that could honestly be trained on needs roughly an order of magnitude more programs — about 120 to 150, still balanced across the six languages and the five question kinds, each written so the answer is not visible in the source, each key hand-written and machine-checked against a real run. That is around 600 to 750 hand-written keys. The machine part of that is cheap; the authoring is not, and generating the programs from a template or from a model would quietly change what the dataset measures, because then the questions become answerable by whatever pattern the generator used.

Scoring rules (fixed before any model was run)

evaluate.py in this repository implements them. In short:

1. The model is told to answer with one line, ОТВЕТ: <value>, and is allowed to answer ОТВЕТ: не знаю ("I don't know").
2. The last line containing ОТВЕТ: is taken; everything after the colon.
3. It is normalised: lowercased, quotes and a trailing period removed, spaces collapsed.
4. Correct if it equals an accepted answer; or the accepted answer is a number and that number is the only number in the text; or the accepted answer is "да"/"нет" and the text starts with it.
5. Abstained if it says it does not know.
6. Everything else is a confidently wrong answer — including a missing ОТВЕТ: line. This is deliberately strict, and it is strict against the trace setting exactly as much as against the control.

Grading is blind: the function that compares an answer to the key receives only the accepted answers and the answer text. It cannot see which setting the answer came from; records are shuffled before grading and the setting label is re-attached only for counting.

Spread is reported as a 95% interval from resampling whole programs with replacement, 10 000 rounds — the five questions about one program are not independent, so resampling single answers would understate the spread. A difference counts as real only if that interval excludes zero.

Usage:

python evaluate.py data/test.jsonl answers.jsonl

answers.jsonl is one object per line:

{"id": "orders-1", "setting": "with_trace", "repeat": 1, "output": "ОТВЕТ: 3"}

Reference numbers

Measured 30 August 2026 on one RTX 6000 Ada under ollama. Four sizes of one family, one generation, one quantization (Q4_K_M) — only the size varies, so a difference between rows is a difference in size and not in training recipe. Prompts are taken from data/test.jsonl verbatim. Temperature 0.8; seed = repeat number, identical in both settings; context 16384; at most 300 tokens of answer; 5 repeats. 600 answers per model, 2400 in all. The raw answers are in results/, so every number here can be recomputed with evaluate.py.

model	correct, no trace	correct, with trace	gain	95% interval of the gain	spread across repeats
qwen2.5:3b-instruct	31.3 %	53.3 %	+22.0 pt	+14.3 … +30.3	6.8 and 8.9 pt
qwen2.5:7b-instruct	50.0 %	63.7 %	+13.7 pt	+5.7 … +22.3	4.7 and 3.0 pt
qwen2.5:14b-instruct	61.7 %	83.7 %	+22.0 pt	+11.7 … +32.7	2.4 and 2.2 pt
qwen2.5:32b-instruct	67.7 %	94.0 %	+26.3 pt	+16.0 … +37.7	1.5 and 0.9 pt

Confidently wrong answers — the ones that matter, because they are claims about a path the program never took:

model	wrong, no trace	wrong, with trace	difference	95% interval
qwen2.5:3b-instruct	39.3 %	42.7 %	+3.3 pt	−8.0 … +16.0
qwen2.5:7b-instruct	48.3 %	36.3 %	−12.0 pt	−20.0 … −4.7
qwen2.5:14b-instruct	38.3 %	16.3 %	−22.0 pt	−32.7 … −11.7
qwen2.5:32b-instruct	32.3 %	6.0 %	−26.3 pt	−37.7 … −16.0

Does the gain grow with model size? On this ladder it holds. Every one of the four intervals excludes zero, so the gain is real at every size. But the intervals overlap heavily, and a paired resampling of the difference between the gains gives +4.3 pt for 32b over 3b, interval −5.7 … +14.7 — that covers zero. The ladder does not establish a trend either way. What it does rule out, for these four models, is the interesting negative case: the gain does not disappear at the top. The largest model still answers only 67.7 % correctly without the trace, so at this scale the trace is not something reasoning replaces.

Two honest caveats. The 7b row is the odd one out — its gain is the smallest of the four, and it is the only model that makes no use of the trace on call_count. And 32 billion parameters at 4-bit is not a frontier model; this dataset says nothing about what a much larger or a reasoning-trained model would do.

The gain is narrow, and it sits in one place. Split by what the question asks:

model	value questions (call count, return, argument)	"was the function called at all"
qwen2.5:3b-instruct	25.0 → 48.8 %	61.8 → 78.2 %
qwen2.5:7b-instruct	38.3 → 54.6 %	100 → 100 %
qwen2.5:14b-instruct	52.1 → 79.6 %	100 → 100 %
qwen2.5:32b-instruct	59.6 → 92.5 %	100 → 100 %

From 7b upwards, whether a function ran at all is already answered from the source, and the trace adds exactly nothing there. Everything the trace buys is on questions about values.

By language, the gain is also uneven: Go is the language where models do best without the trace and gain least from it (98 → 100 % at 32b), while Python and Elixir gain most. Fifty answers per language per setting is an indication, not a conclusion.

Cost of the trace, measured on this run: the traces are 3.7× the size of the sources; the median prompt goes from 1623 to 5919 characters; answer latency is unchanged within noise (for example 8.64 s versus 8.69 s at 32b).

Reproducing

python run_models.py data/test.jsonl answers-14b.jsonl qwen2.5:14b-instruct
python evaluate.py   data/test.jsonl answers-14b.jsonl
python summary.py    data/test.jsonl "3b=answers-3b.jsonl" "32b=answers-32b.jsonl"

run_models.py sends each prompt to a model through the command in OUROBOROS_MODEL_CMD and is included in the source project; evaluate.py and summary.py are in this repository.

Origin

The traces come from ouroboros, a call-tracing tool: each program is wrapped by ouroboros wrap-file, run once, and the trace is the file it leaves behind. The wrapped and the unwrapped run must print exactly the same thing, and the build fails if they do not.

The experiment this dataset was extracted from lives in that repository under scripts/measure/trace-help/; the dataset builder under scripts/dataset/.

License: BSD 2-Clause, same as the source project.

---

По-русски, коротко

Двенадцать программ на шести языках, каждая запущена один раз. К каждой пять вопросов о том, что случилось на этом самом запуске: сколько раз вызвана функция, что вернул такой-то вызов, с чем позвали, вызывалась ли вообще, кто бросил исключение. Шестьдесят записей, у каждой два письма — без трассы и с трассой; всё остальное в них совпадает знак в знак.

Правильные ответы записаны руками при сочинении программ и сверены с настоящим прогоном: сборщик достаёт ту же величину из трассы и отказывается собирать набор, если они разошлись. Все шестьдесят сошлись.

Часть test — это и есть набор, все 60 записей. train и validation — те же 60, разрезанные по программам пополам, чтобы у желающего был неутекающий разрез. Двенадцати программ для обучения мало: дообучение на них даст модель, заучившую двенадцать программ. Чтобы на наборе можно было честно учить, программ надо на порядок больше — около 120–150, и это примерно 600–750 ключей, каждый написанный руками и сверенный с прогоном.

Что вышло на четырёх размерах qwen2.5-instruct: прибавка от трассы есть у всех четырёх (3b +22,0; 7b +13,7; 14b +22,0; 32b +26,3 пункта), и ни один 95-процентный промежуток не накрывает ноль. Растёт ли прибавка с размером — сказать нельзя: разница прибавок между 32b и 3b равна +4,3 пункта с промежутком −5,7 … +14,7, ноль внутри. Зато видно, чего не случилось: у самой большой из проверенных моделей прибавка не пропала, и без трассы она отвечает верно лишь в 67,7 % случаев. Польза узкая: на вопросе «вызывалась ли функция вообще» начиная с 7b трасса не даёт ничего, вся прибавка сидит на вопросах о значениях.