mverde73/mnemonic-proxy-agentlongbench

mnemonic-proxy on AgentLongBench (32K window, one 12 GB GPU)

Per-question results, logs and scripts of two runs of AgentLongBench (kf-c, tool_response) comparing four ways of fitting a long agent history into a local model's context window. One of them is mnemonic-proxy, written by the author of this dataset: keep that in mind when reading the numbers.

What was measured

• Model: Qwen3.8 Flash Next, IQ3_XXS. Engine: Strata 0.1.40, KV int8, MTP speculative decoding, 10 experts.
• One RTX 4070 Ti 12 GB, 64 GB RAM. Seed 1. Temperature 0.6, top_p 0.95, top_k 20. max_tokens 4,096, reasoning budget 3,072.
• Benchmark: AgentLongBench, setting kf-c, history tool_response. Two question types: Count Frequency and Find Duplicates.
• 25 questions per type at 64k (74K-token history) and 128k (150K-token history): 100 questions, each answered by each of the four methods.
• Scoring: the official AgentLongBench scorer; an answer counts only if fully right (correct_official).

The four methods (method column)

method	window (tokens)	what happens when the history does not fit
full_window	81,920 (64k) / 163,840 (128k)	nothing: the whole history fits
proxy	32,768	mnemonic-proxy 0.3.5 moves old tool outputs to an archive and gives the model a recall tool to read them back
summary	32,768	the same model compacts the history into at most 2,048 tokens when the window fills
truncation	32,768	the oldest messages are dropped

The proxy build used is commit b8d4920 (0.3.5; on main it was squash-merged as 9a5bb98). For proxy, the whole history is first replayed through the proxy turn by turn, then the question is asked; wall_s includes that replay.

Primary test, preregistered: proxy vs summary, paired, exact McNemar, 64k + 128k pooled.

The two runs (run column, one config each)

Main run (main_run): the official questions. Everything came out near chance:

correct / 100	full window	proxy	summary	truncation
main run	51	52	56	44

Proxy vs summary: 13 vs 17 discordant, p = 0.58. Answering "0 / no" every time scores 50/100.

Why: the question was ambiguous. The benchmark means "the tool results for round N" as the tool output before the "Round N: Guess…" message (the official answers come out exactly that way on 100 of 100 questions). The model, even with the full window, read it as the output after "Round N". On 51 of 100 questions the two readings give different answers: there, methods that had the evidence were systematically wrong, while methods without it were guessing.

Confirmation run (confirm_run), preregistered before launch: same 100 questions, same everything. The only change is one sentence appended to every question saying which tool output "round N" means (the clarified questions are in questions-clarified/; the question column holds the exact text sent). Official answers and scorer unchanged, no re-scoring.

Validity check, fixed in advance (do answers still follow the "after" reading, on the 51 questions where the two readings differ?): full window 41/51 in the main run, 15/51 now; proxy 41/51, now 8/51. The summary stays at 29/51, about what answering "0 / no" every time would give (31/51); the full evidence is in its final prompt in only 15 of 100 questions.

correct	full window	proxy	summary	truncation
64k (/50)	38	41	27	23
128k (/50)	31	45	20	26
both (/100)	69	86	47	49

• Proxy vs summary, pooled: 44 questions right only with the proxy, 5 only with the summary. p = 7.6e-9. 64k: 18 vs 4, p = 0.004. 128k: 26 vs 1, p = 4e-7.
• Proxy vs truncation: 42 vs 5, p = 2.5e-8.
• Proxy vs full window: +17 points, 90% CI [+7, +26]. At 64k alone it is +6, CI [−7, +19]: not shown either way. At 128k the full window's reasoning hits the 3,072-token budget in 32 of 50 answers (the proxy's in 8; summary 45, truncation 44). That may explain part of the gap; it was not tested.
• Summary vs full window: −22 points, 90% CI [−33, −10].
• Dropping truncated answers, or the one question used during development (38_i13_j22_a_0031): no verdict involving the proxy changes.

Time (median per question, confirmation run)

	full window	proxy	summary	truncation
64k, end to end	70 s	136 s	127 s	58 s
128k, end to end	102 s	286 s	251 s	65 s
128k, time to first token of the answer	61 s	1.9 s	8.6 s	11 s

• Most of the proxy's time is the replay of the whole history before the question (229 s median at 128k).
• In new prompt tokens per question it is the most expensive: 328K median at 128k vs 150K for the full window. At question time alone it reads 19K new tokens on average.
• In a real agent that replay does not happen in one block; the work is spread over the turns. A long session was not measured, so no saving is claimed there.
• VRAM was the same for every method (~11.6 GB; the engine reserves the GPU).

