MarshootLab/beam-verified-reasoning-traces

Beam Verified Reasoning Traces

by Marshoot Lab

7,632 reasoning traces from Reflection's Beam-1.0-501B-A23B on 3,595 procedurally generated problems across 13 task families and 7 difficulty levels. Every answer key is computed by code and re-derived by a second, independent solver, so every trace carries a trustworthy correct/incorrect label.

The dataset is packaged four ways, so you can use it for supervised fine-tuning, preference training, reinforcement learning with verifiable rewards, or simply as a fine-grained evaluation of Beam. The generators, the independent verifier and the audit scripts are included in code/, so every number on this page can be reproduced.

Quickstart

from datasets import load_dataset

repo = "MarshootLab/beam-verified-reasoning-traces"
full  = load_dataset(repo, "full_traces")       # every Beam attempt, right or wrong
sft   = load_dataset(repo, "sft_verified")      # one verified trace per problem
pairs = load_dataset(repo, "preference_pairs")  # filter by pair_type
rl    = load_dataset(repo, "rlvr_prompts")      # prompt + verified answer

hard = rl["train"].filter(lambda x: x["beam_pass_rate"] < 1.0)  # problems Beam sometimes failed

Ready for TRL out of the box

from trl import SFTTrainer, SFTConfig, DPOTrainer, DPOConfig

# SFT on verified reasoning (assistant turn = <think>reasoning</think> + final answer)
sft_ds = sft["train"].map(lambda x: {"messages": x["messages_with_reasoning"]},
                          remove_columns=sft["train"].column_names)
SFTTrainer(model="your-model", train_dataset=sft_ds, args=SFTConfig(output_dir="sft"))

# DPO on correct-vs-incorrect pairs: `prompt`, `chosen`, `rejected` columns are already in TRL's standard format
dpo_ds = pairs["train"].filter(lambda x: x["pair_type"] == "correctness")
DPOTrainer(model="your-model", train_dataset=dpo_ds, args=DPOConfig(output_dir="dpo"))

Use messages instead of messages_with_reasoning if you only want the short final answers (median 25 characters) without the reasoning.

Why this dataset

• Labels you can trust. Answers are not judged by another LLM. Each problem is generated together with its exact answer, and a separate solver that only reads the prompt text (and uses a different algorithm) must agree. Result: 0 disagreements on 3,595 problems.
• Real failures, not just successes. Beam is right 96.5% of the time overall, but the remaining errors are concentrated and reproducible: combinatorics, date arithmetic and multi-step string transformations at low reasoning effort. These are exactly the examples useful for preference and RL training.
• Controlled variation. Each problem has a family, difficulty level, prompt style and (for some) distractor sentences, and the same core problem is sometimes asked in 4 styles or at 5 reasoning efforts. This lets you measure what actually changes model behaviour.
• Leak-free split. Train/test are split by core problem (style variants and near-duplicates stay together), so no test problem has a paraphrase in train.

At a glance

