dacorvo/funes-beam-benchmark

BEAM against funes

BEAM is a long-conversation memory benchmark: ten abilities asked over conversations that run to millions of tokens. past.dev published their numbers on it, and their whole harness with them. This repository runs the same benchmark against funes.

The point of the comparison is that only the memory differs. The dataset, the answer prompt, the rubrics and the evidence budget all come from past.dev's harness, vendored unchanged under vendor/pastdev-beam/, and that harness's answer and judge prompts are ExaBase's published BEAM prompts with a SHA-256 that verify.py --prompts checks against the source. What this repository adds is the one call that fetches the evidence, and one reader and judge over both arms.

Results

BEAM 100K, 400 questions, 20 conversations. Dataset revision 3205395e. Answer and judge model deepseek-ai/DeepSeek-V4-Pro on the Hugging Face router, 8,000 evidence tokens per question in every arm. funes 1.6.0+dev.

category	funes	funes + rerank	past.dev
abstention	1.000	1.000	1.000
contradiction_resolution	0.675	0.650	0.694
event_ordering	0.617	0.563	0.635
information_extraction	0.724	0.638	0.759
instruction_following	0.850	0.906	0.900
knowledge_update	0.719	0.669	0.713
multi_session_reasoning	0.522	0.563	0.493
preference_following	0.894	0.919	0.906
summarization	0.641	0.665	0.622
temporal_reasoning	0.887	0.863	0.875
micro average	0.7529	0.7436	0.7597

Per question, funes against past.dev: 74 better, 245 equal, 81 worse.

past.dev's column is not their published number. They answered and judged with openai/gpt-5.6-luna, which the Hugging Face router does not serve. The column above is their published evidence, per question, read and judged by the same model that reads funes's (replay_pastdev.py). Under their own model the same evidence scores 0.9208. The 16-point difference is the reader, not the memory, so 0.7597 is the figure funes's 0.7529 is measured against and 0.9208 is not.

Reranking. funes reranks the fused pool only when it is at least four times the hits asked for. The second column turns that on: -k 30 --candidates 120. It changes 61% of the passages that reach the reader, costs about 9.5s per question against 0.2s, and scores 0.9 points lower. Per question it is better on 73 and worse on 78. These stores hold a few hundred chunks each.

Results are under results/: one row per question with the evidence, the answer and the judge's verdicts, and a summary.json per arm.

Where the arms meet

run.py:answer_question() in the vendored harness does:

project.recall(question, as_of, identity) → json.dumps(...) → answer_prompt(...) → the reader

run_funes.py does the same with funes recall in place of project.recall. Everything after that call is byte-for-byte the harness's.

The evidence budget is matched, not the hit count. past.dev asks for up to 100 results within 8,000 tokens and their saved runs fill it to within a few tokens of the cap. funes is given the same 8,000-token budget and its passages are cut at the budget. Both arms pay the same for context, which is the control the comparison needs — a memory that returns more text would otherwise score better by spending more.

The two arms fill that budget with different things. past.dev returns extracted observations with source excerpts; funes returns the passages themselves. That difference is the subject of the comparison, not a confound in it.

The hit count is not matched, and should not be. past.dev's limit of 100 is their API's cap on observations. funes is asked for 30 passages, which is enough that on 399 of the 400 questions the budget runs out before the passages do — so the 8,000 tokens, not a hit count, decide what the reader sees. The one question that reached 30 passages did so at 7,988 evidence tokens, within 12 of the cap.

Both arms end up just under the budget, and funes hands the reader slightly less to read:

	evidence tokens	whole envelope	items
past.dev	7,989	10,884	25
funes	7,846	10,470	23
funes + rerank	7,810	10,476	24

Medians over the 400 questions. The envelope is what the answer prompt carries, counted in o200k_base: past.dev's is larger because each observation nests its sources and excerpts.

The two asymmetries, and where they stand

An earlier look at this comparison found two ways the setup could flatter funes.

Recency weighting is no longer one. funes weighted hits by age against the wall clock, which would have been meaningless against conversations dated 2024. That weighting has since been removed from funes, so there is no knob to pick a favourable value for. This needs funes 1.6.0 or newer.

