AndreiGheorghiu/rulebookbench-beam

RulebookBench: Can an AI follow a rulebook it has never seen, and prove every step?

RulebookBench tests whether Beam-1.0 can apply company rules it has never seen. An exact program checks every step of its answer. The project also tests ways to use Beam so that each decision can be checked.

Built for Reflection's Beam Build Challenge · Demo · Code (checker, scorer and puzzle generator, in the demo's files) · Full results

The problem

Companies are starting to let AI answer questions about their own rules. Does this employee qualify for paid leave? Can this IT change go ahead during the holiday freeze? Each answer depends on several rules applied one after another, and a wrong answer looks just like a right one. So a person re-reads the policy to check every answer, and becomes the slowest part of the process.

An example. Take an IT change policy with 9 facts about changes and 8 if-then rules. Its terms are invented, so Beam cannot answer from memory. The question: does change CHG-29475 have a "Drimrand" risk rating? (In a real policy this might read "is it high-risk?") The right answer is yes, by applying five rules in a row. Given the short policy, Beam said yes and wrote out the five steps. Our checking program accepted them.

Then we hid the same puzzle in a generated policy of well over a thousand pages, among tens of thousands of look-alike facts and rules. This time Beam answered "cannot be established", which is wrong. It found the last rule it needed, then said no other rule could meet that rule's condition. One did, three lines further down. In a workflow that treats "cannot be established" as permission to go ahead, a high-risk change would have gone through unflagged. The checking program caught the mistake at once, because it can work out the answer from the rules itself. That is the idea of this project: you do not have to trust Beam's answer, because a program checks it against the rules.

What we built, and why

• Rulebooks Beam has never seen: short, newly generated policies (HR leave, insurance claims, access rights, IT changes) with invented names.
• Show your working: each puzzle asks whether a statement follows from the policy. Beam must answer "yes" and show its working, one rule per line, as in a maths exam, or say that the policy does not establish it.
• A program marks it, not an AI: it checks every line in turn and names the first one that is wrong. A "no" counts only if the program, working from the rules itself, agrees.
• Guessing does not pay: half the puzzles have the answer "yes", so always saying "no" scores only 50%. Some puzzles change one rule so that the answer must flip.

Why a program checks the working. A right answer can be right by luck. In an early trial on tax law, Beam wrote small programs to work out each answer. 2 of its 20 programs gave the right answer by accident; changing the facts and running them again exposed both. Checking every step catches this kind of luck, and it also catches subtly wrong answers that an AI judge can let through (step 4).

What the main test does and does not show. These generated policies follow fixed sentence patterns. A simple program with no AI could turn them back into rules and answer every question. So the main test shows whether Beam reasons correctly from the rules, not whether an AI is needed. Two smaller tests take a first step toward what a real company needs: turning ordinary wording into something a program can check. One rewords the same puzzles; the other uses 30 cases from SARA, a benchmark based on simplified US tax law.

What we found

The results suggest a recipe for using Beam on a company's rules. Steps 1 to 5 each rest on one finding; step 6 tries the recipe on a benchmark based on simplified US tax law (SARA). "Effort" is how long Beam thinks before answering; we tested three of its five levels: low, medium and high.