Model	Beam-1.0-501B-A23B as served by Ollama Cloud's OpenAI-compatible API under the tag beam (serving precision not published by the provider; see Limitations)
Sampling	temperature 0.7, top_p 0.99 (the settings in Beam's model card), max_tokens 16,000 (32,768 for the v4 rescue subset)
Traces	7,632 (6,859 train / 773 test)
Unique problems	3,595 (3,237 train / 358 test)
Task families	13
Difficulty levels	1-5 for all families, 6-7 for the 7 families whose generators scale further
Reasoning efforts	low, high (main grid, hard tier v2); low, medium, high, xhigh, max (Pareto subset); high, max (rescue subset)
Prompt styles	concise, standard, case_study, trap_distractor
Answer keys independently re-verified	3,595 / 3,595 (0 mismatches)
Beam accuracy (all traces)	96.5% (lower than v3's 96.9% because v4 deliberately adds harder problems)
Language	English only

v4 additions (October 2026)

v4 adds 322 new Beam traces, all generated through Ollama Cloud (tag beam) with the same sampling settings, and every new answer key re-derived by the independent solver (0 mismatches).

Hard tier v2 (subset = hard_tier_v2): 135 new problems at difficulty 5-7 in the three families where Beam still fails (combinatorics_count, date_arithmetic, string_pipeline, 45 each), each solved at low and high effort.

Family	Low effort	High effort
combinatorics_count	68.9% (n=45)	86.7% (n=45)
date_arithmetic	84.4% (n=45)	100.0% (n=45)
string_pipeline	68.9% (n=45)	97.8% (n=45)
All	74.1% (median 631 tokens)	94.8% (median 1,544 tokens, 6 truncated at 16k)

These are the main source of the new correct-vs-incorrect preference pairs.

Rescue subset (subset = rescue_32k): problems that had no correct trace in v3 were re-asked at high and max effort with max_tokens = 32,768. Of the 28 problems reached so far, 26 now have a correct trace (high 25/27, max 24/25 correct). This subset is partial: the remaining 25 problems produce answers close to the 32k-token limit and repeatedly exceeded our client timeout, so they were not completed for this release. They stay in rlvr_prompts with their v3 pass rate.

Results

All intervals are Wilson 95% confidence intervals. Numbers in this section come from the v3 traces in full_traces (both splits); v4 results are reported separately above.

By reasoning effort (main grid, 2,600 traces per effort, identical problems):

Effort	Accuracy (95% CI)	Median completion tokens	Median latency
low	95.2% (94.3-95.9)	433	1.8 s
high	99.0% (98.6-99.4)	811	3.0 s

High effort removes about 80% of low-effort errors for roughly 1.9x the tokens.

Pareto subset (the same 130 problems, 10 per family, each solved at all 5 efforts):

Effort	Accuracy (95% CI)	Median completion tokens	Mean completion tokens	Median latency	Truncated
low	95.4% (90.3-97.9)	430	534	2.0 s	0
medium	97.7% (93.4-99.2)	695	835	2.8 s	0
high	99.2% (95.8-99.9)	738	1,004	2.7 s	1
xhigh	97.7% (93.4-99.2)	660	923	2.6 s	1
max	97.7% (93.4-99.2)	608	936	2.5 s	1

Two observations, both stated with caution. First, xhigh and max did not spend more tokens than high on these problems; their medians were lower. On short, well-defined tasks the higher settings do not appear to translate into longer reasoning. Second, with 130 problems per effort the accuracy differences among medium, high, xhigh and max are not statistically significant: high made 1 error, xhigh and max made 3 each. One error at each of these three levels was the same kind: a combinatorics answer cut off at the 16,000-token limit (19 of the 20 truncations in the whole dataset are combinatorics). We do not claim xhigh or max are worse than high; on these tasks, going beyond high brought no measurable gain in accuracy or token use. Latency depends on the serving endpoint and load and should be read as indicative only.

By prompt style: concise 96.9%, standard 97.0%, case_study 97.0%, trap_distractor 96.8%. Beam is robust to rewording and to irrelevant distractor sentences on these tasks; no style effect is detectable.

Hardest cells (low + high pooled): combinatorics level 7 (73%, n=30), combinatorics level 5 (75%, n=106), combinatorics level 4 (81%, n=106), date arithmetic level 7 (83%, n=30), string pipelines level 7 (83%, n=30), string pipelines level 6 (87%, n=30).

Failure case studies

Two real examples from the data, where Beam failed at low effort and succeeded at high effort on the identical prompt. Excerpts are verbatim apart from trimming.

1. Combinatorics, level 3: correct method, wrong subtraction (instance_id 544e5cddf2a4eded45fb)

How many ordered sequences of 4 integers, each between 2 and 6 inclusive, have a sum of exactly 21?

Verified answer: 20.

Low effort (398 tokens), answered 60:

Total without upper bound: C(16,3)=560. [...] subtract 4*165=660. But 560-660 negative; need higher intersections. Two variables >=5: [...] add 6*20=120. [...] Total = 560 - 660 + 120 = 60. Check. Answer 60.

High effort (667 tokens), answered 20:

[...] So total 560 -660 +120 =20. Need check. Alternatively enumerate. Answer 20.

Both runs set up the same inclusion-exclusion with identical terms. The low-effort run even noticed the intermediate value was negative, then made a plain arithmetic slip in the final line and said "Check" without re-checking. The error is in execution, not in understanding.

2. Date arithmetic, level 7: right date, weekday shifted the wrong way (instance_id 2c26d2bf51a5f4253497)

Start from Thursday, August 14, 2003. Subtract 162 days, then add 89 days, then subtract 139 days, then add 294 days, then subtract 24 days, then add 40 days, then add 8 days, then subtract 154 days. What is the resulting date and weekday?

Verified answer: 2003-06-27 Friday.

Low effort (356 tokens), answered 2003-06-27 Wednesday:

Weekday: start Thursday. -48 days mod 7 = -48+49=1, so one day before Thursday = Wednesday. [...] I think yes.

High effort (898 tokens), answered 2003-06-27 Friday:

-48 days ≡ +1 day modulo 7. Thursday +1 = Friday? Need check. [...] subtract 6 more days [...] Thu -1 Wed, -2 Tue, -3 Mon, -4 Sun, -5 Sat, -6 Fri. Yes Friday.

The low-effort run computed the residue correctly (+1) and then applied it in the wrong direction. The high-effort run hit the same doubt, verified with a second method (counting back day by day) and caught it. This pattern, a correct intermediate value followed by a sign or direction slip that only an explicit second check catches, is typical of the low-effort failures in dates and combinatorics.

Where it tops out: shortest path, Venn counting and work rates were solved 100% at both efforts, and inventory and modular arithmetic were above 99.5%. These families are saturated for Beam at the difficulties our generators can produce; they remain useful as clean SFT data and as regression checks, but they do not separate strong models.

The four configurations

Config	Rows (train / test)	One row is	Use it for
full_traces	6,859 / 773	one Beam attempt, correct or not, with all metadata	evaluation, analysis, filtering your own subsets
sft_verified	3,200 / 357	the shortest correct, complete, strictly formatted trace per problem, as messages (answer only) and messages_with_reasoning (reasoning in <think> tags + answer)	supervised fine-tuning on verified reasoning
preference_pairs	1,380 / 155	two Beam answers to the same prompt, labelled by pair_type, with TRL-ready prompt / chosen / rejected columns (reasoning in <think> tags)	DPO / reward modelling
rlvr_prompts	3,237 / 358	a problem with its verified answer and Beam's empirical pass rate, no model output	RL with verifiable rewards, curriculum by difficulty

Because sft_verified keeps the shortest correct trace, it is mostly low-effort reasoning (2,593 of 3,064 train rows are low, 448 high, 23 medium/xhigh/max). Filter on reasoning_effort if you want longer, more self-checking traces. sft_verified covers 3,557 of the 3,595 problems; the other 38 never received a correct, complete, strictly formatted answer from Beam. beam_pass_rate in rlvr_prompts is the fraction of Beam attempts on that problem that were correct (2 to 5 attempts, see beam_attempts), a ready-made difficulty signal.

Preference pair types

pair_type	Train / test	Chosen	Rejected	Notes
correctness	206 / 17	correct, cleanly finished	incorrect (wrong, empty or truncated)	the hard signal; mostly date arithmetic, combinatorics and strings
concise_reasoning	1,174 / 138	correct, strict format, at most half the tokens	correct, strict format, longer	for training shorter reasoning; in 1,198 of 1,246 pairs chosen is low effort and rejected is high effort

Both answers in a concise_reasoning pair are correct, so these pairs teach brevity, not accuracy; use them only if that is what you want. We also considered format-compliance pairs but did not include them: 209 of the 212 correct answers without a strict ANSWER: line were work-rate answers written as ANSWER: 120 minutes instead of ANSWER: 120, and since the prompts never forbid a unit, preferring one over the other would not be justified.

Key fields (full_traces)

Field	Meaning
instance_id	unique id of the exact prompt
core_problem_id	id of the underlying problem; style variants share it
split_group_id	grouping used for the train/test split (merges near-duplicates)
subset	main_grid, pareto_5efforts, robustness_4styles or hard_tier
family, difficulty, style, has_distractors	how the problem was generated
prompt	exact text sent to Beam (includes the answer-format instruction)
core_prompt	the problem without styling or format instruction
answer, answer_format	verified answer and its format (integer, fraction, date, string, list...)
solver_type, key_verified_independently	how the key was computed; always true here
reasoning	the reasoning text returned by the API's reasoning field
response	Beam's visible answer
extracted_answer	answer parsed from the final ANSWER: line (or a lenient fallback)
is_correct	extracted answer equals the key after canonical normalisation
is_correct_strict_format	correct and given on a proper ANSWER: line
finish_reason, prompt_tokens, completion_tokens, latency_s	generation metadata (completion_tokens includes reasoning; the endpoint did not report a separate reasoning-token count)
beam_pass_rate, beam_attempts	fraction of Beam attempts on this exact prompt that were correct, and how many attempts there were

Task families

Each answer key is computed twice by two separate code paths: once by the generator, which knows the problem's internal structure, and once by the verifier, which only sees the prompt text, parses it back into a problem, and solves it with a different method.

Family	What the model must do	Levels	Generator solver	Independent verifier (prompt text only)
Inventory word problems	track a quantity through a sequence of operations	1-7	state simulation on the internal operation list	re-parses each sentence and simulates
Date arithmetic	add or subtract days across month and year boundaries	1-7	Python datetime	ordinal-day arithmetic, plus a check of the stated start weekday
Ordering logic	find the unique order satisfying clues	1-5	brute force over permutations (internal constraints)	re-parses clues and searches permutations
Code tracing	predict the output of a short Python program	1-7	execution of the generated program	executes the code as printed in the prompt
Combinatorics	count sequences with constraints	1-7	forward dynamic programming	brute-force enumeration, or memoised recursion when enumeration is too large
String pipelines	apply a chain of string transformations	1-7	built-in transformation functions	separately written interpreter of the English instructions
Work rates	combined-work timing	1-5	exact fractions	LCM of the individual times
Modular arithmetic	large powers and residues	1-5	Python pow(a, b, m)	hand-written square-and-multiply
Shortest path	weighted shortest route in a graph	1-7	Dijkstra	Floyd-Warshall
Probability	exact probability as a fraction	1-7	closed-form hypergeometric with exact fractions	brute-force enumeration of all draws
Knights & knaves	identify truth-tellers and liars	1-5	truth-table enumeration on internal statements	re-parses the statements and enumerates
Meeting scheduling	earliest common free slot	1-5	interval scan	minute-by-minute bitmap
Venn counting	inclusion-exclusion counting	1-5	explicit set enumeration	region decomposition from the stated counts

For a few families (inventory, ordering, knights & knaves) both sides use a similar algorithm; their independence comes from the verifier re-reading the English text rather than trusting the generator's internal data, which catches wording errors such as an ambiguous or misleading sentence.

Ordering logic, work rates, modular arithmetic, knights & knaves, meeting scheduling and Venn counting are capped at level 5: beyond that our generators either stop producing meaningfully harder instances or produce prompts too long to be natural.

How it was built

Code for every step is in code/: tasks.py and tasks_v2.py (generators and canonical grading), verify.py (independent verifier), run.py (resumable generation), audit.py (quality audit), package.py (splits and configurations), charts.py (figures), check_release.py (one-command re-check of the published files) and reward_fn.py (verifiable reward for GRPO/RLVR).

1. Generate. Deterministic, seeded generators produce each problem and its exact answer. Names (80), items (40) and words (40) are varied, with 8-10 narrative contexts per family and 15 distractor sentence types.
2. Verify the key. A second solver parses only the prompt text and solves it with a different algorithm. Any disagreement blocks release; the final run had none.
3. Ask Beam. Each prompt asks for a final line ANSWER: <answer>. Calls used the official reasoning-effort levels, temperature 0.7, top_p 0.99 and max_tokens 16,000, one request at a time.
4. Grade. Answers are normalised by format (integers, fractions, dates, lists, strings) and compared to the key. Grading was re-run from scratch during the audit with 0 changes.
5. Audit. Schema checks, exact and MinHash near-duplicate detection, manual review of failures, and a check that no core problem appears in two subsets.
6. Split. About 10% of split groups go to test, by hash of split_group_id.

Reproduce the audit

Everything needed is in this repo. From a clone (or with nothing but the scripts, which then fetch the data from the Hub):

pip install -r requirements.txt
python code/check_release.py

It re-derives all 3,595 answer keys with the independent prompt-only verifier, re-grades all 7,632 Beam responses, and checks train/test leakage. Expected output (about a minute on a laptop CPU):

traces            7,632 (6,859 train / 773 test)
unique problems   3,595
key mismatches    0 / 3,595
regrade changes   0 / 7,632
train/test leaks  cores 0, split groups 0
Beam accuracy     96.46%

Reward function for GRPO / RLVR

code/reward_fn.py wraps the same canonical grader as TRL-style reward functions (correctness_reward, 1.0 or 0.0, and an optional format_reward bonus of 0.2), reading the answer, answer_format and family columns of rlvr_prompts:

import sys; sys.path.append("code")
from datasets import load_dataset
from trl import GRPOTrainer, GRPOConfig
from reward_fn import correctness_reward, format_reward

ds = load_dataset("MarshootLab/beam-verified-reasoning-traces", "rlvr_prompts", split="train")
trainer = GRPOTrainer(model="your-model", reward_funcs=[correctness_reward, format_reward],
                      args=GRPOConfig(output_dir="out"), train_dataset=ds)

The reward functions are tested on example completions; we have not run a training job with them.

Quality audit (final)

Check	Result
Answer keys disagreeing with the independent solver	0 / 3,595
Missing fields	0
Exact duplicate prompts across different problems	0
Core problems shared across subsets	0
Train/test leakage (core problems or split groups)	0
Near-duplicate problem pairs (MinHash)	13, all same-template problems with different numbers; kept and grouped into the same split
Empty responses / no ANSWER: line	19 / 19 (kept in full_traces, labelled incorrect; excluded from sft_verified)
Truncated at the 16,000-token limit (finish_reason = length)	20 (same treatment); 19 of them are the 19 empty responses. 18 were at high effort or above, 1 at low. 19 of the 20 are combinatorics problems
Raw records outside the final generation plan (superseded runs)	460, dropped before packaging
Distractor sentences that happen to contain the answer number	14 of 444 distractor problems with an integer answer; kept, flagged here so you can filter them
Strict-format compliance	94.0%; of the correct answers not counted as strict, 209 of 212 are work-rate answers with a unit added (120 minutes)

Ambiguity found and fixed. During failure review we found that "remove all vowels (a, e, i, o, u)" was ambiguous for uppercase letters, and several "errors" were Beam using the other reasonable reading. The wording was changed to "in either upper or lower case" and every affected trace was regenerated. Old traces were discarded, not relabelled. In meeting scheduling, one failure matched an alternative reading of a slot boundary; the other failures are genuine model errors.

Limitations

• Synthetic and templated. Problems come from templates. They test precise multi-step reasoning, not world knowledge, open-ended writing or long-context skills. A model trained only on this data may learn the templates.
• One model, one sampling setting, one provider. All traces are Beam at temperature 0.7 via Ollama Cloud (tag beam). The provider does not publish the precision it serves Beam at, so if it uses a quantised build, accuracy through Reflection's own API or Hugging Face Inference Providers may differ.
• Reasoning text. reasoning is what the API returned in its reasoning field. We make no claim that it is the model's complete internal computation, and a correct final answer does not guarantee every reasoning step is correct.
• Small subsets have wide intervals. The Pareto (130 problems per effort) and hard-tier (105 traces per level per effort) results should be read with their confidence intervals.
• Saturated families. Several families are near 100% for Beam and add little evaluation signal.
• Few correctness pairs. Because Beam is accurate, only 223 correct-vs-incorrect pairs exist (182 before v4), concentrated in the hardest families. The larger concise_reasoning set teaches brevity, not accuracy.
• Pass rates are coarse. beam_pass_rate comes from 2 to 5 attempts, usually at different reasoning efforts, so treat it as a difficulty hint rather than a precise probability.
• No training experiments. We did not fine-tune any model on this data, so we make no claims about downstream gains.

Licence and credit

Released under Apache-2.0, matching Beam's licence. Model outputs are from Reflection's Beam; problems, answer keys, verification and packaging are by Marshoot Lab.

@misc{marshootlab2026beamtraces,
  title  = {Beam Verified Reasoning Traces},
  author = {Marshoot Lab},
  year   = {2026},
  url    = {https://huggingface.co/datasets/MarshootLab/beam-verified-reasoning-traces}
}