Limits

• One model, one quant, one engine, one benchmark, two question types, 100 questions, one seed.
• The clarifying note was added after the first run. The second run was preregistered, but it exists because of the first one.
• Run-to-run noise is large: on the 49 questions where the note does not change the right answer, the full window went from 42 to 35 correct between runs, the proxy from 46 to 44.
• Find Target Offsets is excluded: in a pilot even the full window scored 0/5 (floor effect plus a scorer issue with "id1 and id2" answers).
• 3 of the proxy's answers at 64k came back empty: the model kept calling recall after the last allowed round. This is fixed in mnemonic-proxy 0.3.6, but those questions were not rerun. They count as wrong.

Files

results/main-run.jsonl        400 rows: main run (official question), 100 questions x 4 methods
results/confirm-run.jsonl     400 rows: confirmation run (clarified question)
questions-clarified/          the 100 questions with the note (AgentLongBench jsonl format, 4 files, MIT)
logs/<run>.tar.zst            per run and question: result.json, engine_calls.jsonl, calls.jsonl, resources.jsonl;
                              for the proxy also proxy/journal.jsonl, cfg.json and the archive (archive.sqlite)
logs/gpu-blocks/              logs of the GPU blocks that ran each list of questions
scripts/                      the scripts that produced everything (see scripts/README.md)
analysis/                     tables.md, extra.md, diag.md, summary.json, charts/ (confirmation run);
                              analysis/main-run/ (main run); analysis/code/ (analysis scripts)

main-64k / main-128k are the main run; main-clar-64k / main-clar-128k the confirmation run. The analysis files and script comments are in Italian; the numbers above are taken from them and can all be recomputed from the jsonl files.

Columns of results/*.jsonl

column	meaning
run	main or confirm
length	64k or 128k
question_type	Count Frequency(Tool) or Find Duplicates(Tool)
qid, sample_id	AgentLongBench question id and sample id
method	full_window, proxy, summary, truncation
window	context window given to the engine (tokens)
gold, pred_answer, raw_response	official answer, answer parsed by the official parser, raw model text
correct_official, score_official	1 if the official score is 1.0; the official score itself
empty, truncated, finish_reason	empty answer; answer cut by max_tokens; engine finish reason
wall_s	seconds from the start of the method to the answer (for proxy, including the replay)
ttft_answer_s	time to first token of the call that produced the answer
prompt_tokens_total, cached_tokens_total, completion_tokens_total, n_calls	sums over all engine calls for the question
new_prompt_tokens_total	prompt tokens actually computed (prompt − cached; see analysis/code/main_tables.py, new_prompt)
max_tokens, reasoning_budget, summary_max, sampling	generation settings
question	exact text of the final user message sent to the model

Recomputing the headline numbers

import json
from collections import Counter

def load(path):
    return [json.loads(line) for line in open(path)]

for name in ("main-run", "confirm-run"):
    rows = load(f"results/{name}.jsonl")
    print(name, dict(Counter(r["method"] for r in rows if r["correct_official"])))
    by = {}
    for r in rows:
        by.setdefault((r["length"], r["qid"]), {})[r["method"]] = r["correct_official"]
    only_proxy = sum(1 for v in by.values() if v["proxy"] and not v["summary"])
    only_summary = sum(1 for v in by.values() if v["summary"] and not v["proxy"])
    print("  proxy vs summary, discordant:", only_proxy, only_summary)

Expected: main run 51 / 52 / 56 / 44 (full window / proxy / summary / truncation), discordant 13 / 17; confirmation run 69 / 86 / 47 / 49, discordant 44 / 5.

AgentLongBench: attribution and citation

The questions, histories, prompts and scorer are from AgentLongBench (MIT License, Copyright (c) 2026 euReKa025 (SII)): code euReKa025/AgentLongBench, data ign1s/AgentLongBench, paper arXiv:2601.20730. The only change in questions-clarified/ is the sentence appended to each question.

@misc{fang2026agentlongbenchcontrollablelongbenchmark,
      title={AgentLongBench: A Controllable Long Benchmark For Long-Contexts Agents via Environment Rollouts},
      author={Shicheng Fang and Yuxin Wang and XiaoRan Liu and Jiahao Lu and Chuanyuan Tan and Xinchi Chen and Yining Zheng. Xuanjing Huang and Xipeng Qiu},
      year={2026},
      eprint={2601.20730},
      archivePrefix={arXiv},
      primaryClass={cs.CL},
      url={https://arxiv.org/abs/2601.20730},
}

License

MIT, for the data and scripts in this repository. AgentLongBench material keeps its own MIT license (questions-clarified/LICENSE-AgentLongBench).