1. Beam can apply rules it has never seen. On short policies, at high effort, it got 406 of 410 new puzzles right (99%), with working up to 30 steps long that the program checked line by line. When we changed one rule so the answer should flip, Beam followed the change every time (45 of 45): it reads the rules rather than guessing.
2. Let it think. On 90 of those puzzles, asked at each level, Beam was right 69% of the time at low effort, 87% at medium and 99% at high. High effort writes about five times as much, so answers take longer, in exchange for 30 more right answers in every 100.
3. Give it the section that applies, not the whole manual. Five test puzzles asked on their own were solved 14 times out of 15. Hidden among look-alike facts and rules in a document of a few hundred pages, they were solved 7 times out of 15, and in one of well over a thousand pages, 0 times out of 10. In most of the misses we reviewed, Beam stopped writing out the lines it needed, relied on its impression of the document, like skimming a manual, and missed one. So give Beam only the section that applies, then let it reason.
4. Let a program have the last word. Even set up this way, a few answers will be wrong, and a wrong answer looks just like a right one. Because Beam writes out its working, a program can check every step against the rules and catch them. Checking is where the two complement each other: given 322 answers to check, half right and half subtly wrong, Beam at high effort turned down 157 of the 161 wrong ones (155 rejected in the required format; 2 replies left the verdict out), and the program caught every one of them, including the 4 Beam accepted.
5. Let Beam translate and the program decide. A program can only decide from rules it can read, and real policies are written in ordinary words. So we reworded 90 puzzles so that a simple program could no longer read them, and gave Beam a list of the kinds of fact each policy uses, like the field list of a database. When Beam turned each policy into rules and the program worked out the answer, it was right 100% of the time at high effort and 88% at low; answering directly, 93% and 63%. No person reviewed Beam's rules before the program used them (we compared them with the originals only afterwards), and the rewordings came from a fixed set (see Limits).
6. On a simplified US tax-law benchmark (SARA), the recipe holds when experts write the rules. We used 30 simplified US tax cases from SARA, a public research dataset whose authors also wrote reference rules a computer can run. Beam wrote down each case's facts, and the reference rules worked out the tax: right on all 30 (28 under the strictest scoring). Answering directly, Beam was right on 29, so here the rules added checking rather than accuracy. Writing the tax law itself as a program, in one go and with no chance to run or fix its code, Beam got 25, and nearly all of its programs that passed covered only their own case, for example with that year's figures typed in. So for law like this, and in this one-shot setup, step 5 changes: experts should write the rules once, and Beam's job is to turn each case into facts.

Why Beam, and what this shows about it

• It can take in a whole manual at once (up to 1 million tokens). Applying rules spread through one is not yet reliable, so for now a focused section works far better (step 3); our puzzles can measure progress on it.
• Five thinking levels: we could measure what extra thinking buys. On our rule puzzles, it buys a lot.
• Built for coding: turning policy sentences into rules is a job much like coding. At high effort Beam did it exactly for all 90 reworded puzzles; a simple program that knew only the standard wording got none exactly right. Writing simplified tax law as its own program, case by case and with no chance to test its code, was its weakest route on tax (25 of 30); there, rules written once by experts worked better (step 6).
• Free to download and run (Apache 2.0): a company with a large enough server could run Beam in-house for confidential policies, and train it on these puzzles. We used Reflection's online service and did not train it.

Who benefits

• Companies with rulebooks (HR, insurance, IT, compliance) get practical advice. Use high effort, and give Beam only the section of the policy that applies. Let an exact program make the decision, from rules that experts wrote or a person checked. Then each decision traces back to the rules and facts it used.
• Reflection gets a clear, measurable target for the next version (applying rules spread through long documents, from a few hundred pages up), the pattern behind the misses and fresh puzzles to track progress. It also gets an automatic scorer that could be used to train Beam on it (we did not try).
• People who train or test AI models get an unlimited supply of puzzles marked automatically, and a ready training set. They also get a scorer that rewards checkable working, ready for Hugging Face's training library, and Beam's replies from the puzzle tests with the checker's verdict.

Limits

• Generated, simplified policies: no numbers, dates or exceptions. 99% here is not 99% on a real HR policy.
• Fixed rewordings: only two new wordings for each kind of sentence, and Beam was given the list of fact types. The 90 reworded puzzles come from 35 base policies. So this shows Beam matching new wording to a known list, not reading a freely written policy.
• Little tax law: 30 cases from SARA, a benchmark of constructed cases on simplified US tax law, public since 2020. Beam may have seen it in training, though no reply showed signs of that. We adjusted our instructions to Beam once before the 20 test cases. The changes came from a 10-case trial and a read-through of the test cases: for example, how SARA rounds and how its rules expect the facts. None of the changes gives an answer.
• Few long documents: five puzzles, each asked several times, all at high effort, in generated documents padded with look-alike facts and rules. A clear signal, not a precise rate. Every other puzzle and tax case was asked once at each effort level tested.
• What the checker does not check: it checks the reasoning against the rules and facts it is given. Whether Beam's facts or rules match the original policy and case is a separate question: in the tax test a few fact sets left out stated facts that happened not to change the answer.
• Not tested: a separate search program that finds the section that applies (step 3), a person checking Beam's rules (we recommend it), or training a model with our scorer.

