stepmold-bench

Real-model results for stepmold, a zero-dependency Python framework for multi-step LLM workflows. In stepmold every step is constrained to a JSON schema, checked before anything is saved, retried when it fails the check, and sent down a fallback route when it keeps failing.

Seven models, from Qwen2.5 0.5B to gpt-oss-120b, ran all 86 of stepmold's example cases three times in each of three setups. Every model request and every case result is in the data: 5,418 case runs and 20,520 calls.

The question it answers: on a real model, what do stepmold's checks change?

The short answer

The checks did not make any model answer correctly more often. For every model, the pass rate with the checks on is within 5 points of the pass rate with them off, and most of those gaps sit inside the 95% intervals.

What changed is how the models fail. With the checks on, a bad answer is caught and the case goes to its fallback route (a human queue, in these workflows) instead of ending with a wrong result. For the small models that moves a lot of cases.

"On" is the stepmold arm. "Off" is plain_schema: the same prompts with the expected format written in, and no checks, retries or decoding grammar. 258 case runs per cell.

Model	Passed, on	Passed, off	Silently wrong, on	Silently wrong, off	Escalated, on	Escalated, off	Crashed, off
Qwen2.5 0.5B	5.0%	4.7%	49.2%	68.2%	45.7%	18.6%	8.5%
Qwen2.5 1.5B	14.3%	16.3%	56.2%	74.0%	29.5%	7.8%	1.9%
Qwen3 4B	38.8%	37.2%	57.0%	58.1%	4.3%	4.7%	0.0%
Qwen2.5 7B	38.8%	34.1%	53.5%	63.2%	7.8%	2.7%	0.0%
Qwen3 8B	39.1%	39.9%	53.1%	55.4%	7.8%	4.7%	0.0%
qwen-3.8-27b	48.8%	52.3%	39.5%	32.6%	11.6%	0.4%	14.7%
gpt-oss-120b	53.5%	53.5%	42.2%	46.5%	4.3%	0.0%	0.0%

• No case crashed with the checks on, for any model. With them off, 8.5% of Qwen2.5 0.5B's cases crashed, 1.9% of Qwen2.5 1.5B's and 14.7% of qwen-3.8-27b's.
• Silently wrong answers dropped most for the small models: from 68.2% to 49.2% for Qwen2.5 0.5B, from 74.0% to 56.2% for Qwen2.5 1.5B and from 63.2% to 53.5% for Qwen2.5 7B. For Qwen3 4B and 8B the drop is 1 to 2 points. qwen-3.8-27b went the other way (39.5% against 32.6%), because with the checks off 14.7% of its cases crashed instead.
• Retries mostly happen in the smallest models. Qwen2.5 0.5B averaged 0.84 retries per case and Qwen2.5 1.5B 0.45. The Qwen models from 4B up averaged 0.05 or fewer, qwen-3.8-27b 0.20 and gpt-oss-120b none. Schema-constrained decoding gets the format right on the first try, so what is left to catch is mostly wrong content.
• Without any format instruction nothing works. In the plain arm (no grammar and no schema in the prompt) every model passed 0% and about 72% of cases crashed. The packs' prompts never ask for JSON; only the grammar tells the model the format.
• Absolute pass rates are low, 53.5% even for gpt-oss-120b, because a pass needs every gold field to match exactly, including judgement calls such as a ticket's priority. Compare the arms with each other, not the models' absolute scores.

These numbers do not reproduce the "96.5% against 2.0%" in stepmold's README. That figure comes from a seeded simulation where the checks always know the right answer and retries fail independently. A real model tends to repeat its mistake when asked again, and a check can only catch an answer that breaks the schema or a node's assert.

What was run

Label	Model	Where	Settings
qwen2.5-0.5b-instruct	Qwen/Qwen2.5-0.5B-Instruct	Kaggle, 1 T4, vLLM 0.33.0	fp16
qwen2.5-1.5b-instruct	Qwen/Qwen2.5-1.5B-Instruct	Kaggle, 1 T4, vLLM 0.33.0	fp16
qwen3-4b	Qwen/Qwen3-4B	Kaggle, 1 T4, vLLM 0.33.0	fp16, thinking off
qwen2.5-7b-instruct	Qwen/Qwen2.5-7B-Instruct	Kaggle, 2 T4s (tensor parallel), vLLM 0.33.0	fp16
qwen3-8b	Qwen/Qwen3-8B	Kaggle, 2 T4s (tensor parallel), vLLM 0.33.0	fp16, thinking off
qwen-3.8-27b	qwen-3.8-27b	Cerebras API	reasons before answering, 1,000 extra tokens per call
gpt-oss-120b	gpt-oss-120b	Cerebras API	reasons before answering, 1,000 extra tokens per call

