thinletter/longctx-agent-bench

Long-context agent benchmark: facts, tool calls and rules far back in the context

Does a language model still use information that lies far back in a long conversation? An agent that works for hours gets its tools defined at the start, reads facts somewhere in the middle and is told rules ("don't use grep here, use rg") long before the moment they matter. This benchmark measures exactly that, on real agent transcripts and real text, at 8k and 32k tokens:

config	what the model has to use from far back	language	licence
facts	numbers planted in a long Wikipedia text ("Fiona booked flight 48213."), asked for again thousands of tokens later	English	CC BY-SA 4.0
tool_calls	the definitions of tools and documented commands at the start of an agent session, needed to call them correctly much later	English	CC BY 4.0
rules_en	a policy rule given at the start (system prompt) or in a later user message, which should change what the agent does many turns later	English	CC BY 4.0
rules_cs	the same rules written in Czech (the commands stay the English shell commands)	Czech	CC BY 4.0
rules_de	the same rules written in German	German	CC BY 4.0

Every test is teacher-forced: the model reads the full text once, and its next-token prediction is checked at the target positions. Nothing is generated, so the scores are deterministic up to the model's numerical precision and do not depend on sampling or answer parsing.

Sizes

config	split	items	targets	tokens per item (Qwen3.5 tokenizer)
facts	8k	8	64 queries	8,193
facts	32k	7	56 queries	32,769
tool_calls	8k	16	886 (414 far, 217 of them fresh)	8,193
tool_calls	32k	16	3,244 (2,038 far, 989 of them fresh)	32,769
rules_en / rules_cs / rules_de	8k	82 each	155 each	2 x 8,193 (without / with the rule)
rules_en / rules_cs / rules_de	32k	84 each	605 each	2 x 32,769

The 82 / 84 rule items per language are planted in 16 different agent sessions per length (each session carries several rules, one per item: three rule families, each in the system prompt and in a later user message; items of the same session share their context_id).

What an item looks like

All configs keep the full text the model reads, the target positions as character offsets into that text (usable with any tokenizer) and, for reference, the token ids of the Qwen3.5 tokenizer with which the items were built (qwen_* fields). The agent texts are written in the Qwen3.5 chat format (<|im_start|>system ... <|im_end|>, tool definitions as JSON lines inside <tools>, calls as <tool_call><function=...> blocks), as one long session followed by further documents.