Technical data

Model reflection/Beam-1.0-501B-A23B on Reflection's API, 18–22 October 2026 (puzzles 18–20, tax cases 20–21; the high-effort checking run and the two-step long-document check on 22). One run per item unless stated. Sampling at the server defaults (temperature 0.7, top_p 0.99). Output limit 16,384 / 24,576 / 32,768 tokens at low / medium / high effort; the xhigh and max levels were not tried. Token counts are Reflection's (a token is a word or part of a word). "100k" and "800k" are measured prompt sizes (about 102k–107k and 799k–830k tokens); the example's long document is 820,140 tokens. Ranges such as 98–100% are 95% confidence intervals. They treat each puzzle as independent; twin puzzles and rule edits are related, so the real uncertainty is somewhat larger.

What was measured	Result	For comparison
Short policies, high effort: 410 new puzzles, working of 1–30 steps	406/410 right (99.0%; 98–100%)	always "no": 50%
True statements proved with working that checks	202/205 (98.5%): all up to 16 steps, 20/23 at 17–30	–
False statements claimed as proven	1/205 (rejected by the checker)	–
One rule edited so the answer flips: both versions right	45/45 pairs	–
Effort, same 90 puzzles: right	low 68.9% · medium 86.7% · high 98.9%	–
True puzzles of 6+ steps proved, same 90	low 0/21 · medium 11/21 · high 21/21	–
Median reply length, thinking included, same 90	low 968 · medium 2,580 · high 5,006 tokens	–
Long documents, high effort: 5 true puzzles proved	alone 14/15 runs · ~100k tokens 7/15 · ~800k tokens 0/10	–
Beam checking 322 given answers (written by the test, shown as another AI's; medium effort): fully right, decision and reason	298/322 (92.5%)	always accept: 50%
Wrong answers accepted	19/161 (11.8%), including 14 of the 46 that wrongly said "cannot be established"	always accept: 161/161
The same 322 answers checked again at high effort: fully right, decision and reason	307/322 (95.3%)	always accept: 50%
Wrong answers accepted, high effort	4/161 (2.5%); it also rejected 1 of the 161 right answers	always accept: 161/161
Correct answers rejected	medium 0/161 · high 1/161	–
Reworded puzzles (90, list of fact types given): Beam answers directly	low 63.3% · medium 70.0% · high 93.3%	always "no": 50%
Reworded: Beam translates (rewrites the policy as rules), the checker decides	low 87.8% · medium 97.8% · high 100%	program without AI: 35.6%
Reworded: Beam's translations exactly right	low 66/90 · medium 88/90 · high 90/90	program without AI: 0/90
Tax law (SARA, a benchmark on simplified US tax law, 30 cases: 10 trial, 20 test; high effort): right (strict)	Beam writes the facts, SARA's reference rules compute 30 (28) · Beam answers directly 29 (27) · Beam writes its own program 25 (23)	–
Beam's own tax programs after an AI reviewer changed a date, the year or a family detail (test set)	at least 8 of the 17 that had passed went wrong, 7 of them giving a wrong number with no error	–
Earlier true/false trial on SARA (10 cases): programs right by luck	2 of 20, exposed by running them on changed facts	–

Notes:

• Reviews. Two independent AI reviewers checked each of the first run's 12 wrong answers (8 long-document, 4 short) against the rebuilt prompt. All 12 are Beam's own errors, not faults in the test. Failures in the later repeat and placement runs were scored by the checker but not reviewed one by one.
• Long documents. As a check, the five puzzles were also asked alone, worded exactly as in the long documents. Beam still proved them 9 times out of 10. At ~100k the result varies from run to run: identical prompts gave 1 to 4 of 5. With the puzzle's facts moved to the start or the end of the document, Beam proved 3 of 5 and 4 of 5. That is inside the same spread, so these runs cannot tell whether position matters. Position was not tested at ~800k.
• Reworded puzzles. The 90 come from 35 base policies, so they are less independent than 90 separate cases. The program without AI is scored as strictly as Beam: its "no" counts only if it read the question correctly. That puts it below 50%. A program written for these exact rewordings would read them too. The original-wording direct answers (68.9% / 86.7% / 98.9%) come from the main run, which had no list of fact types. A first run of direct answers on the reworded puzzles without the list scored 53% / 58% / 67%. The rewriting route always had the list, so the direct answers were run again with it, and those are the ones compared.
• SARA scoring. Strict: exact to the dollar and, for programs, also right when run again with the case's amounts changed. Right also accepts disputed cases. In the test set these are case 49 (SARA's answer key misses a dependent; all three routes counted it) and case 78 (the law text supports several amounts). Cases 77 and 85 were also flagged as unclear (a child's age is not given) and were scored normally. The rules for all four were written down before the run; the test report lists them. In the trial, one disputed rerun (case 20) was judged after an AI review. Beam's one real miss when answering directly (case 82) assumed a payment the case never states, because that "uses all numbers". The facts route's worked example is almost word for word one test case, a head start on that case. Beam's own-program route scores 26 if one harmless program is set aside: the filter that runs only code it can verify as safe refused it. SARA: Holzenberger, Blair-Stanek and Van Durme, 2020 (MIT-style licence). SARA's own data is not included, but Beam's replies in sara_results quote parts of its cases, statutes and Prolog, so SARA's licence notice is included (SARA-LICENSE.txt).
• Dataset. 2,160 Beam replies from the puzzle tests, with Beam's thinking and the checker's verdict (the 120 tax-law replies are in sara_results); the benchmark; 11,192 training and 1,120 validation items (puzzles and answer-checking questions); the full report, the review and the three tax-law reports. The scorer for TRL, Hugging Face's training library, is in the code (the demo's files); its training example was not run here.