All runs were on 2 November 2026, with stepmold at commit 38235ab. The first draw of every step used temperature 0.7 (top_p 0.8 for the Qwen models). After a rejection stepmold uses its own retry temperatures: 0.5, 0.8 and 1.0. Each case ran 3 times in each arm, so every model has 774 case runs.

The three arms

Arm	Grammar sent to the server	Checks before saving	Retries and fallback	Agreement gate	Format written in the prompt
stepmold	yes	parse, schema and assert	yes	yes	no
plain_schema	no	no	no	no, one draw	yes, the node's schema
plain	no	no	no	no, one draw	no

All three arms use stepmold's own walker, the same graph, the same prompts (plain_schema adds the schema text, in the same words stepmold's json_object mode uses) and the same think steps. In the plain arms an answer that does not parse saves nothing, and the walk carries on where the graph allows. Assert nodes and tool nodes keep their fallback edges in every arm. code/README.md lists every difference.

How a case is scored

outcome	Meaning
passed	every gold field matched, and the case ended where the gold case says it should
escalated	the case ended on a fallback route, such as needs_human, without passing
silently_wrong	the case ended normally, but the answer differs from the gold answer
crashed	the walk could not finish, for example because a later prompt needed a value an earlier step never produced

Files

Path	Contents
data/cases.jsonl	one row per case run (5,418): model, arm, pack, case, run, outcome, fields matched, end node, tokens, time. Nested fields (input, expected, output, mismatches, path and others) are JSON strings
data/calls.jsonl	one row per model request (20,520): node, stage, attempt, raw output, whether it parsed, fit the schema and passed the assert, why it was rejected, tokens and latency
data/runs.jsonl	one row per model: settings, software versions and a digest of each pack
raw/	the runner's own output files, unchanged except that local paths are removed, plus the vLLM server logs
summary/	tables per model, arm and pack, with 95% Wilson intervals
code/	the runner (bench.py), summarize.py, build_dataset.py and kaggle_runner.py

from datasets import load_dataset

cases = load_dataset("ahkamboh/stepmold-bench", "cases", split="train")
calls = load_dataset("ahkamboh/stepmold-bench", "calls", split="train")

Reproducing a run

The runner uses only the Python standard library. It needs a checkout of stepmold at 38235ab, because the example packs are not part of the pip package.

git clone https://gitlab.com/ahkamboh/stepmold && git -C stepmold checkout 38235ab
python3 code/bench.py --stepmold stepmold \
  --model 'openai:http://localhost:8000/v1#Qwen/Qwen2.5-7B-Instruct' \
  --label qwen2.5-7b-instruct --arms stepmold,plain_schema,plain --runs 3 \
  --extra-body '{"temperature": 0.7, "top_p": 0.8}'
python3 code/summarize.py results/*.jsonl

code/kaggle_runner.py is the script that served and ran the five Qwen models on Kaggle.

Limitations

• The gold set is small: 86 cases from 7 example packs written for stepmold's documentation. The gold labels are strict and include judgement fields.
• One case in refund_desk only passes when a step fails three times in a row, so no real model is expected to pass it in any arm.
• There is one sampling setup (temperature 0.7) and three runs per case.
• The T4 has no support for FlashAttention 2, so vLLM used another attention backend. The Qwen models ran in fp16, not bf16.
• The Kaggle runs used a copy of bench.py with comments and docstrings removed (sha256 b51bae8fd52d...) so it fit in a notebook cell. On all 258 scripted offline case runs it gives the same verdicts as the original in code/bench.py.
• The two Cerebras models reason before answering, and the five Qwen models do not.
• The plain arm mostly measures a pipeline that never tells the model its output format. It fails almost the same way for every model.
• Example inputs include made-up names and email addresses from stepmold's example packs.

License

MIT, the same as stepmold.

Links

• stepmold: gitlab.com/ahkamboh/stepmold
• Try the packs in a browser: huggingface.co/spaces/ahkamboh/stepmold