• facts: text; targets[] with answer_char (the span of " 48213." after the query), answer, fact_char / fact (the planted fact sentence), distance_tokens; source (WikiText-103 and the titles of the Wikipedia articles the text comes from).
• tool_calls: text; definitions[] (the tool definition or documented command and its span); targets[] with char (the target token's span), target, kind (name, param, next, command), far, fresh, definition_id, distance_tokens; sources[].
• rules_*: text_without_rule, text_with_rule (the same session with one rule line added), rule, rule_char, family (substitution, redirect, required), placement (system: at the end of the system prompt; user: at the end of a later user message), lang, context_id; targets[] with char_without_rule / char_with_rule (where the governed action starts), expected_text (the first token the rule implies, e.g. " rg"), original_text (what the session actually did, e.g. " grep"), distance_tokens, first, mentioned; sources[].
• sources[] (agent configs): every source dataset in the item's text with its dataset id, revision, license, and the tokens / documents the item takes from it.

A target is far when the fact, tool definition or rule it needs ends 512 or more tokens before it (counted in Qwen3.5 tokens; a fixed parameter of the benchmark). Every rules target is far; distance_tokens gives the exact distance.

Metrics

• facts: query accuracy. A query counts as recalled when every token of the answer (the five-digit number and the final ".") is the model's top-1 prediction. Also reported: token accuracy.
• tool_calls: far accuracy. Top-1 accuracy of the next token at the far targets: the tool's exact name, its parameter names, the token that closes them, which parameter or closing tag comes next, the name of a documented command. fresh targets are far targets of a tool with no earlier call in the 512 tokens before the target (the model cannot copy a recent call); also reported: fresh and near accuracy, mean log-probabilities.
• rules: follow and retained. At each target, score = log p(the rule-implied first token). The effect of the rule is score(with rule) - score(without rule). A reference model decides which targets count: those where its own effect is at least 1 nat in absolute value (the reference reacts to the rule). Over these targets: follow = share of targets where the model's effect is at least half the reference's; retained = sum of the model's effects / sum of the reference's. Reported per placement and family. The reference is typically the original model a compressed, quantized or otherwise modified model was derived from (for the reference itself follow = retained = 1.00); with no reference given, the model is its own reference.

Headline rows as score.py prints them:

row	definition
Facts recalled at 8k / 32k tokens	facts, query accuracy
Distant tool calls at 8k / 32k tokens	tool_calls, far accuracy
Rules followed at 8k / 32k tokens	rules_en, follow, rules in the system prompt, all families
Rules kept far back, worst case (1.00 = as the original)	rules_en, the lowest retained of 12 cells (3 families x 2 placements x 2 lengths)
Czech / German rules kept far back, worst case	rules_cs / rules_de, the same
Rules in Czech / German followed at 32k tokens	rules_cs / rules_de at 32k, follow, system prompt, all families

Running it

score.py (in this repository) needs torch and transformers (pyarrow for the Parquet files) and scores any Hugging Face causal language model that runs in transformers:

# a model on its own
python score.py --model Qwen/Qwen3.5-2B --data thinletter/longctx-agent-bench --out qwen35_2b.json

# a modified model against its original (the reference of the rules configs), saving the reference's scores once
python score.py --model Qwen/Qwen3.5-2B --data ./longctx-agent-bench --sets rules_en,rules_cs,rules_de \
    --save_scores ref_2b.json.gz --out ref.json
python score.py --model my-org/my-compressed-2b --data ./longctx-agent-bench --reference_scores ref_2b.json.gz \
    --out mine.json

# a quick test: the first item per config at 8k
python score.py --model Qwen/Qwen3.5-0.8B --data ./longctx-agent-bench --lengths 8k --limit 1

• --mode auto (default) feeds the stored Qwen3.5 token ids when the model's tokenizer has the same vocabulary (exactly the evaluated sequences), and otherwise tokenizes text with the model's own tokenizer and maps the targets by character offsets (--mode text). A target whose characters do not start at a token boundary of that tokenizer is skipped and counted as unaligned in the output. The rules configs need the model and its reference to use the same tokenization mode.
• The texts use the Qwen3.5 chat markup verbatim. Other model families read it as plain text; their scores are comparable with each other within a family (model vs its reference), less so across families.
• Models that need their own runtime: score_sets(backend, tokenizer, data) takes any object with read(ids, positions, tokens) (the top-1 token and the log-probabilities of given tokens at given positions). ThinCtx models run on the thinctx runtime and are scored with --backend thinctx through its Engine.score: thinctx 1.1 (upcoming) adds Engine.score; thinctx 1.0.x cannot score ThinCtx models teacher-forced.
• Cost: about 12 million tokens of forward passes per model for all configs (the rules configs are most of it), one sequence at a time, at most 32,769 tokens long.
• Output: rows (the headline rows above), sets (every metric per config and length), reference, mode.

Licence

config	licence	why
facts	CC BY-SA 4.0	an adaptation of WikiText-103 (Wikipedia text, CC BY-SA 3.0): ShareAlike
tool_calls, rules_en, rules_cs, rules_de	CC BY 4.0	the choice of texts, the planted rules and the target annotations

The third-party text inside every config stays under the licence of its source (below), which you must also respect: attribution, the licence notices of the code, and the terms its sources name for model outputs.

Sources and licences

facts. Salesforce/wikitext, config wikitext-103-raw-v1, validation split (revision main), licence CC BY-SA 3.0 (and GFDL): text of English Wikipedia articles by Wikipedia contributors, via WikiText-103 (Merity et al., 2016, "Pointer Sentinel Mixture Models"). Each item names its articles in source.articles. Changes: 8 fact sentences and their 8 queries were written over parts of the article text.

tool_calls and rules_*. Agent sessions and documents from the datasets below, rendered in the Qwen3.5 chat format and concatenated; the rules configs add one rule line to the system prompt or to a user message. Each item's sources names the datasets in it.

dataset	revision	licence	content
nebius/SWE-agent-trajectories	68195a1450865274106246d0d0296a1d6807b88e	CC BY 4.0	agent runs on GitHub issues
Kwai-Klear/SWE-smith-mini_swe_agent_plus-trajectories-66k	750b2c11239fd5e32f97e6cfb9bf80fb9a9a2983	MIT	agent runs on SWE-smith repositories
NousResearch/hermes-function-calling-v1 (configs func_calling, json_mode_agentic)	dae3e1d28cfbcf4b915c04ea1e072030529b4bda	Apache-2.0	function-calling conversations
glaiveai/glaive-function-calling-v2	e7f4b6456019f5d8bcb991ef0dd67d8ff23221ac	Apache-2.0	function-calling conversations
minpeter/xlam-function-calling-60k-parsed, a parse of Salesforce/xlam-function-calling-60k (APIGen, Liu et al., 2024)	c6a0d61d66c5ac769c5c8c7de007322fa24f1825	CC BY 4.0	single-turn parallel tool calls
codeparrot/github-code-clean	c48d40f9e70f0196f8236901ee35807f7d6c44c0	Apache-2.0 (dataset card); files used: MIT, Apache-2.0, BSD-2-Clause, BSD-3-Clause, ISC, Unlicense or CC0-1.0	GitHub source files
AmanPriyanshu/random-python-github-repositories	53690024aaa0f56f81700bf504d9d5e16ec81a4d	ODC-By; repositories used: MIT, Apache-2.0, BSD or Unlicense	Python repositories
HuggingFaceFW/fineweb-edu (config sample-10BT)	87f09149ef4734204d70ed1d046ddc9ca3f2b8f9	ODC-By (and the Common Crawl terms of use)	educational web text

• Code excerpts. The source files and repositories come from repositories whose files are licensed MIT, Apache-2.0, BSD-2-Clause, BSD-3-Clause, ISC, Unlicense or CC0-1.0 according to the source datasets' metadata; only such files were used. The repository name stands inside the text before its files (<|repo_name|>owner/name, <|file_sep|>path); the copyright of the code belongs to its authors under those licences.
• Agent sessions. The nebius card states that the licence of each repository an instance is based on must be respected (the repositories' code appears in the sessions' observations) and that users of the model outputs in these trajectories must comply with the Llama 3.1 License. The SWE-smith sessions likewise show code of the repositories they work on.

Attribution: Wikipedia contributors (via WikiText-103, Merity et al. 2016; Salesforce); Nebius (SWE-agent-trajectories); Kwai-Klear (SWE-smith mini-swe-agent-plus trajectories); NousResearch (Hermes function-calling v1); Glaive AI (glaive-function-calling-v2); Salesforce (APIGen / xlam-function-calling-60k) and minpeter (its parse); codeparrot (github-code-clean) and AmanPriyanshu (random-python-github-repositories), and the authors of the GitHub repositories named in the texts; Hugging Face (FineWeb-Edu).

Limitations

• The rule targets are English shell commands in English agent sessions, also in the Czech and German configs: those test rules given in Czech or German, not agents working in those languages.
• Teacher forcing reads the model's belief at each target given the true history; it does not measure whether a generated session would go the same way.
• The rules metrics are relative to a reference model; the absolute effect sizes are reported too (eff, eff_ref).
• 7 to 16 contexts per config and length: differences of a few points are within noise.

Results of models evaluated with this benchmark: https://thinletter.io/thinctx/