The asked-at moment is handled by --until, with a measured residue. Nine of BEAM's ten categories are asked at the end of the conversation, where nothing follows the question. knowledge_update is asked as of the update the dataset marks, so the memory must be held to that moment. funes recall --until cuts by day, and BEAM places a whole session on one day, so turns that follow the update within its own session stay visible.

beam_leak.py measures what that leaves, and whether it matters:

BEAM 100k: 40 knowledge_update questions, 5732 turns over 20 conversations

  turns after the asked-at moment, with no cutoff   median 150  (52.6% of the conversation)
  turns left by a day-granular cutoff                median 5  (2.4% of the conversation)

  questions whose leaked turns carry the gold answer better
  than anything before the cutoff                     2/40

So the cutoff removes almost all of the exposure, and on 38 of 40 questions what it leaves carries the answer less well than the evidence already available before the cutoff. Two questions are exposed. Report them; they are 2 of the split's 400.

Holding the memory to the exact turn would mean a store per question over a truncated conversation, or a sub-day cutoff in funes. Neither is worth 2 questions in 400, and a benchmark is not a reason to grow the product's surface.

Running it

Needs Python 3.11+, a funes 1.6.0+ binary, and a Hugging Face token (HF_TOKEN, or huggingface-cli login) for the reader and judge. FUNES_BEAM_MODEL picks the model.

uv venv .venv && uv pip install --python .venv/bin/python -r requirements.txt

# one store per conversation, each in its own FUNES_HOME
.venv/bin/python beam_store.py --split 100k --funes /path/to/funes

# recall, answer, judge
.venv/bin/python run_funes.py --split 100k --funes /path/to/funes

# the same, with the cross-encoder reranking the pool
.venv/bin/python run_funes.py --split 100k --funes /path/to/funes -k 30 --candidates 120

# everything except the model calls: free, and no key needed
.venv/bin/python run_funes.py --split 100k --funes /path/to/funes --dry-run

# past.dev's published evidence, read and judged by this run's model
.venv/bin/python replay_pastdev.py --split 100k

# what a day-granular cutoff leaves exposed
.venv/bin/python beam_leak.py --split 100k

# what two recall configurations put in front of the reader
.venv/bin/python compare_recall.py results/<a>/results.jsonl results/<b>/results.jsonl

beam_store.py writes each conversation as .funes.jsonl turns and indexes them into work/<split>/<conversation>/funes-home. Each turn keeps BEAM's own identity — session_id is the BEAM session, turn_uuid its message id — and its own timestamp, noon UTC on the session's day plus one microsecond per turn, so ordering within a day survives into the store. A turn's text is prefixed with its author, since funes indexes text and has nowhere else to carry who spoke; past.dev sends the same name as turn metadata.

The stores are never the real memory: every call sets FUNES_HOME to the conversation's own store.

past.dev's arm

vendor/pastdev-beam/results/100k/ holds their published run: the recall payload, the answer and the judge's verdicts for all 400 questions. Because the payload is there, their memory's output can be read and judged here by the model that reads funes's, which is what replay_pastdev.py does. No past.dev account is needed, and the arms then differ in nothing but the memory.

Attribution

This repository's own code — beam_store.py, funes_recall.py, run_funes.py, replay_pastdev.py, beam_leak.py, compare_recall.py and hf_llm.py — is Apache 2.0; see LICENSE. The licences below cover everything else, and neither is replaced by it.

vendor/pastdev-beam/ is past.dev's harness, MIT, unchanged, including the published results under vendor/pastdev-beam/results/. Its answer and judge prompts are ExaBase's work and are excluded from that licence; see vendor/pastdev-beam/NOTICE.md.

The BEAM dataset is by Mohammad Taghavi et al., "Beyond a Million Tokens: Benchmarking and Enhancing Long-Term Memory in LLMs", published as Mohammadta/BEAM under CC BY-SA 4.0. The dataset itself is not redistributed here — the harness downloads it and records the revision — but the files under results/ include questions, reference answers and conversation excerpts taken from it, next to model answers and judge verdicts. That dataset-derived content keeps its CC BY-SA 4.0 terms.