Datasets:

dmartine
/

beam-effort-curve

run_id large_stringclasses 1 value	task_id large_stringclasses 125 values	category large_stringclasses 5 values	tier large_stringclasses 2 values	effort large_stringclasses 5 values	sample int64 0 2	variant large_stringclasses 2 values	backend large_stringclasses 1 value	provider large_stringclasses 1 value	model large_stringclasses 1 value	model_version large_stringclasses 1 value	temperature float64 0.7 0.7	top_p float64 0.99 0.99	max_tokens int64 32.8k 32.8k	content large_stringlengths 9 8.83k ⌀	reasoning large_stringlengths 33 78.6k	tool_calls large_stringclasses 89 values	prompt_tokens int64 70 12.1k	completion_tokens int64 94 32.8k	reasoning_tokens float64 10 32.8k	finish_reason large_stringclasses 2 values	latency_s float64 0.92 1.87k	turns int64 1 8	ts large_stringdate 2026-10-28 03:03:30 2026-11-02 01:09:14	truncated bool 2 classes	grade large_stringclasses 103 values	correct bool 2 classes	format_ok bool 2 classes
full-2026-10-27	code-001	code	core	low	0	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python import re _DURATION_RE = re.compile( r"^\s" r"(?:(\d+)\sd)?\s" r"(?:(\d+)\sh)?\s" r"(?:(\d+)\sm)?\s" r"(?:(\d+)\ss)?\s*$" ) def parse_duration(s: str) -> int: if not isinstance(s, str): raise ValueError("duration must be a string") match = _DURATION_RE.fullmatch(s...	We need to parse durations. Let's design robust regex. Pattern: optional whitespace, then sequence of (number + unit) in order d,h,m,s, each at most once, whitespace between parts allowed. Also entire string maybe whitespace? Empty string invalid. Need handle numbers? Probably nonnegative integers? Could be "1.5h"? S...	null	177	676	415	stop	3.974	1	2026-10-28T03:03:30+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-001	code	core	low	1	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python import re def parse_duration(s: str) -> int: if not isinstance(s, str) or not s.strip(): raise ValueError("duration must be a non-empty string") # Remove all whitespace so parts may be separated freely. compact = "".join(s.split()) # Match number+unit segments, ensuring the entire s...	We need to write parse_duration. Need consider edge cases. Need produce code. Let's reason. Input string. Units d,h,m,s. Each may appear at most once and order. Whitespace allowed between parts. Number before unit. Need raise ValueError for empty, unknown unit, repeated/out-of-order, number without unit. Also presumab...	null	177	837	555	stop	5.22	1	2026-10-28T03:03:31+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-001	code	core	low	2	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python def parse_duration(s: str) -> int: if not s or not s.strip(): raise ValueError("empty duration") text = "".join(s.split()) units_order = {"d": 0, "h": 1, "m": 2, "s": 3} multipliers = {"d": 86400, "h": 3600, "m": 60, "s": 1} total = 0 i = 0 n = len(text) last_order = ...	We need to write parse_duration. Need to be careful. Let's reason. Input string s. Convert to seconds. Units d,h,m,s. Each at most once, order d<h<m<s. Whitespace between parts allowed. Raise ValueError for empty, unknown unit, repeated/out-of-order, number without unit. Need parse like "1h30m", "2d 4h", "45s", "1d2h...	null	177	953	658	stop	7.038	1	2026-10-28T03:03:33+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-001	code	core	medium	1	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python import re _UNIT_ORDER = {"d": 0, "h": 1, "m": 2, "s": 3} _UNIT_SECONDS = {"d": 86400, "h": 3600, "m": 60, "s": 1} def parse_duration(s: str) -> int: if not isinstance(s, str) or s.strip() == "": raise ValueError("duration must be a non-empty string") if not re.fullmatch(r"\s*(?:\d+[dhms]\s...	We need to write parse_duration(s: str) -> int. Need to parse durations like "1h30m", "2d 4h", "45s", "1d2h3m4s" to seconds. Units d,h,m,s. Each unit at most once, order d,h,m,s. Whitespace between parts allowed. Raise ValueError for empty string, unknown unit, repeated/out-of-order unit, number without unit. Need rob...	null	178	2,241	1,979	stop	10.843	1	2026-10-28T03:03:37+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-001	code	core	medium	2	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python import re def parse_duration(s: str) -> int: if not isinstance(s, str) or not s.strip(): raise ValueError("duration must be a non-empty string") if re.fullmatch(r"\s(?:\d+[dhms]\s)+\s*", s) is None: raise ValueError(f"invalid duration: {s!r}") units = {"d": 86400, "h": 3600, "...	We need to write parse_duration(s: str) -> int. Need parse durations like "1h30m", "2d 4h", "45s", "1d2h3m4s". Units d,h,m,s. Each at most once, order d before h before m before s. Whitespace between parts allowed. Raise ValueError for empty string, unknown unit, repeated/out-of-order unit, number without unit. Need c...	null	178	1,705	1,448	stop	11.487	1	2026-10-28T03:03:37+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-001	code	core	medium	0	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python def parse_duration(s: str) -> int: if not isinstance(s, str) or not s.strip(): raise ValueError("duration string must not be empty") units = {"d": 86400, "h": 3600, "m": 60, "s": 1} order = {"d": 0, "h": 1, "m": 2, "s": 3} total = 0 last_order = -1 found = False i = 0 ...	We need to write parse_duration(s: str) -> int. Need handle examples. Units d,h,m,s. Each unit at most once, order d<h<m<s. Whitespace between parts allowed. Raise ValueError for empty, unknown unit, repeated/out-of-order, number without unit. Need parse robustly. Need consider what constitutes number? Probably intege...	null	178	2,589	1,806	stop	11.991	1	2026-10-28T03:03:38+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-001	code	core	high	0	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python import re _DURATION_RE = re.compile( r"\s(?:(\d+)\sd\s)?(?:(\d+)\sh\s)?(?:(\d+)\sm\s)?(?:(\d+)\ss\s)?\s" ) def parse_duration(s: str) -> int: """Convert a duration such as '1h30m' or '2d 4h' to seconds.""" if not isinstance(s, str) or s == "": raise ValueError("duration must b...	We need to write parse_duration(s: str) -> int. Need robust parsing. Need consider edge cases. Let's parse requirements. Convert duration like "1h30m", "2d 4h", "45s", "1d2h3m4s" to seconds. Units d,h,m,s. Each unit at most once, units must appear in that order (d before h before m before s). Whitespace between parts ...	null	179	2,385	2,167	stop	11.952	1	2026-10-28T03:03:42+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-001	code	core	high	2	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python import re def parse_duration(s: str) -> int: if not isinstance(s, str) or not s.strip(): raise ValueError("duration must be a non-empty string") if not re.fullmatch(r"\s(?:[0-9]+[dhms]\s)+", s): raise ValueError("invalid duration format") parts = re.findall(r"([0-9]+)([dhms])"...	We need answer code. Need solve parse_duration. Need consider edge cases. Need produce complete implementation. Let's parse requirements carefully. Function parse_duration(s: str) -> int converts duration like "1h30m", "2d 4h", "45s", "1d2h3m4s" to seconds. Units d,h,m,s. Each at most once, order d<h<m<s. Whitespace b...	null	179	3,295	3,035	stop	17.066	1	2026-10-28T03:03:50+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-001	code	core	max	0	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python import re _DURATION_RE = re.compile(r"^\s(?:[0-9]+[dhms])(?:\s[0-9]+[dhms])\s$") _UNIT_ORDER = "dhms" _MULTIPLIERS = {"d": 86400, "h": 3600, "m": 60, "s": 1} def parse_duration(s: str) -> int: if not isinstance(s, str) or s.strip() == "": raise ValueError("duration must be a non-empty strin...	We need answer code. Need implement parse_duration robust. Need think requirements. Need output final with code block only? User asks reply complete implementation. We'll provide. Need ensure correctness tests likely. Let's analyze deeply. Function parse_duration(s: str) -> int. Convert duration like examples. Units d...	null	179	2,786	2,518	stop	11.479	1	2026-10-28T03:03:53+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-001	code	core	xhigh	1	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python import re _UNIT_ORDER = "dhms" _MULTIPLIERS = {"d": 86400, "h": 3600, "m": 60, "s": 1} _DURATION_RE = re.compile(r"\s(?:\d+\s[dhms]\s*)+") def parse_duration(s: str) -> int: if not isinstance(s, str) or not s.strip(): raise ValueError("duration must be a non-empty string") if _DURATION_R...	We need answer Python code. Need implement parse_duration robustly. Need think requirements. Let's parse. We need function parse_duration(s: str) -> int. Converts durations like "1h30m", "2d 4h", "45s", "1d2h3m4s" to seconds. Units d,h,m,s. Each at most once and order d<h<m<s. Whitespace between parts allowed. Raise V...	null	179	2,974	2,737	stop	17.143	1	2026-10-28T03:03:55+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-001	code	core	xhigh	0	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python import re _DURATION_RE = re.compile( r"^\s(?:([0-9]+)\sd)?\s(?:([0-9]+)\sh)?\s(?:([0-9]+)\sm)?\s(?:([0-9]+)\ss)?\s*$" ) def parse_duration(s: str) -> int: """Convert a duration string such as '1h30m' or '2d 4h' to seconds.""" match = _DURATION_RE.fullmatch(s) if match is None: ...	We need answer with python code block. Need implement parse_duration. Need think carefully about requirements and edge cases. User asks "Write parse_duration(s: str) -> int ...". Need complete implementation single code block standard library. We need infer expected behavior. Convert duration like strings to seconds. ...	null	179	3,633	3,392	stop	19.075	1	2026-10-28T03:03:56+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-002	code	core	low	0	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python def semver_compare(a: str, b: str) -> int: def parse(v: str): # Split off build metadata. v = v.split("+", 1)[0] # Split core and pre-release. if "-" in v: core, pre = v.split("-", 1) else: core, pre = v, None major, minor, patch = (i...	Need to implement semver_compare. Parse version. Semver grammar: MAJOR.MINOR.PATCH-prerelease+build. Build ignored. Need compare core numeric tuples. If equal, prerelease: version without prerelease > version with. Compare prerelease identifiers split by '.'. Each identifier: if all digits -> numeric (integer compariso...	null	204	595	133	stop	3.171	1	2026-10-28T03:03:58+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-002	code	core	low	1	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python import re def semver_compare(a: str, b: str) -> int: def parse(v: str): m = re.fullmatch(r"(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)))?(?:\+.)?", v) if not m: raise ValueError(f"invalid semver: {v!r}") major, minor, patch = (int(x) for x in m.group(1, ...	Implement semver_compare. Need to parse version. SemVer 2.0.0. Use regex maybe. Need robust. Let's write. Pattern: ^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)))?(?:\+.)?$ maybe build ignored. Pre-release identifiers. Compare core numerically. Then pre-release: no prerelease > prerelease. If both have,...	null	204	609	176	stop	2.939	1	2026-10-28T03:03:59+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-002	code	core	low	2	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python def semver_compare(a: str, b: str) -> int: def parse(version: str): # Ignore build metadata. version = version.split("+", 1)[0] if "-" in version: core, pre = version.split("-", 1) prerelease = pre.split(".") else: core = version ...	We need write function. Need ensure semver compare. Need output code block. Let's reason. Need parse version string into core version and pre-release. Build ignored. Need validate? Problem says versions look like. We can implement robust enough. Semver precedence: compare major.minor.patch numerically. If equal, pre-...	null	204	871	453	stop	4.649	1	2026-10-28T03:04:02+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-001	code	core	xhigh	2	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python import re _UNIT_SECONDS = { "d": 86400, "h": 3600, "m": 60, "s": 1, } _UNIT_ORDER = { "d": 0, "h": 1, "m": 2, "s": 3, } _DURATION_RE = re.compile(r"\s(?:[0-9]+[dhms]\s)+") def parse_duration(s: str) -> int: if not isinstance(s, str) or not s.strip(): raise Va...	We need write parse_duration(s: str) -> int. Need handle specs carefully. Need produce final code block. Let's reason requirements. Convert duration like "1h30m", "2d 4h", "45s", "1d2h3m4s" to seconds. Units d,h,m,s. Each unit at most once and units must appear in order (d before h before m before s). Whitespace betwe...	null	179	4,045	3,746	stop	25.934	1	2026-10-28T03:04:04+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-002	code	core	medium	0	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python import re _VERSION_RE = re.compile(r"^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$") def _parse(version: str): # Build metadata is ignored. core_and_prerelease = version.split("+", 1)[0] match = _VERSION_RE.fullmatch(core_and_prerelease) if match is None: raise ValueError(f"Invalid semantic versi...	We need write Python function semver_compare. Need obey SemVer 2.0.0 precedence. Need likely robust parsing. Need output only code block? User asks complete implementation single code block. We can include docstring. Need ensure standard lib. Let's reason thoroughly. SemVer core version numeric identifiers: major.mino...	null	205	1,477	1,047	stop	7.229	1	2026-10-28T03:04:06+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-001	code	core	high	1	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python import re _DURATION_RE = re.compile( r"^\s" r"(?:(\d+)d)?" r"\s" r"(?:(\d+)h)?" r"\s" r"(?:(\d+)m)?" r"\s" r"(?:(\d+)s)?" r"\s*$" ) def parse_duration(s: str) -> int: """Convert a duration string like '1h30m' to seconds.""" match = _DURATION_RE.fullmatch(s) ...	We need answer Python code. Need parse_duration. Need think thoroughly. Requirements: - convert duration like "1h30m", "2d 4h", "45s", "1d2h3m4s" to seconds. - Units d h m s. Each unit at most once and units must appear in that order (d before h before m before s). - Whitespace between parts allowed. - Raise ValueErro...	null	179	6,422	6,148	stop	34.965	1	2026-10-28T03:04:06+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-002	code	core	medium	1	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python def semver_compare(a: str, b: str) -> int: def parse(version: str): # Ignore build metadata. version = version.split("+", 1)[0] # Split core version from pre-release. if "-" in version: core, pre = version.split("-", 1) pre_ids = pre.split(".") if p...	We need to write semver_compare. Need careful. Need output only code block? User says Reply with complete implementation in single python code block. We'll provide. Need implement parsing SemVer 2.0.0. Need consider validation? Probably not strict. Versions look like given. Need compare core version numerically. Then ...	null	205	1,235	842	stop	6.468	1	2026-10-28T03:04:09+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-001	code	core	max	1	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python import re _UNIT_ORDER = {"d": 0, "h": 1, "m": 2, "s": 3} _MULTIPLIERS = {"d": 86400, "h": 3600, "m": 60, "s": 1} _DURATION_RE = re.compile(r"\s(?:[0-9]+\s[dhms]\s*)+") def parse_duration(s: str) -> int: if not isinstance(s, str) or not _DURATION_RE.fullmatch(s): raise ValueError(f"Invalid dur...	We need answer code. Need parse duration. Need consider edge cases. Need implement robust. Let's parse spec. Convert duration like "1h30m", "2d 4h", "45s", "1d2h3m4s" to seconds. Units d,h,m,s. Each at most once, order d<h<m<s. Whitespace between parts allowed. Raise ValueError empty, unknown unit, repeated/out-of-orde...	null	179	3,496	3,253	stop	18.926	1	2026-10-28T03:04:09+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-002	code	core	medium	2	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python def semver_compare(a: str, b: str) -> int: def _ident_key(identifier: str): if identifier and all(c in "0123456789" for c in identifier): return (0, int(identifier)) return (1, identifier) def _parse(version: str): # Ignore build metadata. version = version...	We need to write semver_compare(a,b) -> int returning -1,0,1 by SemVer 2.0.0 precedence. Need complete implementation in single code block. Need only stdlib. Need parse carefully. SemVer precedence rules: - Version core: major.minor.patch numeric. - Pre-release identifiers split by '.'. - Build metadata ignored. - Pre...	null	205	1,469	1,201	stop	8.401	1	2026-10-28T03:04:12+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true
full-2026-10-27	code-002	code	core	high	0	default	reflection	reflection	Beam-1.0-501B-A23B	Beam-1.0-501B-A23B	0.7	0.99	32,768	```python def semver_compare(a: str, b: str) -> int: def parse(version: str): core_and_pre, _, _ = version.partition("+") if "-" in core_and_pre: core, pre = core_and_pre.split("-", 1) prerelease = pre.split(".") if pre != "" else [] else: core, prerelease...	We need answer Python implementation semver_compare. Need careful Semantic Versioning 2.0.0 precedence. Need only stdlib. Need complete implementation in code block. We can include helper. Need parse robustly. Need decide validation? Problem says versions look like. We can implement. Need ensure exact semantics. Let's...	null	206	2,765	2,371	stop	13.357	1	2026-10-28T03:04:19+00:00	false	{"correct": true, "format_ok": true, "detail": null}	true	true

End of preview. Expand in Data Studio

Beam Effort Curve

Every graded run behind Beam Effort Curve: Reflection's Beam-1.0-501B-A23B at all five reasoning_effort levels (low, medium, high, xhigh, max) on 125 tasks written after the model's knowledge cutoff.

Headline: high for reasoning and low for everything else matches max accuracy (95.7%) with 64% of the output tokens. See FINDINGS.md for the full write-up.

from datasets import load_dataset

runs = load_dataset("dmartine/beam-effort-curve", "main", split="train")
ablation = load_dataset("dmartine/beam-effort-curve", "ablation", split="train")

Configs

Config	Rows	What it is
`main`	1,775	125 tasks x 5 effort levels x 3 samples (1 sample for the 10 hard math tasks), Reflection's API, October 27 to November 1, 2026
`ablation`	360	the 30 tool-calling tasks at `low` and `high`, 3 samples, with the earlier reasoning sent back (`preserve`) or replaced by a placeholder (`drop`); run on Ollama Cloud

The task definitions (prompts, tests, schemas, canned tool outputs, answers) are in tasks/, one JSONL file per category, identical to the ones in the GitHub repo.

Fields

Field	Meaning
`run_id`, `task_id`, `category`, `tier`	run, task, `math` / `code` / `tools` / `tool_schema` / `structured`, `core` or `hard`
`effort`, `sample`, `variant`	effort level, sample index, `default` or (tools) `preserve` / `drop`
`backend`, `provider`, `model`, `model_version`	where the call ran
`temperature`, `top_p`, `max_tokens`	sampling settings (0.7, 0.99, 32,768)
`content`, `reasoning`, `tool_calls`	the final reply, the reasoning text, and the parsed tool calls (JSON string)
`prompt_tokens`, `completion_tokens`, `reasoning_tokens`	usage; summed over turns for tool tasks; `reasoning_tokens` is not reported by Ollama
`finish_reason`, `truncated`	`length` / `truncated = true` means the run hit the 32k cap
`latency_s`, `turns`, `ts`	wall time, model turns (tool tasks), UTC timestamp
`correct`, `format_ok`, `grade`	grader verdict, whether the answer was in the expected format, and the grader's full output (JSON string)

How it was made

Tasks: 35 math (25 core, 10 hard), 35 code (25 core, 10 hard), 30 tool calling (20 core, 10 hard), 10 tool schemas, 15 structured output. All written for this benchmark after the June 30, 2026 knowledge cutoff; every builder verifies its tasks before writing them (brute-force answers, reference solutions against the tests, perfect transcripts replayed through the grader).
Grading: math by the last \boxed{} answer (exact or symbolic match), code by running the reply against hidden tests in a sandboxed subprocess, tool calling by checking calls in order against the expected steps, structured output by JSON Schema validation plus field-level accuracy. No model judges anything.
Sampling: temperature 0.7 and top_p 0.99, the settings on the model card. Runs that hit the 32k cap or error count as wrong.

Limitations

10 to 35 tasks per category, so confidence intervals are wide; differences of a point or two between levels are not significant.
Hard math has 1 sample per task and level, to fit Reflection's beta allowance of 1M output tokens per day.
One provider for main. The ablation config ran on Ollama Cloud, whose serving precision is not documented; it is a separate experiment and is not mixed with main.

Downloads last month: 22