Where the details are

• Full results: every table, by puzzle type, length of working and effort, with the long-document checks; the reworded puzzles are in section 5.
• Review of the wrong answers: each of the first run's 12, with the evidence.
• Tax law (SARA), test set, with the numeric trial (pilot) and the true/false trial (pilot).
• Demo: check Beam's answers step by step (including the long-document miss), paste any AI's answer, or generate a fresh puzzle.
• Not published here: the tax-law scripts, the program without AI, and the project's change log.
• Below: what is in this dataset, how to use it, how the puzzles are made, and the limits in detail. Those sections use technical names. The checking program is the engine, Beam's working is a proof, a given answer is a claim, and the list of fact types is the list of record types. A puzzle's wording is its skin; Datalog is the bare-logic version. In Beam's raw replies, "yes" is DERIVED and "cannot be established" is NOT_DERIVABLE.

What is in this dataset

config	split	rows	what
beam_results	test	2,160	Beam's replies from the puzzle tests (none from the tax cases, and not the 40 replies of the two-step long-document check), with the engine's verdict, the first failing proof line, tokens and latency
qwen_results	test	822	the same three tests on Qwen3.8-27B (NVIDIA's NVFP4 build, effort xhigh): the 410 short-policy puzzles, the 322 checks and the 90 reworded translations, judged the same way
sara_results	test	120	Beam's tax-law (SARA) replies at high effort: one row per case and route (direct, facts, rules) in the three runs (true/false pilot, numeric pilot, numeric test), with the program Beam wrote (facts and rules routes) and the scores, including the reruns with changed amounts (scores, JSON). The prompts are not included: they are mostly SARA's own text
benchmark	solve	2,374	the full puzzle test set: 1,187 puzzles, each in Datalog and in one policy wording; the 410 short-policy puzzles Beam answered were drawn from it
benchmark	verify	1,846	"is this claimed answer right?" items: correct and subtly wrong claims, each in both wordings; the 322 Beam checked were drawn from them
training	train	11,192	fresh puzzles from disjoint seeds, for SFT / RL
training	validation	1,120	the same, for tuning
data/long_recipes.jsonl	–	150	long-context items as rebuildable recipes for the "128k" / "512k" / "1M" settings (the ~100k and ~800k documents of the results; measured on Beam: about 102k–107k and 799k–830k prompt tokens; the "512k" setting was not run)

Also in the dataset: results/report.md and results/audit.md (the full results and the review of the wrong answers), sara-numeric-test/report.md, sara-numeric-pilot/report.md and sara-pilot/report.md (the tax-law reports), qwen-comparison/report.md (the same tests on Qwen3.8-27B), SARA-LICENSE.txt (SARA's licence notice, for the quotes in sara_results), and manifest.json (rows, seeds and SHA-256 of every file).

Each row has the full prompt, the label from the exact engine, a reference answer (the engine's canonical proof, or the reference verdict) and the puzzle as JSON text, so it can be re-rendered and re-scored offline.

Reading beam_results

One row per Beam reply. Rows from different parts of the run measure different things, so filter on part rather than averaging correct over the whole table:

part	rows	what it gives
main	410	the main set at high effort (406/410 correct); rows with in_effort_curve are also the "high" point of the effort curve
effort_curve	180	the effort curve at low (62/90) and medium (78/90)
verify	322	answer checking at medium effort: false_accept, false_reject, beam_reason
verify_high	322	the same 322 claims checked again at high effort (2026-10-22): 4 wrong claims accepted, 1 right claim rejected
size_study	30	long documents, first run: alone, ~100k (length 128k), ~800k (length 1m); the headline counts the true puzzles (label 1)
size_repeat	15	repeated runs at ~100k and ~800k (run = repeat1 / repeat2)
size_alone_same_words	10	the stand-alone puzzles in the long documents' exact wording
size_placement	10	the facts moved to the start (depth_pct 0) or the end (100) at ~100k
pilot	51	a warm-up sample from the start of the run, kept for completeness, not counted in the report
reworded_direct	270	the effort-curve puzzles reworded (skin ends in _reworded_vocab), answered directly with the list of record types, at low / medium / high (57, 63, 84 of 90)
reworded_translate	270	the same documents rewritten as rules (skin ends in _reworded); correct = the engine's answer from Beam's rules is right (only a complete translation with the question read correctly can earn credit; for a "yes", the engine's proof must check against the original); here beam_verdict is empty, engine_verdict is the engine's answer, valid_proof says whether its proof checks against the original, false_derived means the engine said yes without a valid proof (as elsewhere) and engine_false_yes that it said yes to a false statement; translation_complete, translation_exact, rules_exact / rules, facts_exact / facts (79, 88, 90 of 90 correct)
reworded_direct_no_list	270	a first run of direct answers on the reworded documents without the list of record types (48, 52, 60 of 90); not a fair comparison, see the report

Beam's replies are unedited model output: beam_answer is the final answer and beam_reasoning the thinking Reflection's API returned with it (most of each reply's output tokens).

The same tests on Qwen3.8-27B (qwen_results)

To see how the benchmark treats a model that fits on one GPU, three tests were run again on Qwen3.8-27B (open-weight, Apache 2.0; NVIDIA's NVFP4 build, served with vLLM on one RTX PRO 6000, effort xhigh, one run each). The puzzles, prompts and scoring are the same as for Beam.

test	Beam-1.0, high	Qwen3.8-27B, xhigh
410 short-policy puzzles, right	406	406
322 checks: answers in the required format	320	263
161 wrong answers, not accepted (counting a reason given without the word REJECT)	157	160
90 reworded policies translated exactly	90	85

The long-document tests were not run on Qwen in our serving setup (a limit of 81,920 tokens per request; the ~800k documents are also beyond Qwen's native 262,144-token context). Details: the comparison, also section 6 of the full results. part is main, verify or reworded_translate; verdict and correct are the checker's, as in beam_results.

Suites

iid (1–8 steps) · combos (rule combinations held out of training) · depth16 / depth32 (9–32 steps) · large (many distractors) · traps (look-alike facts about the wrong party) · near-identical twin negatives · rule-edit pairs (one rule edited so the answer must flip, or must not) · renamed and shuffled copies (consistency).

How to use it

Evaluate a model (proof-checked, deterministic, offline). Always pass the row's own skin: with the wrong wording, correct proofs score 0 and no error is raised.

from datasets import load_dataset
from beambench.reward import score                       # code: see the Space's files
row = load_dataset("AndreiGheorghiu/rulebookbench-beam", "benchmark", split="solve")[0]
out = score(row["problem"], model_reply, skin=row["skin"])                       # solve mode
vrow = load_dataset("AndreiGheorghiu/rulebookbench-beam", "benchmark", split="verify")[0]
out = score(None, model_reply, mode="verify", claim=vrow["claim"], skin=vrow["skin"])  # verify rows
out["reward"], out["components"], out["report"]

Train with RL (TRL GRPO): the training config already has the columns the reward needs; beambench.trl_reward.rulebook_reward is a drop-in reward function and examples/train_grpo.py shows how to set up a full run (--hub-dataset AndreiGheorghiu/rulebookbench-beam); it was not run for these results.

Guard another AI's answers: beambench.verify.check_claimed_answer(row["problem"], row["skin"], reply) accepts a reply only if its proof checks, and names the first failing step otherwise.

How the puzzles are made

A proof-first generator builds each problem backward from the query, adds distractor rules, binding traps and unproductive cycles, and an exact forward-chaining engine assigns the label. A negative twin is the positive after one decisive edit, re-verified. Long-context items bury a puzzle in a document of logically unrelated but active rules and records (they derive thousands of facts of their own, but can never reach the question's predicates; they reuse the puzzle's own names, so they cannot be skipped by name). The puzzle's facts sit together at a controlled depth (~46% of the document in the headline runs); its rules sit in the rules section, after all the facts. Every padded item is re-labelled by the engine.

Splits and contamination

The test split was generated with seed 4242 (long tier 4243), validation 50,000, train 100,000; the held-out rule combinations (combos) appear only in the test split, and exact duplicates of test puzzles are removed from train / validation. All names are fresh pseudo-words; regenerate a private test set from a new seed at any time.

Limitations in detail

• The logic is positive Datalog with 1- and 2-place relations: no negation, numbers, dates or exceptions, which real policies often have.
• Policy wording uses six relation and six quality templates per domain, each with a fresh invented word.
• The long-context result rests on 5 true puzzles (2–3 runs each at ~100k and ~800k tokens, plus word-identical stand-alone controls and two other placements at ~100k). The 5 false puzzles were always answered "no", which shows little at long length.
• One run per item unless stated. Sampling was left at the server defaults that Reflection's API reported for our account (temperature 0.7, top_p 0.99); output limit 32,768 tokens at high effort, 24,576 at medium, 16,384 at low.
• Token counts are those reported by Reflection's API.
• The reworded documents use a fixed set of wordings (two per kind of statement), the list of record types was given, and every sentence still contains its record type's invented word, so the main difficulty left was who-does-what. The documents are short, each item ran once per effort level, and the 90 puzzles come from 35 base documents. It shows that Beam can match reworded sentences to a list of record types it was given. It does not show that Beam can turn a real, freely written policy into rules.

Licence

Data: CC BY 4.0. Code: Apache-2.0. Beam outputs are included as evaluation results.