sphinx: grounded long-context reasoning archive (12 arXiv papers, 25 verbatim-quote records, falsifiable verify.py)

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/README.md

@@ -0,0 +1,27 @@
+# README — longctx-arxiv-archive
+
+Grounded research archive for the Archive lane (long-context research).
+
+## Contents
+
+- `synthesis.md` — themed synthesis; each evidence record carries a verbatim quote + arXiv source id.
+- `corpus/<id>.txt` — normalized plain text of each paper (single-space collapsed).
+- `manifest.json` — per-paper sha256, char/word counts, retrieval method, title, authors, date.
+- `candidates.json` — mined candidate sentences with stable (source, idx) keys.
+- `claims.json` — operator-written claims keyed by (source, idx); quotes are never hand-typed.
+- `records.json` — flattened evidence records.
+- `verify.py` — independent checker; exit 0 = all quotes verbatim and corpus intact.
+- `falsify_verify.py` — mutation tests: the verifier must exit nonzero on a fabricated quote, a
+  corrupted corpus file, and a missing corpus file (measured: all three exit 1).
+
+## Reproduce
+
+```
+python3 fetch_corpus.py          # arXiv HTML/PDF -> corpus/ + sources.json
+python3 build_archive.py normalize   # collapse whitespace, recompute sha256 -> manifest.json
+python3 mine_quotes.py           # -> candidates.json
+python3 render_synthesis.py      # -> synthesis.md
+python3 verify.py                # exit code is the verdict
+```
+
+Coverage: 12/12 sources cited; 25 records; 964,298 corpus characters.

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/build_archive.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""Build the grounded long-context archive: normalize corpus, pick verbatim
+quote candidates, render the synthesis. Three modes: normalize | pick | render."""
+import hashlib, json, os, re, sys
+
+BASE = "/root/.hermes/wizard-outputs/sphinx/longctx-arxiv-archive-2026-10-20"
+CORPUS = os.path.join(BASE, "corpus")
+
+# Per-source keyword specs: first sentence containing ALL terms (case-insensitive).
+SPECS = {
+    "2507.06261": [("frontier", ["frontier", "long context"], ["gemini 2.5"])],
+    "2501.15089": [("benchmark", ["synthetic", "context expansion"], ["benchmark"])],
+    "2502.13127": [("cot", ["chain-of-thought", "reasoning"], ["supervised"])],
+    "2511.02817": [("aggregation", ["aggregation", "long context"], ["capabilities"])],
+    "2409.02465": [("novels", ["detective", "novels"], ["reasoning"])],
+    "2604.05114": [("structure", ["structure", "reasoning data"], ["improves"])],
+    "2603.20586": [("memory", ["memory-keyed", "attention"], ["efficient"])],
+    "2609.33485": [("disaggregation", ["disaggregation", "grounding"], ["scaling"])],
+    "2512.04307": [("webagents", ["webagent", "long-context"], ["evaluating"])],
+    "2507.06415": [("test-time", ["test-time", "learning"], ["long-context"])],
+    "2505.09561": [("diffusion", ["past-token", "prediction"], ["long-context"])],
+    "2506.02483": [("neurosymbolic", ["neurosymbolic", "reasoning"], ["multilingual"])],
+}
+
+
+def norm(t):
+    t = t.replace("\xa0", " ").replace("\u2019", "'").replace("\u2013", "-").replace("\u2014", "-")
+    t = re.sub(r"\s+", " ", t)
+    return t.strip()
+
+
+def sentences(t):
+    return [s.strip() for s in re.split(r"(?<=[.!?])\s+", t) if s.strip()]
+
+
+def load_corpus():
+    out = {}
+    for fn in sorted(os.listdir(CORPUS)):
+        if fn.endswith(".txt"):
+            with open(os.path.join(CORPUS, fn), encoding="utf-8") as fh:
+                out[fn[:-4]] = fh.read()
+    return out
+
+
+def mode_normalize():
+    meta = json.load(open(os.path.join(BASE, "sources.json")))
+    sources = meta["sources"]
+    manifest = []
+    for s in sources:
+        t = norm(load_corpus()[s["arxiv_id"]])
+        path = os.path.join(CORPUS, s["arxiv_id"] + ".txt")
+        with open(path, "w", encoding="utf-8") as fh:
+            fh.write(t)
+        sha = hashlib.sha256(t.encode()).hexdigest()
+        s.update({"text_sha256": sha, "text_chars": len(t), "text_words": len(t.split())})
+        manifest.append({"arxiv_id": s["arxiv_id"], "title": s["title"], "sha256": sha,
+                         "chars": len(t), "words": len(t.split()), "method": s["method"],
+                         "url": s["source_url"], "published": s["published"],
+                         "authors": s["authors"][:6]})
+    json.dump(manifest, open(os.path.join(BASE, "manifest.json"), "w"), indent=2)
+    json.dump(meta, open(os.path.join(BASE, "sources.json"), "w"), indent=2)
+    print(f"normalized {len(manifest)} sources; total chars {sum(m['chars'] for m in manifest)}")
+
+
+def mode_pick():
+    corpus = load_corpus()
+    pool = []
+    for aid, specs in SPECS.items():
+        if aid not in corpus:
+            print("MISSING source", aid)
+            continue
+        for label, terms, tags in specs:
+            hit = None
+            for s in sentences(corpus[aid]):
+                low = s.lower()
+                if all(t in low for t in terms) and 60 <= len(s) <= 600:
+                    hit = s
+                    break
+            pool.append({"id": f"{aid}::{label}", "arxiv_id": aid, "label": label,
+                         "terms": terms, "quote": hit})
+    json.dump(pool, open(os.path.join(BASE, "quotes_pool.json"), "w"), indent=2)
+    got = sum(1 for p in pool if p["quote"])
+    print(f"picked {got}/{len(pool)} quotes")
+    for p in pool:
+        print(("OK  " if p["quote"] else "MISS") , p["id"], "|", (p["quote"] or "")[:150])
+
+
+def mode_render(claims_path):
+    pool = {p["id"]: p for p in json.load(open(os.path.join(BASE, "quotes_pool.json")))}
+    manifest = json.load(open(os.path.join(BASE, "manifest.json")))
+    by_id = {m["arxiv_id"]: m for m in manifest}
+    claims = json.load(open(claims_path))
+    used = set()
+    recs, skipped = [], []
+    for c in claims:
+        p = pool.get(c["quote_id"])
+        if not p or not p["quote"]:
+            skipped.append(c["quote_id"])
+            continue
+        q = norm(p["quote"])
+        if "\n" in q or len(q) < 60 or len(q) > 600:
+            skipped.append(c["quote_id"])
+            continue
+        m = by_id[p["arxiv_id"]]
+        used.add(p["arxiv_id"])
+        recs.append({"n": len(recs) + 1, "claim": c["claim"], "quote": q,
+                     "arxiv_id": p["arxiv_id"], "label": c.get("label", p["label"]),
+                     "chars": m["chars"], "title": m["title"], "method": m["method"]})
+    json.dump({"records": recs, "skipped": skipped},
+              open(os.path.join(BASE, "records.json"), "w"), indent=2)
+    print(f"rendered {len(recs)} records; skipped={skipped}; sources covered={len(used)}/{len(manifest)}")
+
+
+if __name__ == "__main__":
+    mode = sys.argv[1]
+    if mode == "normalize":
+        mode_normalize()
+    elif mode == "pick":
+        mode_pick()
+    elif mode == "render":
+        mode_render(sys.argv[2])
+    else:
+        raise SystemExit("usage: build_archive.py normalize|pick|render <claims.json>")

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/candidates.json

@@ -0,0 +1,442 @@
+[
+  {
+    "source": "2409.02465",
+    "idx": 0,
+    "quote": "To facilitate this research, we propose DetectiveQA, a dataset specifically designed for narrative reasoning within long contexts."
+  },
+  {
+    "source": "2409.02465",
+    "idx": 1,
+    "quote": "Furthermore, we introduce a step-wise reasoning metric, which enhances the evaluation of LLMs' reasoning processes."
+  },
+  {
+    "source": "2409.02465",
+    "idx": 2,
+    "quote": "Inspired by his words, we propose DetectiveQA, a long-context narrative reasoning dataset with three features."
+  },
+  {
+    "source": "2409.02465",
+    "idx": 3,
+    "quote": "\u2022 We propose DetectiveQA, a human-annotated evaluation of narrative reasoning in long contexts, averaging over 100k tokens, with 1200 questions in English and Chinese, each paired with reference steps, averaging over 8 steps."
+  },
+  {
+    "source": "2409.02465",
+    "idx": 4,
+    "quote": "\u2022 Furthermore, we introduce a step-wise reasoning metric that evaluates the LLM's reasoning process, which evaluates the evidence retrieval capability of long-context LLMs and, more importantly, reflects the logical coherence of their reasoning process."
+  },
+  {
+    "source": "2409.02465",
+    "idx": 5,
+    "quote": "\u2022 We evaluate mainstream LLMs, including GPT-4, Claude, and LLaMA, revealing challenges in long-context reasoning."
+  },
+  {
+    "source": "2409.02465",
+    "idx": 6,
+    "quote": "For long-context reasoning, the most commonly used metrics remain multiple-choice accuracy (Wang et al., 2024) or output matching (Kuratov et al., 2024)."
+  },
+  {
+    "source": "2409.02465",
+    "idx": 7,
+    "quote": "Fortunately, we find a group of detective novels categorized as orthodox school (Saito, 2007), which emphasize logical puzzles and provide readers with the same evidence as the detective, making them suitable for our benchmark."
+  },
+  {
+    "source": "2501.15089",
+    "idx": 0,
+    "quote": "To address this gap and enable a more comprehensive evaluation of the long-context reasoning capabilities of current LLMs, we propose a new synthetic benchmark, LongReason, which is constructed by synthesizing long-context reasoning questions from a varied set of short-context reasoning questions through context expansion."
+  },
+  {
+    "source": "2501.15089",
+    "idx": 1,
+    "quote": "To address these challenges, we introduce a new long-context reasoning benchmark, LongReason, featuring diverse and realistic reasoning tasks to assess the long-context reasoning abilities of LLMs."
+  },
+  {
+    "source": "2501.15089",
+    "idx": 2,
+    "quote": "To assess the current progress in the long-context reasoning abilities of existing LLMs, we evaluated 21 models of varying scales and architectures, sourced from both open-source and closed-source communities."
+  },
+  {
+    "source": "2501.15089",
+    "idx": 3,
+    "quote": "Consequently, state-of-the-art language models [openai2024gpt4o, openai2024gpt4omini, reid2024gemini, anthropic2024claud35sonnet, llama3-1, mistrallarge2, qwen2.5, glm4] now support context windows ranging from 128K to millions of tokens, enabling the exploration of reasoning abilities over extensive contexts with LLMs."
+  },
+  {
+    "source": "2501.15089",
+    "idx": 4,
+    "quote": "For each question, we evaluate multiple versions of the synthesized question for comparison, including the original question QshortQ_{\\text{short}}, the expanded version QexpandedQ_{\\text{expanded}}, and long-context versions with context lengths ranging from 8\u200bK8K to 128\u200bK128K."
+  },
+  {
+    "source": "2501.15089",
+    "idx": 5,
+    "quote": "Evaluation setup We evaluate all models on LongReason, which comprises 794 questions, each featuring multiple variations, including the original version, expanded versions, and long-context versions with context lengths of 8K, 16K, 32K, 64K, and 128K."
+  },
+  {
+    "source": "2501.15089",
+    "idx": 6,
+    "quote": "For long-context reasoning performance, Gemini-1.5 Pro outperforms all other closed-source models, exhibiting negligible performance drop when extending the context length from 8K to 128K."
+  },
+  {
+    "source": "2501.15089",
+    "idx": 7,
+    "quote": "Additionally, we observe that for these problem types, Claude 3.5 shows much lower performance when the clues are distributed separately throughout the context, compared to when the clues are grouped together."
+  },
+  {
+    "source": "2502.13127",
+    "idx": 0,
+    "quote": "To achieve this, we introduce LongFinanceQA, a synthetic dataset in the financial domain designed to improve long-context reasoning."
+  },
+  {
+    "source": "2502.13127",
+    "idx": 1,
+    "quote": "Unlike existing long-context synthetic data, LongFinanceQA includes intermediate CoT reasoning before the final conclusion, which encourages LLMs to perform explicit reasoning, improving accuracy and interpretability in long-context understanding."
+  },
+  {
+    "source": "2502.13127",
+    "idx": 2,
+    "quote": "To generate synthetic CoT reasoning, we propose Property-based Agentic Inference (PAI), an agentic framework that simulates human-like reasoning steps, including property extraction, retrieval, and summarization."
+  },
+  {
+    "source": "2502.13127",
+    "idx": 3,
+    "quote": "To validate this hypothesis, we introduce LongFinanceQA, a novel long-context synthetic dataset constructed using financial data."
+  },
+  {
+    "source": "2502.13127",
+    "idx": 4,
+    "quote": "To generate reliable reasoning-augmented answers, we propose Property-based Agentic Inference (PAI), a comprehensive agentic framework."
+  },
+  {
+    "source": "2502.13127",
+    "idx": 5,
+    "quote": "Following this methodology, we propose the Property-based Agentic Inference (PAI) framework, illustrated in Figure 2, containing three steps: (1) property extraction, (2) property-based retrieval, and (3) summarization."
+  },
+  {
+    "source": "2502.13127",
+    "idx": 6,
+    "quote": "For evaluation, Loong employs GPT-4-Turbo as a judge, scoring model responses based on accuracy, hallucinations, and completeness on a scale of 0 to 100."
+  },
+  {
+    "source": "2502.13127",
+    "idx": 7,
+    "quote": "To assess the quality of these synthetic answers, we evaluate the annotator, PAI, on the Long benchmark, using GPT-4o-mini as the agent within the PAI, referred to as GPT-4o-mini w/ PAI."
+  },
+  {
+    "source": "2505.09561",
+    "idx": 0,
+    "quote": "As context length increases, training becomes increasingly expensive due to rising memory demands, and policy performance often degrades as a result of spurious correlations."
+  },
+  {
+    "source": "2505.09561",
+    "idx": 1,
+    "quote": "To address this, we introduce Past-Token Prediction (PTP), an auxiliary task in which the policy learns to predict past action tokens alongside future ones."
+  },
+  {
+    "source": "2505.09561",
+    "idx": 2,
+    "quote": "Policies that latch onto such information may diverge from expert behavior during deployment, leading to performance degradation [10, 34]."
+  },
+  {
+    "source": "2505.09561",
+    "idx": 3,
+    "quote": "In this paper, we introduce a simple and effective approach for learning long-context robot policies, illustrated in Fig."
+  },
+  {
+    "source": "2505.09561",
+    "idx": 4,
+    "quote": "Crucially, we find that the benefits of PTP primarily emerge in the policy head for sequence modeling, rather than the visual encoder."
+  },
+  {
+    "source": "2505.09561",
+    "idx": 5,
+    "quote": "Building upon this analysis, we introduce a multi-stage training recipe: first, pre-train the visual encoder in a short-context setting, where the policy learns to predict a chunk of future actions from only a few past frames [47, 8], and subsequently fine-tune a long-context decoder that jointly predicts past and future actions from precomputed image embeddings."
+  },
+  {
+    "source": "2505.09561",
+    "idx": 6,
+    "quote": "Notably, recent works [8, 48] have empirically found that image-conditioned specialist and generalist policies degrade with history, leading many works to exclude history altogether [37, 4, 6, 47, 14, 38, 17]."
+  },
+  {
+    "source": "2505.09561",
+    "idx": 7,
+    "quote": "To this end, we evaluate our method on the modern diffusion-based policy [8], in comparison with the classical regression-based policy."
+  },
+  {
+    "source": "2506.02483",
+    "idx": 0,
+    "quote": "To address this challenge, we introduce NeuroSymbolic Augmented Reasoning (NSAR), which combines the benefits of neural and symbolic reasoning during inference."
+  },
+  {
+    "source": "2506.02483",
+    "idx": 1,
+    "quote": "Our results highlight the effectiveness of combining explicit symbolic operations with neural inference for robust, interpretable, and scalable reasoning in multilingual settings."
+  },
+  {
+    "source": "2506.02483",
+    "idx": 2,
+    "quote": "By integrating symbolic logic into a retrieval-based framework, NSAR improves interpretability, consistency, and accuracy when working with multilingual and long-context data."
+  },
+  {
+    "source": "2506.02483",
+    "idx": 3,
+    "quote": "\u2022 We show that combining Chain of Thought (CoT), ReAct, and Self-Reflection prompting strategies with neurosymbolic reasoning leads to further performance gains."
+  },
+  {
+    "source": "2506.02483",
+    "idx": 4,
+    "quote": "\u2022 Through extensive experiments on cross-lingual, long-context tasks, we demonstrate that NSAR substantially outperforms purely retrieval-based and neural-only methods."
+  },
+  {
+    "source": "2506.02483",
+    "idx": 5,
+    "quote": "Hybrid systems like LINC (Olausson et al., 2023) and PAL (Gao et al., 2023) produce executable code, improving transparency and accuracy."
+  },
+  {
+    "source": "2506.02483",
+    "idx": 6,
+    "quote": "Context length From the results presented in Figure 2, we observe that both GPT-4o-mini and Llama 3.2 exhibit declining accuracy as context length increases in LLM only (solid lines) scenario, with accuracy dropping to almost 0% as context lengths reach 128K words."
+  },
+  {
+    "source": "2506.02483",
+    "idx": 7,
+    "quote": "We observe that RAG-Vanilla consistently outperforms the LLM-only baseline across all tested languages, including those with non-Latin scripts such as Persian, Russian, Hindi, and Arabic."
+  },
+  {
+    "source": "2507.06261",
+    "idx": 0,
+    "quote": "Gemini Team Google Abstract In this report, we introduce the Gemini 2.X model family: Gemini 2.5 Pro and Gemini 2.5 Flash, as well as our earlier Gemini 2.0 Flash and Flash-Lite models."
+  },
+  {
+    "source": "2507.06261",
+    "idx": 1,
+    "quote": "While this still increases training data throughput and storage demands by a factor of k, we find this to be a worthwhile trade-off given the significant quality improvement distillation has on our smaller models, leading to high-quality models with a reduced serving cost (see Figure 2)."
+  },
+  {
+    "source": "2507.06261",
+    "idx": 2,
+    "quote": "The model has learned to use search and other tools, reason about the outputs, and issue additional, detailed follow-up queries to expand the information available to it and to verify the factual accuracy of the response."
+  },
+  {
+    "source": "2507.06261",
+    "idx": 3,
+    "quote": "These models exhibit state-of-the-art performance across a suite of factuality benchmarks, including SimpleQA for parametric knowledge (Wei et al., 2024), FACTS Grounding for faithfulness to provided documents (Jacovi et al., 2024; Jacovi et al., 2025), and the Vectara Hallucination Leaderboard (Hughes et al., 2023), cementing Gemini as the model of choice for information-seeking demands."
+  },
+  {
+    "source": "2507.06261",
+    "idx": 4,
+    "quote": "Deep Think enables Gemini to creatively produce multiple hypotheses and carefully critique them before arriving at the final answer, achieving state-of-the-art performances in challenging benchmarks such as Olympiad math (USAMO 2025), competitive coding (LiveCodeBench), and multimodality (MMMU), see more details at (Doshi, 2025b)."
+  },
+  {
+    "source": "2507.06261",
+    "idx": 5,
+    "quote": "Audio Understanding In Table 5, we showcase the performance of the Gemini 2.5 model family at audio understanding, and compare the performance of these models to earlier Gemini models, as well as to GPT models."
+  },
+  {
+    "source": "2507.06261",
+    "idx": 6,
+    "quote": "As can be seen, Gemini 2.5 Pro achieves state-of-the-art performance on key video understanding benchmarks, surpassing recent models like GPT 4.1 under comparable testing conditions (same prompt and video frames)."
+  },
+  {
+    "source": "2507.06261",
+    "idx": 7,
+    "quote": "Performance is measured by string-match accuracy for multiple-choice VideoQA, LLM-based accuracy for open-ended VideoQA, R1@0.5 for moment retrieval and CIDEr for captioning."
+  },
+  {
+    "source": "2507.06415",
+    "idx": 0,
+    "quote": "In this work, we propose PERK (Parameter Efficient Reasoning over Knowledge), a scalable approach for learning to encode long contexts using gradient updates at test time."
+  },
+  {
+    "source": "2507.06415",
+    "idx": 1,
+    "quote": "These challenges arise because longer contexts contain more irrelevant distractor information, and may also be attached to more complex reasoning problems (i.e., multiple hops), both of which degrade LLM performance (Chen et al., 2023b)."
+  },
+  {
+    "source": "2507.06415",
+    "idx": 2,
+    "quote": "In this work, we address these challenges of long-context reasoning by reframing it as test-time learning, enabling models to encode context at inference time using gradient-based parameter adaptation."
+  },
+  {
+    "source": "2507.06415",
+    "idx": 3,
+    "quote": "PERK also outperforms specialized long-context LLMs (Gao et al., 2025a; Yang et al., 2025) with over 7B parameters that have undergone extensive long-context training, achieving the highest accuracy when generalizing to contexts up to 128k tokens."
+  },
+  {
+    "source": "2507.06415",
+    "idx": 4,
+    "quote": "In these settings, PERK models again outperform the FT-ICR baselines, and even surpass commercial LLMs (e.g., GPT, Gemini) on benchmarks for long-context symbolic reasoning."
+  },
+  {
+    "source": "2507.06415",
+    "idx": 5,
+    "quote": "PERK trained on 8K-token contexts maintains decent performance on 64K and 128K windows, consistently surpassing FT-ICR length generalization, and even outperforming models with native 512K and 1M context windows."
+  },
+  {
+    "source": "2507.06415",
+    "idx": 6,
+    "quote": "(5) 4 Experiments We empirically evaluate PERK's long-context reasoning performance in three scenarios: reasoning over (1) Needles-in-a-Haystack (NIAH, Kuratov et al., 2024), (2) Open-domain, multi-document QA (Multi-Doc), and (3) Drops-in-an-Ocean (DIO), a novel long-context evaluation setting we propose."
+  },
+  {
+    "source": "2507.06415",
+    "idx": 7,
+    "quote": "To address NIAH's fundamental limitation, where target information is stylistically distinct from distractors and thus artificially simpler to identify, we evaluate in two additional settings."
+  },
+  {
+    "source": "2511.02817",
+    "idx": 0,
+    "quote": "(2024), inter alia), we find that models struggle with information aggregation as the input length grows."
+  },
+  {
+    "source": "2511.02817",
+    "idx": 1,
+    "quote": "75.7% of traces end in an incomplete sentence.66 6 Note that in some cases, the model provides a candidate answer, then begins to double-check the answer and then exceeds the maximum output length; we evaluate the last candidate answer we are able to parse."
+  },
+  {
+    "source": "2511.02817",
+    "idx": 2,
+    "quote": "We observe that both models, and especially Gemini 2.5 Pro, increasingly exceeds its maximum output length during reasoning for long Oolong-synth inputs."
+  },
+  {
+    "source": "2511.02817",
+    "idx": 3,
+    "quote": "This is because GPT 5.2 is much more likely to refuse to perform the task; at 256K, GPT-5 attempts 83% of queries and answers 44.5% of these correctly, while GPT-5.2 attempts only 32% with an accuracy of 52.8%."
+  },
+  {
+    "source": "2511.02817",
+    "idx": 4,
+    "quote": "As expected, adding labels improves accuracy; however, this improvement ranges from 10.9 points to only 0.79 points."
+  },
+  {
+    "source": "2511.02817",
+    "idx": 5,
+    "quote": "Additionally, we show complex discussions surrounding dice rolls (Figure 13, Figure 15) and damage calculation (Figure 14)."
+  },
+  {
+    "source": "2512.04307",
+    "idx": 0,
+    "quote": "Through extensive evaluation of four popular models, Claude-3.7, GPT-4.1, Llama 4, and o4-mini, we observe a dramatic performance degradation as context length increases, with success rates dropping from 40-50% in baseline conditions to less than 10% in long context scenarios."
+  },
+  {
+    "source": "2512.04307",
+    "idx": 1,
+    "quote": "Please ensure the accuracy of your output, as we will execute subsequent steps based on the \u2018action\u2018, \u2018action_input\u2018 and \u2018element_id\u2018 you provide."
+  },
+  {
+    "source": "2603.20586",
+    "idx": 0,
+    "quote": "We propose Memory-Keyed Attention (MKA), a hierarchical attention mechanism that integrates multi-level KV caches-local, session, and long-term-and learns to route attention across them dynamically."
+  },
+  {
+    "source": "2603.20586",
+    "idx": 1,
+    "quote": "In this paper, we propose Memory-Keyed Attention (MKA), a novel attention mechanism that hierarchically organizes memory into three levels-local (L1), session (L2), and long-term (L3)-and dynamically learns how to route each query token across these sources."
+  },
+  {
+    "source": "2603.20586",
+    "idx": 2,
+    "quote": "\u2022 We introduce Memory-Keyed Attention (MKA), a dynamic routing mechanism across local, session, and long-term memory with hardware-friendly implementations, we further accelerate MKA training and inference by designing broadcast routing (FastMKA)."
+  },
+  {
+    "source": "2603.20586",
+    "idx": 3,
+    "quote": "Our approach supports query-dependent access, soft selection (via learned weights), and slot reuse-achieving high memory efficiency without sacrificing accuracy."
+  },
+  {
+    "source": "2603.20586",
+    "idx": 4,
+    "quote": "To alleviate this, we propose Route-Fused MKA (FastMKA), a simplified yet effective variant that performs route-fusion-a token-wise soft fusion of hierarchical memory levels before attention-thereby avoiding multiple attention paths and significantly reducing runtime cost."
+  },
+  {
+    "source": "2603.20586",
+    "idx": 5,
+    "quote": "Long-Context Benchmark Evaluation To validate MKA's effectiveness on long-context reasoning tasks, we evaluate on LongBench (Bai et al., 2024) and RULER (Sun et al., 2024) benchmarks, which test various long-context capabilities including QA, summarization, and long-distance retrieval."
+  },
+  {
+    "source": "2603.20586",
+    "idx": 6,
+    "quote": "To address this, we propose Route-Fused MKA (FastMKA), a route-fusion variant that fuses memory levels before attention computation."
+  },
+  {
+    "source": "2603.20586",
+    "idx": 7,
+    "quote": "It offers a practical balance between accuracy, latency, and memory usage, and serves as a strong drop-in replacement for traditional attention in long-context scenarios."
+  },
+  {
+    "source": "2604.05114",
+    "idx": 0,
+    "quote": "Through deeper analyses, we observe that reasoning style contributes little, while faithful reasoning patterns discovered by back translation and grounded realistic long context, as \u03c02\\pi^{2} is designed for, are crucial for the improvement."
+  },
+  {
+    "source": "2604.05114",
+    "idx": 1,
+    "quote": "We observe that structured representations, such as tables, is a natural medium that bridges complex reasoning and real long-context open-domain data, in which the data construction and verification are otherwise difficult."
+  },
+  {
+    "source": "2604.05114",
+    "idx": 2,
+    "quote": "Through deeper analyses, we observe that reasoning style contributes little, while faithful reasoning patterns discovered by back translation and grounded realistic long context are crucial for the improvement."
+  },
+  {
+    "source": "2604.05114",
+    "idx": 3,
+    "quote": "Finally, by the direct comparison with a previous long-context reasoning dataset, we show that \u03c02\\pi^{2} closes the gap between previous works and real-world demands."
+  },
+  {
+    "source": "2604.05114",
+    "idx": 4,
+    "quote": "Our contributions are as follows: \u2219\\bullet We propose \u03c02\\pi^{2}, a QA curation pipeline that leverages tables as structured intermediate representations to generate verifiable, long-context, complex reasoning data across domains (\u00a72)."
+  },
+  {
+    "source": "2604.05114",
+    "idx": 5,
+    "quote": "For reasoning traces generation, as we observed different reasoning \"styles\" of models from different families, we adaptively select the teacher model according to the target student model."
+  },
+  {
+    "source": "2604.05114",
+    "idx": 6,
+    "quote": "We evaluate our models and baselines on in-domain benchmarks LongSeal, OfficeQA, and our \u03c02\\pi^{2}-Bench; as well as out-of-domain benchmarks LongBenchV2 and Oolong."
+  },
+  {
+    "source": "2604.05114",
+    "idx": 7,
+    "quote": "Notably, we use the provided LLM grader (with backbone gpt-oss-120b) to report the accuracy on \u03c02\\pi^{2}-Bench and LongSeal, while for others, we report scores from the deterministic graders."
+  },
+  {
+    "source": "2609.33485",
+    "idx": 0,
+    "quote": "Furthermore, it outperforms full-context models by up to 9.8 points on LongBench v2 and matches frontier models like Gemini-3-Pro-Preview while reducing inference costs by over 80%, establishing a highly efficient paradigm for robust long-context inference."
+  },
+  {
+    "source": "2609.33485",
+    "idx": 1,
+    "quote": "Conversely, sequential multi-agent workflows (Zhang et al., 2024b; Qian et al., 2024; Zhao et al., 2024; Zhou et al., 2024) apply full LLM-grade understanding to each chunk, but process them serially---incurring linear latency and fragile cross-step state management that degrades over multiple hops."
+  },
+  {
+    "source": "2609.33485",
+    "idx": 2,
+    "quote": "To realize this disaggregation, we introduce DIStributed long COntext scaling (DISCO), an architecture directly inspired by distributed computing frameworks like Apache Spark (Zaharia et al., 2010; Zaharia et al., 2016)."
+  },
+  {
+    "source": "2609.33485",
+    "idx": 3,
+    "quote": "Experimental results demonstrate that DISCO effectively eliminates context rot: on RULER-QA (1M tokens), DISCO with Qwen3-8B (Qwen, 2025) maintains 78.4% accuracy while standard retrieval baselines collapse to 10.9%."
+  },
+  {
+    "source": "2609.33485",
+    "idx": 4,
+    "quote": "On reasoning-intensive benchmarks, it outperforms Full Long Context baselines by up to 9.8 points (Qwen3-14B) on LongBench v2 (Long subset), with RL tuning further amplifying gains."
+  },
+  {
+    "source": "2609.33485",
+    "idx": 5,
+    "quote": "This coupling creates a critical bottleneck: as LL grows, the complexity of the grounding term P\u0398\u200b(\ud835\udc9b\u2223\ud835\udc99,q)P_{\\Theta}(\\bm{z}\\!\\mid\\!\\bm{x},q) degrades rapidly due to architectural limitations (e.g., context rot and the \u201clost-in-the-middle\u201d phenomenon), where attention mechanisms fail to distinguish signal from noise."
+  },
+  {
+    "source": "2609.33485",
+    "idx": 6,
+    "quote": "To circumvent the limitations of directly modeling the full sequence, we introduce Distributed Context Scaling (DISCO), a paradigm that structurally decouples contextual grounding via context partitioning."
+  },
+  {
+    "source": "2609.33485",
+    "idx": 7,
+    "quote": "(7) The Accuracy Reward Racc\u2208{0,1}R_{\\text{acc}}\\in\\{0,1\\} evaluates the correctness of the final response \ud835\udc9a{\\bm{y}} against the ground truth."
+  }
+]

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/claims.json

@@ -0,0 +1,54 @@
+{
+  "sections": [
+    {
+      "title": "1. The core finding: reasoning degrades as context grows",
+      "records": [
+        {"source": "2512.04307", "idx": 0, "label": "webagent-degradation", "claim": "Four popular agentic models lose almost all success once context grows: success falls from 40-50% in baseline conditions to under 10% in long-context scenarios."},
+        {"source": "2511.02817", "idx": 0, "label": "aggregation-struggle", "claim": "Frontier models themselves struggle specifically at information aggregation as input length grows."},
+        {"source": "2501.15089", "idx": 7, "label": "distributed-clues", "claim": "Performance depends on where the evidence sits: Claude 3.5 is much weaker when clues are spread through the context than when they are grouped together."},
+        {"source": "2506.02483", "idx": 6, "label": "near-zero-accuracy", "claim": "Without retrieval support, LLM-only accuracy on long multilingual context falls to almost 0% at 128K words for both GPT-4o-mini and Llama 3.2."},
+        {"source": "2501.15089", "idx": 6, "label": "flat-model", "claim": "Not every model degrades: Gemini-1.5 Pro shows negligible drop from 8K to 128K and outperforms other closed-source models on this axis."}
+      ]
+    },
+    {
+      "title": "2. Why it degrades: distractors, spurious correlation, lost-in-the-middle",
+      "records": [
+        {"source": "2507.06415", "idx": 1, "label": "distractors", "claim": "PERK attributes the degradation to two causes: more irrelevant distractor information in longer contexts and more complex multi-hop reasoning problems."},
+        {"source": "2609.33485", "idx": 5, "label": "context-rot", "claim": "DISCO names the failure mode 'context rot' and ties it to the lost-in-the-middle phenomenon, where attention cannot separate signal from noise as sequence length grows."},
+        {"source": "2505.09561", "idx": 0, "label": "spurious-correlation", "claim": "In robot policy learning, longer context raises memory cost and degrades performance through spurious correlations the policy latches onto."},
+        {"source": "2505.09561", "idx": 4, "label": "where-ptp-helps", "claim": "The benefit of Past-Token Prediction concentrates in the policy head that does sequence modelling, not in the visual encoder."}
+      ]
+    },
+    {
+      "title": "3. Benchmarks and datasets built to measure this",
+      "records": [
+        {"source": "2409.02465", "idx": 3, "label": "detectiveqa-size", "claim": "DetectiveQA scales narrative long-context reasoning to over 100k tokens per instance, 1200 English and Chinese questions, each with about 8 reference reasoning steps."},
+        {"source": "2501.15089", "idx": 0, "label": "longreason-construction", "claim": "LongReason synthesizes long-context reasoning questions by context expansion of short-context reasoning questions, giving controlled 8K-128K variants."},
+        {"source": "2502.13127", "idx": 1, "label": "cot-in-synthetic-data", "claim": "LongFinanceQA embeds intermediate chain-of-thought reasoning before the final answer, which the authors argue improves accuracy and interpretability."},
+        {"source": "2604.05114", "idx": 2, "label": "what-actually-helps", "claim": "Ablation in pi-squared shows reasoning style contributes little, while faithful reasoning patterns from back translation and grounded realistic long context are what matter."},
+        {"source": "2604.05114", "idx": 4, "label": "table-pipeline", "claim": "The pi-squared pipeline uses tables as structured intermediate representations to produce verifiable long-context reasoning data across domains."}
+      ]
+    },
+    {
+      "title": "4. Architectural and training fixes",
+      "records": [
+        {"source": "2507.06415", "idx": 2, "label": "test-time-learning", "claim": "PERK reframes long-context reasoning as test-time learning: the model encodes the context at inference time via gradient-based parameter adaptation."},
+        {"source": "2507.06415", "idx": 5, "label": "length-generalization", "claim": "A model trained on 8K contexts keeps working at 64K and 128K and beats models with native 512K and 1M context windows."},
+        {"source": "2603.20586", "idx": 1, "label": "mka-routing", "claim": "Memory-Keyed Attention splits memory into local, session and long-term levels and learns to route each query token across them."},
+        {"source": "2505.09561", "idx": 1, "label": "past-token-prediction", "claim": "Past-Token Prediction adds an auxiliary task in which the policy predicts past action tokens as well as future ones."},
+        {"source": "2506.02483", "idx": 4, "label": "neurosymbolic", "claim": "NSAR combines symbolic logic with neural inference and substantially outperforms purely retrieval-based and neural-only methods on cross-lingual long-context tasks."},
+        {"source": "2609.33485", "idx": 3, "label": "disco-rot-fix", "claim": "On RULER-QA at 1M tokens, DISCO holds 78.4% accuracy while standard retrieval baselines collapse to 10.9%, i.e. it removes the context-rot penalty."}
+      ]
+    },
+    {
+      "title": "5. Cost, serving, and model behaviour at scale",
+      "records": [
+        {"source": "2609.33485", "idx": 0, "label": "disco-cost", "claim": "DISCO beats full-context models by up to 9.8 points on LongBench v2 while cutting inference cost by over 80%."},
+        {"source": "2511.02817", "idx": 3, "label": "refusal-behaviour", "claim": "Model behaviour changes with length: at 256K GPT-5 attempts 83% of queries and answers 44.5% correctly, while GPT-5.2 attempts only 32% with 52.8% accuracy on those attempts."},
+        {"source": "2507.06261", "idx": 4, "label": "gemini-deepthink", "claim": "Gemini 2.5's Deep Think mode reaches state-of-the-art results on Olympiad math (USAMO 2025), competitive coding (LiveCodeBench) and multimodality (MMMU)."},
+        {"source": "2507.06261", "idx": 3, "label": "gemini-factuality", "claim": "Gemini 2.5 is reported at state-of-the-art on factuality suites including SimpleQA, FACTS Grounding and the Vectara Hallucination Leaderboard."},
+        {"source": "2502.13127", "idx": 5, "label": "pai-pipeline", "claim": "The PAI framework generates reasoning-augmented answers in three steps: property extraction, property-based retrieval, and summarization."}
+      ]
+    }
+  ]
+}

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/corpus/2409.02465.txt

@@ -0,0 +1 @@
+Report GitHub Issue × Title: Content selection saved. Describe the issue below: Description: Submit without GitHub Submit in GitHub arXiv is now an independent nonprofit! Learn more × Back to arXiv Why HTML? Report Issue Back to Abstract Download PDF Abstract 1 Introduction 2 Related Work Long-Context Reasoning Reasoning Metrics 3 Creating DetectiveQA 3.1 Data Source 3.2 Data Annotation 4 Evaluating with DetectiveQA 4.1 Metric Settings Multiple-Choice Accuracy Step-wise Reasoning Metric 4.2 Context Settings 5 Experiment 5.1 Validation Results Statistics. Validation on data annotations. Validation on metrics. 5.2 Evaluation Results Models. Main results. Analysis on data contamination. 5.3 Identifying Performance Bottlenecks by Ablating Long Context and Reasoning 5.3.1 Analysis on evidence retrieval over long context. 5.3.2 Analysis on reasoning capability. 6 Conclusion References A Annotation Guideline Data format. Annotation procedure. Agent Workflow B Details in Reasoning Metric C More Validation Results Depth Distribution D More Evaluation Results License: arXiv.org perpetual non-exclusive license arXiv:2409.02465v2 [cs.CL] 14 Mar 2025 DetectiveQA: Evaluating Long-Context Reasoning on Detective Novels Zhe Xu ††thanks: Equal contribution. Affiliation: School of Computer Science, Fudan University Email: zxu24@m.fudan.edu.cn Jiasheng Ye11footnotemark: 1 Affiliation: School of Computer Science, Fudan University Email: jsye23@m.fudan.edu.cn Xiaoran Liu11footnotemark: 1 Affiliation: School of Computer Science, Fudan University Email: xrliu24@m.fudan.edu.cn Xiangyang Liu11footnotemark: 1 Affiliation: School of Computer Science, Fudan University Tianxiang Sun Affiliation: School of Computer Science, Fudan University Zhigeng Liu Affiliation: School of Computer Science, Fudan University Qipeng Guo Affiliation: Shanghai AI Laboratory Linlin Li Affiliation: Huawei Noah's Ark Lab Qun Liu Affiliation: Huawei Noah's Ark Lab Xuanjing Huang Affiliation: School of Computer Science, Fudan University Xipeng Qiu ††thanks: Corresponding author. Affiliation: School of Computer Science, Fudan University Affiliation: Shanghai AI Laboratory Abstract Recently, significant efforts have been devoted to enhancing the long-context capabilities of Large Language Models (LLMs), particularly in long-context reasoning. To facilitate this research, we propose DetectiveQA, a dataset specifically designed for narrative reasoning within long contexts. We leverage detective novels, averaging over 100k tokens, to create a dataset containing 1200 human-annotated questions in both Chinese and English, each paired with corresponding reference reasoning steps. Furthermore, we introduce a step-wise reasoning metric, which enhances the evaluation of LLMs' reasoning processes. We validate our approach and evaluate the mainstream LLMs, including GPT-4, Claude, and LLaMA, revealing persistent long-context reasoning challenges and demonstrating their evidence-retrieval challenges. Our findings offer valuable insights into the study of long-context reasoning and lay the base for more rigorous evaluations. The evaluation code are publicly accessible via our GitHub repository 1 Introduction The long-context capabilities of Large Language Models (LLMs) (OpenAI, 2023; Anthropic, 2024a; Touvron et al., 2023; Sun et al., 2024; Bai et al., 2023a; Cai et al., 2024; Zeng et al., 2023b), particularly long-context reasoning(Kociský et al., 2018; Sprague et al., 2024; Wang et al., 2024; Karpinska et al., 2024), are a key competitive advantage in the current landscape. Recently, OpenAI released the O1 model (OpenAI, 2024), which not only supports a context length of 128k but can also generate extensive reasoning chains, effectively solving complex reasoning problems in intricate scenarios. As the long-context reasoning capabilities of LLMs improve, there is a growing demand for more challenging and realistic long-context reasoning evaluations(Sprague et al., 2024; Kuratov et al., 2024; Zhang et al., 2024; Wang et al., 2024; Karpinska et al., 2024). Among these, narrative reasoning based on detective novels provides a sufficiently realistic and challenging setting(Sprague et al., 2024; Gu et al., 2024). As Ilya, the core developer of GPT-4, has stated, if LLMs possess real understanding when presented with a detective novel with a complicated plot, a storyline, different characters, numerous events, and mysteries like clues, LLMs should be able to predict who commits the crime at the last page of the book based on the context11 1 Ilya Sutskever - GPT4 predicts the next word better - Now upgraded to the more powerful GPT4o https://www.youtube.com/watch?v=1OsHC1vbpc0. Inspired by his words, we propose DetectiveQA, a long-context narrative reasoning dataset with three features. First, DetectiveQA provides detailed annotation information. The dataset includes 1200 reasoning questions from English and Chinese detective novels, with an average length exceeding 100Line truncated

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/corpus/2501.15089.txt

@@ -0,0 +1 @@
+1 Introduction 2 Related Work 3 Our Benchmark: LongReason 3.1 Long-context Reasoning Question Construction via Context Expansion 3.2 The Statistics of LongReason 4 Exerperiments & Results 4.1 Experimental setup 4.2 Main Results 4.3 Further Analysis 5 Conclusion and Limitations 6 Model Information 7 Hyperparameters for LongReason Construction 8 Human Annotator 9 Prompts 1]ByteDance Seed 2]UC San Diego 3]University of Illinois Urbana-Champaign \contribution[*]Work done at ByteDance Seed \contribution[†]Corresponding authors LongReason: A Synthetic Long-Context Reasoning Benchmark via Context Expansion Zhan Ling Kang Liu Kai Yan Yifan Yang Weijian Lin Ting-Han Fan Lingfeng Shen Zhengyin Du Jiecao Chen [ [ [ z6ling@ucsd.edu jiecao.chen@bytedance.com (November 17, 2025) Abstract Large language models (LLMs) have demonstrated remarkable progress in understanding long-context inputs. However, benchmarks for evaluating the long-context reasoning abilities of LLMs fall behind the pace. Existing benchmarks often focus on a narrow range of tasks or those that do not demand complex reasoning. To address this gap and enable a more comprehensive evaluation of the long-context reasoning capabilities of current LLMs, we propose a new synthetic benchmark, LongReason, which is constructed by synthesizing long-context reasoning questions from a varied set of short-context reasoning questions through context expansion. LongReason consists of 794 multiple-choice reasoning questions with diverse reasoning patterns across three task categories: reading comprehension, logical inference, and mathematical word problems. We evaluate 21 LLMs on LongReason, revealing that most models experience significant performance drops as context length increases. Our further analysis shows that even state-of-the-art LLMs still have significant room for improvement in providing robust reasoning across different tasks. We have open-sourced LongReason to support the comprehensive evaluation of LLMs' long-context reasoning capabilities. \correspondence Zhan Ling at , Jiecao Chen at \checkdata[Dataset]https://huggingface.co/datasets/lz1bytedance/LongReason 1 Introduction Benchmark Avg Len Light Human Effort Realistic Tasks Broad Tasks Controllable Context ZeroSCROLLS [zeroscrolls] ∼\sim10K ✗ ✓ ✓ ✗ L-Eval [leval] ∼\sim8K ✗ ✓ ✓ ✗ BAMBOO [dong2023bamboo] ∼\sim16K ✗ ✓ ✓ ✗ LongBench [bai2023longbench] ∼\sim8K ✗ ✓ ✓ ✗ LooGLE [li2023loogle] ∼\sim20K ✗ ✓ ✓ ✗ InfiniteBench [zhang2024infty] ∼\sim200K ✗ ✓ ✓ ✗ Loong [wang2024leave] ∼\sim250K ✗ ✓ ✓ ✗ Needle-in-a-haystack [needleinhaystack] any ✓ ✗ ✗ ✓ RULER [hsieh2024ruler] any ✓ ✗ ✓ ✓ LongReason (Ours) any ✓ ✓ ✓ ✓ Table 1: Comparison of LongReason with other long-context benchmarks. LongReason offers controllable context lengths and incorporating diverse and realistic tasks without the need for human annotation on long text. In recent years, large language models (LLMs) [openai2023gpt4, gemini, claude3, llama3-1, mistral, qwen2.5] have demonstrated remarkable advances in diverse natural language processing tasks. The ability to comprehend and reason over long inputs is essential for downstream applications, including multi-turn conversations [tan2024peer], document understanding [masry2024longfin] retrieval-augmented generation [yao2022react, xu2023retrieval], and language agents [zhao2024longagent, zhang2024chain]. Meanwhile, extensive efforts in deep learning system [dao2022flashattention, dao2023flashattention, chen2023longlora, ratner2022parallel] research have been devoted to optimizing computational overhead to support increasing numbers of input tokens, which has led to growing attention on long-context LLMs. Now, both proprietary and open-source LLMs can support up to millions of input tokens [gemini, mistralnemo, glm4]. However, despite the rapid development of long-context language models, benchmarks have lagged behind. One of the key challenges is dataset construction, as long-context question-answering data is relatively scarce on the internet. To address this, prevalent long-context benchmarks have utilized synthetic tasks like passkey retrieval [mohtashami2023landmark], needle-in-a-haystack (NIAH) [needleinhaystack, zhao2024longagent], and variable tracking [hsieh2024ruler] to evaluate long-context LLMs. However, these tasks are often unrealistic and involve reasoning processes that differ significantly from those in real-world applications. Alternatively, some research efforts have involved human annotation of realistic questions and gold answers over one or multiple long documents [bamboo, wang2024leave, li2023loogle]. However, creating realistic long-context tasks from extensive texts is both challenging and time-consuming, even for human experts [wang2024leave]. This limitation restricts the expansion of datasets to accommodate arbitrary context lengths and the ability to support controllable contextLine truncated

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/corpus/2502.13127.txt

@@ -0,0 +1 @@
+Report GitHub Issue × Title: Content selection saved. Describe the issue below: Description: Submit without GitHub Submit in GitHub arXiv is now an independent nonprofit! Learn more × Back to arXiv Why HTML? Report Issue Back to Abstract Download PDF Abstract 1 Introduction 2 Related Work 3 Methodology 3.1 Problem Formulation 3.2 LongFinanceQA Dataset 3.3 Supervised CoT Reasoning 4 Experiments 4.1 Experimental Setup 4.2 Main Results 4.3 Discussion 5 Conclusion References A Appendix A.1 Trend of Long-Context LLMs A.2 Prompts of Property-based Agentic Inference (PAI) A.3 LongFinanceQA Dataset Statistics A.4 Synthetic Question Generation A.5 More Empirical Results A.6 Full Performances License: arXiv.org perpetual non-exclusive license arXiv:2502.13127v2 [cs.CL] 01 Dec 2025 Facilitating Long Context Understanding via Supervised Chain-of-Thought Reasoning Jingyang Lin Andy Wong Affiliation: University of Rochester, NY, United States Affiliation: PAII Inc., CA, United States Tian Xia Affiliation: PAII Inc., CA, United States Shenghua He Affiliation: PAII Inc., CA, United States Hui Wei Affiliation: PAII Inc., CA, United States Mei Han Affiliation: PAII Inc., CA, United States Jiebo Luo Affiliation: University of Rochester, NY, United States Affiliation: University of California, Merced, CA, United Stateshttps://long-pai.github.io/ Abstract Recent advances in Large Language Models (LLMs) have enabled them to process increasingly longer sequences, ranging from 2K to 2M tokens and even beyond. However, simply extending the input sequence length does not necessarily lead to effective long-context understanding. In this study, we integrate Chain-of-Thought (CoT) reasoning into LLMs in a supervised manner to facilitate effective long-context understanding. To achieve this, we introduce LongFinanceQA, a synthetic dataset in the financial domain designed to improve long-context reasoning. Unlike existing long-context synthetic data, LongFinanceQA includes intermediate CoT reasoning before the final conclusion, which encourages LLMs to perform explicit reasoning, improving accuracy and interpretability in long-context understanding. To generate synthetic CoT reasoning, we propose Property-based Agentic Inference (PAI), an agentic framework that simulates human-like reasoning steps, including property extraction, retrieval, and summarization. We evaluate PAI's reasoning capabilities by assessing GPT-4o-mini w/ PAI on the Loong benchmark, outperforming standard GPT-4o-mini by 20.0%. Furthermore, we fine-tune LLaMA-3.1-8B-Instruct on LongFinanceQA, achieving a 28.0% gain on Loong's financial subset. ††footnotetext: Corresponding author: 🖂 jlin81@ur.rochester.edu.††footnotetext: Work was done during the internship at PAII Inc. 1 Introduction Figure 1: The hype of long-context large language models. The results shown are from the Loong benchmark, where green points refer to open-source LLMs and red points indicate closed-source LLMs. Our GPT-4o-mini w/ PAI stands out as the red open circle. Long context understanding remains an evolving challenge Kočiský et al. (2018); Wu et al. (2021); Bai et al. (2024); Wang et al. (2024) in natural language processing (NLP). Achieving long-context understanding requires processing long-form textual information, thereby enhancing a model's ability to generate coherent, accurate, and contextually relevant responses IBM Research (2024). Practical long context understanding has a potential impact on numerous applications, such as private document analysis Mukherjee et al. (2023), large codebase understanding Nam et al. (2024), and multimodal content understanding Chandrasegaran et al. (2024); Lin et al. (2023); Tang et al. (2023); Chen et al. (2024c). Recent advancements in large language models Ouyang et al. (2022); Reid et al. (2024); Dubey et al. (2024) have significantly extended the input sequence length, ranging from 2K to 2M tokens, as shown in Figure 7 in Appendix A. However, simply increasing the input sequence length does not necessarily improve the ability to comprehend the long content Yang et al. (2024a); Goldman et al. (2024). In particular, Figure 1 presents the performance of various long-context LLMs on the Loong benchmark Wang et al. (2024). The results suggest that, regardless of the maximum sequence length models can process, their performance remains similar, typically between 45% and 55%. This phenomenon exposes a hype that despite considerably enlarging context window size, the state-of-the-art LLMs still fail to perform satisfactorily in practical long-context problem-solving tasks. Therefore, instead of merely increasing the input sequence length, achieving effective long-context understanding remains an open challenge. In parallel with advanced long-context architectures and techniques Peng et al. (2024); Liu et al. (2024c); Dao and Gu (2024), constructing high-quality long-context training data remains essential yet underexplored. Given the scarcity aLine truncated

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/corpus/2505.09561.txt

@@ -0,0 +1 @@
+Report GitHub Issue × Title: Content selection saved. Describe the issue below: Description: Submit without GitHub Submit in GitHub arXiv is now an independent nonprofit! Learn more × Back to arXiv Why HTML? Report Issue Back to Abstract Download PDF Abstract 1 Introduction 2 Related Work Imitation Learning. Long-Context Policies. Test-Time Scaling. 3 Preliminaries Problem Setting. Practical Challenges. 4 Method 4.1 Past-Token Prediction 4.2 Memory-Efficient Training with PTP 4.3 Test-Time Verification with PTP 5 Experiments 5.1 Simulation Experiments 5.2 Real-World Experiments 6 Conclusion 7 Limitations and Discussion. References A Additional Experiments A.1 Which component of the policy benefits most from PTP? A.2 Does our method reduce reliance on action chunking? A.3 Is PTP still critical when conditioning on past actions? B Environmental Details B.1 Real-World Tasks B.2 Simulation Tasks B.3 Implementation Details B.3.1 Policy Architecture B.3.2 Subsampling Rate B.3.3 Context Length B.3.4 Action Dependency Metric C Additional Results License: CC BY 4.0 arXiv:2505.09561v2 [cs.RO] 19 May 2025 Learning Long-Context Diffusion Policies via Past-Token Prediction Marcel Torne ††thanks: Equal contribution Andy Tang11footnotemark: 1 Yuejiang Liu11footnotemark: 1 Chelsea Finn Affiliation: Stanford University August 24, 2026 Abstract Reasoning over long sequences of observations and actions is essential for many robotic tasks. Yet, learning effective long-context policies from demonstrations remains challenging. As context length increases, training becomes increasingly expensive due to rising memory demands, and policy performance often degrades as a result of spurious correlations. Recent methods typically sidestep these issues by truncating context length, discarding historical information that may be critical for subsequent decisions. In this paper, we propose an alternative approach that explicitly regularizes the retention of past information. We first revisit the copycat problem in imitation learning and identify an opposite challenge in recent diffusion policies: rather than over-relying on prior actions, they often fail to capture essential dependencies between past and future actions. To address this, we introduce Past-Token Prediction (PTP), an auxiliary task in which the policy learns to predict past action tokens alongside future ones. This regularization significantly improves temporal modeling in the policy head, with minimal reliance on visual representations. Building on this observation, we further introduce a multistage training strategy: pre-train the visual encoder with short contexts, and fine-tune the policy head using cached long-context embeddings. This strategy preserves the benefits of PTP while greatly reducing memory and computational overhead. Finally, we extend PTP into a self-verification mechanism at test time, enabling the policy to score and select candidates consistent with past actions during inference. Experiments across four real-world and six simulated tasks demonstrate that our proposed method improves the performance of long-context diffusion policies by 3× and accelerates policy training by more than 10×. Videos are available at https://long-context-dp.github.io. 1 Introduction Many robotic tasks are inherently non-Markovian: an appropriate choice of action may depend not only on the current observation but also on past observations and actions [21, 47, 15, 48]. For example, consider manipulation tasks where the robot arm occludes critical parts of the scene, or multi-stage tasks where early steps inform later strategies [24]. Likewise, past actions can prescribe a style of execution, such as speed, curvature, or strategy, that shapes how future actions should unfold [8, 19]. Despite the importance of historical observations, learning long-context robotic policies through imitation learning remains difficult. First, longer observation histories often introduce features that spuriously correlate with actions in the training data. Policies that latch onto such information may diverge from expert behavior during deployment, leading to performance degradation [10, 34]. Second, conditioning on high-dimensional image sequences imposes a rapidly growing memory and computation burden, making end-to-end training excessively expensive at scale [48, 16]. To cope with these challenges, recent methods typically limit the amount of historical information the policy sees - either by truncating the context length [8, 5] or by engineering past observations into compact representations, such as selecting key frames [42] and summarizing observations [48]. While these strategies reduce memory requirement, they risk discarding information critical to subsequent decisions. In this paper, we introduce a simple and effective approach for learning long-context robot policies, illustrated in Fig. 1. At the core of our method is to explicitly regularize the information preserved from past Line truncated

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/corpus/2506.02483.txt

@@ -0,0 +1 @@
+Report GitHub Issue × Title: Content selection saved. Describe the issue below: Description: Submit without GitHub Submit in GitHub arXiv is now an independent nonprofit! Learn more × Back to arXiv Why HTML? Report Issue Back to Abstract Download PDF Abstract 1 Introduction 2 Related Works Long-Context and Cross-Lingual Challenges Advanced Prompting Strategies Neurosymbolic Reasoning 3 System Architecture and Approach 3.1 Retrieval Component Tokenization and Embedding Candidate Selection and Model Input 3.2 NeuroSymbolic Augmented Reasoning (NSAR) 1. Symbolic Fact Extraction 2. Python Code Generation 3. Final Answer Extraction 4 Experiments 4.1 Dataset 4.2 Evaluation 4.3 Models and Baseline Methods 5 Results and Analysis 5.1 LLM-Only vs. RAG-Vanilla Context length Accuracy by context language Error analysis 5.2 NeuroSymbolic Reasoning (NSAR) Accuracy by context language Effect of kk on performance Error analysis for NSAR and NSAR+3 6 Conclusion References A Prompt and Needle Templates A.1 Needle Template A.2 Prompt Templates License: CC BY 4.0 arXiv:2506.02483v1 [cs.CL] 03 Jun 2025 Enhancing Large Language Models with Neurosymbolic Reasoning for Multilingual Tasks Sina Bagheri Nezhad Email: sina.bagherinezhad@pdx.edu Ameeta Agrawal Email: ameeta@pdx.edu Affiliation: Portland State University, USA Abstract Large language models (LLMs) often struggle to perform multi-target reasoning in long-context scenarios where relevant information is scattered across extensive documents. To address this challenge, we introduce NeuroSymbolic Augmented Reasoning (NSAR), which combines the benefits of neural and symbolic reasoning during inference. NSAR explicitly extracts symbolic facts from text and generates executable Python code to handle complex reasoning steps. Through extensive experiments across seven languages and diverse context lengths, we demonstrate that NSAR significantly outperforms both a vanilla RAG baseline and advanced prompting strategies in accurately identifying and synthesizing multiple pieces of information. Our results highlight the effectiveness of combining explicit symbolic operations with neural inference for robust, interpretable, and scalable reasoning in multilingual settings. 1 Introduction Large language models (LLMs) have achieved impressive progress in natural language processing, yet their ability to handle long-context, cross-lingual reasoning remains limited (Agrawal et al., 2024). In real-world multilingual scenarios, information is often scattered across languages and embedded within lengthy documents, complicating retrieval and coherent reasoning. This challenge is exacerbated by the lost-in-the-middle phenomenon, where LLMs struggle to retain and integrate relevant information from extended contexts (Liu et al., 2023). Although retrieval-augmented generation (RAG) frameworks help narrow the context window, LLMs still frequently fail to combine dispersed facts into a consistent chain of reasoning, resulting in hallucinations and inconsistencies (Zhu et al., 2024; Jiang et al., 2024). In this work, we introduce NeuroSymbolic Augmented Reasoning (NSAR)-a neurosymbolic method that explicitly merges symbolic reasoning with neural inference. NSAR centers on a neurosymbolic prompt that instructs LLMs to extract structured symbolic facts and generate executable code, thus offering a verifiable and interpretable reasoning pathway for complex tasks. By integrating symbolic logic into a retrieval-based framework, NSAR improves interpretability, consistency, and accuracy when working with multilingual and long-context data. The main contributions of our work are as follows: • We propose NSAR, a neurosymbolic reasoning framework that couples retrieval with explicit symbolic reasoning. We develop a dedicated NSAR prompt to structure information into symbolic representations and guide the model in generating executable Python code for final verification. • We show that combining Chain of Thought (CoT), ReAct, and Self-Reflection prompting strategies with neurosymbolic reasoning leads to further performance gains. • Through extensive experiments on cross-lingual, long-context tasks, we demonstrate that NSAR substantially outperforms purely retrieval-based and neural-only methods. 2 Related Works Long-Context and Cross-Lingual Challenges Large language models (LLMs) frequently exhibit a lost-in-the-middle phenomenon in extended contexts (Liu et al., 2023; Xu et al., 2024), causing them to overlook crucial information. Retrieval-augmented frameworks such as LONGEMBED (Zhu et al., 2024), LongRAG (Jiang et al., 2024) and DR-RAG (Hei et al., 2024) alleviate this issue but mostly target monolingual settings. McCrolin (Limkonchotiwat et al., 2024) extends these ideas to cross-lingual retrieval, yet it remains computationally intensive. Bridging queries and contexts in different languages is still difficult (Li et al., 2024; Hengle et al., 2024). Methods such as OPTICAL (Huang et al., 2023) and Line truncated

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/corpus/2507.06261.txt

@@ -0,0 +1 @@
+Report GitHub Issue × Title: Content selection saved. Describe the issue below: Description: Submit without GitHub Submit in GitHub arXiv is now an independent nonprofit! Learn more × Back to arXiv Why HTML? Report Issue Back to Abstract Download PDF Abstract 1 Introduction 2 Model Architecture, Training and Dataset 2.1 Model Architecture 2.2 Dataset 2.3 Training Infrastructure 2.4 Post-training 2.5 Thinking 2.6 Capability-specific improvements 2.7 The path to Gemini 2.5 3 Quantitative evaluation 3.1 Methodology 3.2 Core capability quantitative results 3.3 Evaluation of Gemini 2.5 Pro against other large language models 4 Example use cases of Gemini 2.5 Pro 4.1 Gemini Plays Pokémon Long Context Agentic Tooling Long Horizon Task Coherence Screen reading Long Context Reasoning 4.2 What else can Gemini 2.5 do? 4.3 Gemini in Google Products 5 Safety, Security, and Responsibility Guideline for Navigating This Section 5.1 Our Process 5.2 Policies and Desiderata 5.3 Training for Safety, Security, and Responsibility 5.4 Results on Training/Development Evaluations 5.5 Automated Red Teaming 5.6 Memorization and Privacy 5.7 Assurance Evaluations and Frontier Safety Framework 5.8 External Safety Testing 6 Discussion References 7 Contributors and Acknowledgments 8 Appendix 8.1 Evaluation additional details 8.2 Gemini Plays Pokémon Additional Details Agent Panic 8.3 Frontier Safety Framework Evaluations Additional Details: Frontier Safety Correctness Tests 8.4 Image to Code Demo 8.5 Long Context Video Understanding Demo License: CC BY 4.0 arXiv:2507.06261v6 [cs.CL] 19 Dec 2025 \uselogo Gemini 2.5: Pushing the Frontier with Advanced Reasoning, Multimodality, Long Context, and Next Generation Agentic Capabilities. Gemini Team Google Abstract In this report, we introduce the Gemini 2.X model family: Gemini 2.5 Pro and Gemini 2.5 Flash, as well as our earlier Gemini 2.0 Flash and Flash-Lite models. Gemini 2.5 Pro is our most capable model yet, achieving SoTA performance on frontier coding and reasoning benchmarks. In addition to its incredible coding and reasoning skills, Gemini 2.5 Pro is a thinking model that excels at multimodal understanding and it is now able to process up to 3 hours of video content. Its unique combination of long context, multimodal and reasoning capabilities can be combined to unlock new agentic workflows. Gemini 2.5 Flash provides excellent reasoning abilities at a fraction of the compute and latency requirements and Gemini 2.0 Flash and Flash-Lite provide high performance at low latency and cost. Taken together, the Gemini 2.X model generation spans the full Pareto frontier of model capability vs cost, allowing users to explore the boundaries of what is possible with complex agentic problem solving. 1 Introduction We present our latest family of natively multimodal models with advanced reasoning through thinking, long context and tool-use capabilities: Gemini 2.5 Pro and 2.5 Flash and our earlier Gemini 2.0 Flash and Gemini 2.0 Flash-Lite models. Together these form a new family of highly-capable models representing our next generation of AI models, designed to power a new era of agentic systems. Building upon the foundation of the Gemini 1.5 series (Gemini Team, 2024), this Gemini 2.X generation brings us closer to the vision of a universal AI assistant (Hassabis, 2025). The Gemini 2.X series are all built to be natively multimodal, supporting long context inputs of >1 million tokens and have native tool use support. This allows them to comprehend vast datasets and handle complex problems from different information sources, including text, audio, images, video and even entire code repositories. These extensive capabilities can also be combined to build complex agentic systems, as happened in the case of Gemini Plays Pokémon11 1 Pokémon is a trademark of Nintendo Co., Ltd., Creatures Inc., and Game Freak Inc. (Zhang, 2025). Different models in the series have different strengths and capabilities: (1) Gemini 2.5 Pro is our most intelligent thinking model, exhibiting strong reasoning and code capabilities. It excels at producing interactive web applications, is capable of codebase-level understanding and also exhibits emergent multimodal coding abilities. (2) Gemini 2.5 Flash is our hybrid reasoning model with a controllable thinking budget, and is useful for most complex tasks while also controlling the tradeoff between quality, cost, and latency. (3) Gemini 2.0 Flash is our fast and cost-efficient non-thinking model for everyday tasks and (4) Gemini 2.0 Flash-Lite is our fastest and most cost-efficient model, built for at-scale usage. A full comparison of the models in the Gemini 2.X model family is provided in Table 1. Taken together, the Gemini 2.X family of models cover the whole Pareto frontier of model capability vs cost, shifting it forward across a large variety of core capabilities, applications and use-cases, see Figure 1. FlashGemini 1.5 ProGemini 1.5 Flash-LiteGemini 2.0 FlashGemiLine truncated

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/corpus/2507.06415.txt

@@ -0,0 +1 @@
+Report GitHub Issue × Title: Content selection saved. Describe the issue below: Description: Submit without GitHub Submit in GitHub arXiv is now an independent nonprofit! Learn more × Back to arXiv Why HTML? Report Issue Back to Abstract Download PDF Abstract 1 Introduction 2 Background and Preliminaries 3 PERK: Meta-Learning Parameter-Efficient Reasoning over Knowledge 3.1 Parameter-Efficient Meta-Learning with Low-Rank Adaptation 3.2 Scalable Meta-Learning with Truncated Gradient Unrolling 4 Experiments 4.1 Experimental Setup Datasets. 4.2 Long-Context Reasoning Results 5 Analysis 5.1 Test-Time Length Robustness 5.2 Robustness to Positional Biases 5.3 Inference Latency and Memory Usage Setup PERK scales more efficiently in memory and runtime on extremely long contexts. 6 Related Work 7 Conclusion References A Datasets A.1 BabiLong Tasks Build Long Context A.2 Student Records Tasks Build Long Context A.3 Open-Domain Multi-doc QA Build Long Context A.4 Lost-in-the-Middle API Retrieval Task Build Long Context B Training and Inference Details Hardware Information Standard Hyperparameters LoRA Hyperparameters Meta-Learning Hyperparameters Long-context Data Collation for PERK Evaluation Hyperparameters C Additional Analysis C.1 Impact of LoRA Rank in PERK C.2 Inner Loop Adaptation Steps C.3 Gradient Unrolling Truncation Steps D Training Memory Cost Analysis E Detailed Results License: CC BY 4.0 arXiv:2507.06415v3 [cs.CL] 31 Aug 2026 PERK: Long-Context Reasoning as Test-Time Learning Zeming Chen Angelika Romanou Gail Weiss Antoine Bosselut Affiliation: EPFL Affiliation: email{zeming.chen, antoine.bosselut}@epfl.ch Abstract Long-context reasoning requires accurately identifying relevant information in extensive, noisy input contexts. In this work, we propose PERK (Parameter Efficient Reasoning over Knowledge), a scalable approach for learning to encode long contexts using gradient updates at test time. Specifically, PERK employs two nested optimization loops in a meta-training phase. The inner loop rapidly encodes contexts into a low-rank adapter (LoRA) that serves as a parameter-efficient memory module for the base model. Concurrently, the outer loop learns to use the updated adapter to accurately recall and reason over relevant information from the encoded long context. Our evaluations on several long-context reasoning tasks show that PERK significantly outperforms the standard long-context finetuning, achieving average absolute performance gains of up to 20% for Qwen-2.5 (0.5B & 7B) on synthetic and real-world long-context reasoning. PERK also maintains its advantages across model scales and families. Compared to specialized long-context LLMs, PERK matches or surpasses their performance. Finally, our analyses show PERK is more robust to reasoning complexity, length extrapolation, and the positions of relevant information in contexts. https://perk-long-context.web.app 1 Introduction Large language models (LLMs) struggle with identifying and reasoning over relevant information in long, potentially noisy, input contexts (i.e., long-context reasoning; Anil et al., 2022; Lee et al., 2024; Li et al., 2024; Liu et al., 2023; Xu et al., 2024), including modern models with substantial context windows (Kuratov et al., 2024; Levy et al., 2024; Hsieh et al., 2024). These challenges arise because longer contexts contain more irrelevant distractor information, and may also be attached to more complex reasoning problems (i.e., multiple hops), both of which degrade LLM performance (Chen et al., 2023b). Furthermore, these challenges are exacerbated by positional biases in long-context models, which focus attention on the beginning or end of contexts, neglecting intermediate information (Liu et al., 2024). In this work, we address these challenges of long-context reasoning by reframing it as test-time learning, enabling models to encode context at inference time using gradient-based parameter adaptation. Our approach, Parameter-Efficient Reasoning over Knowledge (PERK), processes and compresses lengthy sequences as a batch (or multiple batches) of shorter segments of the long context, rather than processing the full sequence token-by-token. The updated model can then use the newly stored parametric information (and its initial parametric knowledge) to answer relevant questions. The original context is then discarded in this answering step as it is now encoded parametrically by the model. To train PERK, we operate two nested optimization loops: the inner loop, which is also used at test time, encodes the long context segment batches into model parameters, while the outer loop learns to respond to queries using the updated parameters representing the context. However, bi-level optimization algorithms for training test-time learning methods entail prohibitive memory overhead (Finn et al., 2017; Chen et al., 2023b; Hu et al., 2023), particularly when updating all model parameters, because they require backpropagating through a cLine truncated

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/corpus/2511.02817.txt

@@ -0,0 +1 @@
+Report GitHub Issue × Title: Content selection saved. Describe the issue below: Description: Submit without GitHub Submit in GitHub arXiv is now an independent nonprofit! Learn more × Back to arXiv Why HTML? Report Issue Back to Abstract Download PDF Abstract 1 Introduction 2 Oolong-synth 2.1 Data Data filtering 2.2 Context window construction Questions Instructions 2.3 Evaluation Baseline Parsing answers Scoring An iterative system? 3 Oolong-real 4 Results and Analysis 4.1 Does reasoning effort correlate to performance? Qwen and Olmo: think versus instruct models. GPT-5-nano: reasoning effort parameter. Gemini 3 Pro: reasoning token count. 4.2 Over-reasoning Deepseek R1 Gemini models 4.3 Refusal 4.4 Aggregation without classification Providing labels Providing domain knowledge 4.5 Iterative retrieval baseline for Oolong-real 5 Related Work 6 Conclusion 7 Acknowledgements References A Oolong - Leaderboard B Additional Results B.1 Reasoning effort on Oolong-real B.2 Data contamination for Oolong-real C Additional Related Work Dungeons & Dragons data Aggregation as an NLP concept D ICL label validation E Question types E.1 Oolong-synth E.2 Oolong-real F Deepseek R1 trace examples G Question type analysis G.1 Oolong-synth G.2 Oolong-real H Oolong-real data H.1 Data quality and curation H.2 Challenges of Oolong-real License: arXiv.org perpetual non-exclusive license arXiv:2511.02817v2 [cs.CL] 05 Oct 2026 Oolong: Evaluating Long Context Reasoning and Aggregation Capabilities Amanda Bertsch Adithya Pratapa ††thanks: Work conducted while the author was a student at Carnegie Mellon University. Teruko Mitamura Graham Neubig Matthew R. Gormley Carnegie Mellon University Email: {abertsch,vpratapa,teruko,gneubig,mgormley}@cs.cmu.edu Affiliation: abertsch72/oolong oolongbench/oolong-[synth, real] Abstract Many important applications of long-context models require reasoning over large collections of items-summarizing trends across thousands of customer interactions, identifying patterns in research corpora, or analyzing behavioral data at scale. Evaluating whether models can analyze items atomically and aggregate findings requires information-dense tasks that make use of the full context, like writing a summary or describing trends across a collection. Yet these types of tasks often result in long-form outputs which are challenging to evaluate; as a result, current long-context benchmarks predominantly test retrieval-style tasks, where the correct answer depends on a small fraction of tokens and the rest is noise. We introduce Oolong, a benchmark of distributional reasoning tasks that require analyzing individual chunks of text atomically and aggregating results. Oolong includes synthetic tasks (Oolong-synth) that enables controlled ablation of reasoning components, and a downstream setting (Oolong-real) that requires reasoning over realistic conversational data. Tasks involve classification, counting, filtering by metadata, and temporal reasoning. Frontier models struggle at moderate context lengths at this task, suggesting Oolong captures capabilities not yet addressed by scale alone. We release the data and evaluation harness for Oolong to enable further development of models that can reason over large quantities of text. 1 Introduction In the last several years, the exponentially increasing context lengths of LLMs have enabled many new applications, including reasoning models (Guo et al., 2025), many-shot prompting (Bertsch et al., 2024), and repository-level code generation (Jimenez et al., 2023). However, despite the rapid improvement in this area, long-context aggregation remains a challenging capability to study. Tasks like summarization are realistic but produce long and subjective outputs that are challenging to evaluate. Other tasks require only a subset of the input, which could be extracted from the long context before solving (e.g. using a RAG system). Multi-step reasoning datasets make progress towards measuring this capability, but often lack realism - inputs may be artificial (e.g. random repeated words in RULER (Hsieh et al., 2024)), the posed questions may be unrealistic (e.g. “identify the second poem about this topic” in MRCR (OpenAI, 2025)), and the relevant context may be embedded in distractor text from a different domain or a well-known text (e.g. small state updates embedded in Project Gutenberg novels in BABILong (Kuratov et al., 2024)). We argue that aggregation is best measured in realistic settings with multiple types of aggregative component tasks- including the ability to draw inferences across different sections of input and perform basic numeracy operations with this information. We further discuss these desiderata in Table 1. We propose Oolong, a benchmark that requires multi-hop reasoning over long inputs to produce easily verifiable outputs. Oolong is separated into two task sets, presented in Figure 1. Oolong-synth (§2) is a set of naturalistic synthetic tasks constructedLine truncated

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/corpus/2512.04307.txt

@@ -0,0 +1 @@
+Report GitHub Issue × Title: Content selection saved. Describe the issue below: Description: Submit without GitHub Submit in GitHub arXiv is now an independent nonprofit! Learn more × Back to arXiv Why HTML? Report Issue Back to Abstract Download PDF Abstract 1 Introduction 2 Related Work 3 Long-Context Reasoning Benchmark 3.1 Problem Formulation 3.2 Task Definition 3.3 Subtask Generation 4 Evaluation 4.1 Task Success Criteria 4.2 Implicit RAG (iRAG) Approach 5 Experiments 5.1 Retrieval Performance Analysis 5.1.1 Implicit RAG Retrieval Performance 5.2 Efficiency Ratio 6 Conclusion 7 Limitations 8 Reproducibility Statement References A Technical Appendices and Supplementary Material A.1 WebAgent Architecture A.2 System Prompts A.2.1 WebAgent system prompt A.2.2 Implicit RAG Prompt A.3 Sample Implicit RAG summary A.4 Summary Relevance Prompt A.5 Sample Trajectory A.6 List of successful tasks A.7 Sample interaction history A.8 False End Example A.8.1 Self evaluation A.9 Inefficent Progress Example A.10 Loop Example A.11 Implicit RAG analysis A.11.1 Failed retrieval without iRAG. A.11.2 With iRAG, successful retrieval of correct trajectory and completion of the task A.11.3 Summary used in the above task. License: CC BY 4.0 arXiv:2512.04307v1 [cs.LG] 03 Dec 2025 \workshoptitle LAW 2025: Bridging Language, Agent, and World Models Evaluating Long-Context Reasoning in LLM-Based WebAgents Andy Chung Affiliation: University of Michigan Yichi Zhang Affiliation: University of Michigan Kaixiang Lin Affiliation: Amazon Aditya Rawal Affiliation: Amazon Qiaozi Gao Affiliation: Amazon Joyce Chai Affiliation: University of Michigan Abstract As large language model (LLM)-based agents become increasingly integrated into daily digital interactions, their ability to reason across long interaction histories becomes crucial for providing personalized and contextually aware assistance. However, the performance of these agents in long context scenarios, particularly for action-taking WebAgents operating in realistic web environments, remains largely unexplored. This paper introduces a benchmark for evaluating long context reasoning capabilities of WebAgents through sequentially dependent subtasks that require retrieval and application of information from extended interaction histories. We develop a novel evaluation framework that simulates multi-session user interactions by injecting irrelevant task trajectories between dependent subtasks, creating contexts ranging from 25,000 to 150,000 tokens. Through extensive evaluation of four popular models, Claude-3.7, GPT-4.1, Llama 4, and o4-mini, we observe a dramatic performance degradation as context length increases, with success rates dropping from 40-50% in baseline conditions to less than 10% in long context scenarios. Our detailed error analysis reveals that agents primarily fail due to getting stuck in loops and losing track of original task objectives. We further propose an implicit RAG approach that provides modest improvements by generating task-relevant summaries, though fundamental limitations in long context reasoning persist. These findings highlight critical challenges for deploying WebAgents in realistic, long-term user interaction scenarios and provide insights for developing more robust agent architectures capable of maintaining coherent task execution across extended contexts. 1 Introduction Action-taking large language model (LLM)-based agents are rapidly becoming ubiquitous in our daily lives. These assistants extend their capabilities beyond the chatbot environment, making tangible impacts through their ability to operate in the digital realm. For instance, an action-taking agent can go beyond merely suggesting vacation plans-it can go online to book your flights and reserve your hotel as well. As these assistants become more capable, users will increasingly expect them to recognize and adapt to their preferences and intentions. A user may ask the assistant to find the highest-rated movie on IMDb and add it to your watchlist. Days later, they might simply say, “Buy that movie we saved earlier,” and expect it to understand the reference. While there have been many studies on the personalization of LLMs for chatbots and information retrieval assistants [7, 14, 15], studies exploring the personalization capabilities of LLM-based action-taking agents are lacking. We study WebAgents in the live open Internet, one of the most information-rich environments on earth. Its usage is ubiquitous in North America with 96% of the population online. This environment also enables an unparalleled variety of tasks such as shopping, social media, banking, entertainment, or research. This diversity enables us to design the experiment to closely reflect real-world human behavior. Despite the challenges and limitations of studying live environments, this approach enables us to observe how these agents perform under realistic conditions. We explore the capabilities of these types of Line truncated

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/corpus/2603.20586.txt

@@ -0,0 +1 @@
+Report GitHub Issue × Title: Content selection saved. Describe the issue below: Description: Submit without GitHub Submit in GitHub arXiv is now an independent nonprofit! Learn more × Back to arXiv Why HTML? Report Issue Back to Abstract Download PDF Abstract. 1 Introduction 2 Related Work 2.1 Long-context Attention Mechanisms 2.2 Hierarchical and External Memory Systems 2.3 Dynamic Routing and Query-aware Attention 3 Motivation: Beyond MLA and MHA 4 Methodology 4.1 Route-Fused MKA (FastMKA): Causal Route-Fusion with KV-Cache 4.2 Block-Memory Keyed Attention (Block-MKA) Design 4.3 Hierarchical Block-wise MKA Algorithm 4.4 Algorithm and Pseudocode 5 Theoretical Formulation: Recursive MKA with Online Softmax 5.1 Recursive Reformulation 5.2 Numerical Stability via Max-Shift 5.3 Local vs. Global MKA Modes 5.4 Runtime Bounds and Complexity 6 Experiments 6.1 Experimental Setup Models. Dataset. Hardware. Training Details. Inference Details. Metric. 6.2 Main Results 6.3 Experimental Results Analysis 6.4 Long-Context Benchmark Evaluation 6.5 Ablation Studies 6.5.1 Memory Tier Ablation 6.5.2 Routing Mechanism Ablation 6.5.3 Routing Weight Analysis 6.6 System-Level Performance Analysis 6.6.1 Prefill vs Decode Latency Breakdown 6.6.2 Computational Cost Analysis 6.7 Discussion 7 Conclusion Acknowledgements References License: CC BY 4.0 arXiv:2603.20586v2 [cs.LG] 24 Mar 2026 MKA: Memory-Keyed Attention for Efficient Long-Context Reasoning Conference: Proceedings of the 23rd ACM International Conference on Computing Frontiers; May 19-21, 2026; Catania, ItalyProceedings of the 23rd ACM International Conference on Computing Frontiers (CF '26), May 19-21, 2026, Catania, ItalyDOI: 10.1145/3801487.3801812ISBN: 979-8-4007-2568-5/2026/05 Dong Liu Affiliation: University of California, Los Angeles, Los Angeles, California, USA email: pikeliu@ucla.edu , Yanxuan Yu Affiliation: Columbia University, New York, New York, USA email: yy3523@columbia.edu , Ben Lengerich Affiliation: University of Wisconsin-Madison, Madison, Wisconsin, USA email: lengerich@wisc.edu and Ying Nian Wu Affiliation: University of California, Los Angeles, Los Angeles, California, USA email: ywu@stat.ucla.edu © cc Abstract. As long-context language modeling becomes increasingly important, the cost of maintaining and attending to large Key/Value (KV) caches grows rapidly, becoming a major bottleneck in both training and inference. While prior works such as Multi-Query Attention (MQA) and Multi-Latent Attention (MLA) reduce memory by sharing or compressing KV features, they often trade off representation quality or incur runtime overhead. We propose Memory-Keyed Attention (MKA), a hierarchical attention mechanism that integrates multi-level KV caches-local, session, and long-term-and learns to route attention across them dynamically. We further introduce Route-Fused MKA (FastMKA), a broadcast-routed variant that fuses memory sources before attention computation for enhanced efficiency. Experiments on different sequence lengths show that FastMKA achieves a favorable accuracy-efficiency trade-off: comparable perplexity to MLA while achieving up to 5 ×\times faster training throughput and 1.8 ×\times lower evaluation latency. These results highlight MKA as a practical and extensible framework for efficient long-context attention. ††cc-license: by 1. Introduction Large Language Models (LLMs) have rapidly advanced and are now capable of processing context lengths up to 128K or even 1M tokens (Peng et al., 2023; Jiang et al., 2024; Tworkowski et al., 2023). This unprecedented expansion of context length unlocks new applications such as long-document reasoning and multi-turn dialogue with persistent memory. However, supporting long contexts during inference introduces severe memory and latency bottlenecks, particularly due to the scaling cost of attention with Key/Value (KV) caches. In self-attention, each newly generated token must attend to all past tokens stored in the KV cache. This results in quadratic compute and increasingly large memory reads. For instance, with a context length of 3232K, we measure that the KV cache for a LLaMA-7B model (Touvron et al., 2023) occupies approximately 15.8GB on an NVIDIA A800 GPU and requires 11.3ms to access during decode, which dominates more than 50% of the inference latency. This cost limits the throughput of LLMs in production environments. Several methods have attempted to address the inefficiencies in attention computation. Multi-Query Attention (MQA) (Shazeer, 2019) and Grouped-Query Attention (GQA) (Ainslie et al., 2023) reduce KV duplication by sharing them across heads. Multi-Latent Attention (MLA) (Team, 2024) compresses the KV cache via low-rank factorization. However, these methods sacrifice representation fidelity or lack the flexibility to differentiate among memory types. Figure 1. MKA hierarchical memory design with three memory levels (L1: local, L2: session, L3: long-term) and dynamic routing gates. InLine truncated

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/corpus/2604.05114.txt

@@ -0,0 +1 @@
+Report GitHub Issue × Title: Content selection saved. Describe the issue below: Description: Submit without GitHub Submit in GitHub arXiv is now an independent nonprofit! Learn more × Back to arXiv Why HTML? Report Issue Back to Abstract Download PDF Abstract 1 Introduction 2 Curation of π2\pi^{2} 2.1 Table Collection and Expansion 2.2 QA Generation 2.3 Reasoning Trace Generation 2.4 π2\pi^{2} 2.5 π2\pi^{2}-Bench and Quality of π2\pi^{2} 3 Experiments 3.1 Methods and Baselines 3.2 Benchmarks and Metrics In-domain evaluation. Out-of-domain evaluation. Metrics. 3.3 Results 4 Ablation Study 4.1 Reasoning Style versus Faithful Reasoning Patterns 4.2 Contribution of Table Expansion and Context Realisticness 4.3 Comparison to Previous Long-Context Reasoning Datasets 5 Related Work 6 Conclusion References A π2\pi^{2}'s Curation and Statistics B Training Details C Additional Experiments and Analyses C.1 Efficiency of High-Quality Data. C.2 Effective Self-Distillation with Curated QA Data. C.3 Effect of Learning Rate C.4 Effect of Context Cleanliness C.5 Validation of π2\pi^{2}-Bench C.6 Comparison with Recursive Language Models C.7 Output Length Analysis C.8 Statistical Significance of Results D Attempts at Larger Improvements E Limitations F Prompts License: arXiv.org perpetual non-exclusive license arXiv:2604.05114v2 [cs.CL] 02 Oct 2026 Structure-Originated Reasoning Data Improves Long-Context Reasoning Ability of Large Language Models Quyet V. Do Thinh Pham Nguyen Nguyen Sha Li Pratibha Zunjare Tu Vu Affiliation: Virginia Tech, VA 24061, USA Email: {quyetdo,thinhphp,stephenallstar24,shal,pratibhaz,tuvu}@vt.edu Abstract We study a QA curation pipeline for improving long-context complex reasoning in large language models (LLMs). Our approach, π2\pi^{2}, constructs high-quality reasoning data through rigorous QA curation: 1) extracting and expanding tables from Wikipedia, 2) from the collected tables together with relevant metadata, generating complex reasoning questions whose answers are automatically determined and validated through dual-path code execution, 3) finally, back-translating chain-of-thoughts solutions grounded in realistic context. Supervised fine-tuning with gpt-oss-20b and Qwen3-4B-Instruct-2507 on π2\pi^{2} yields consistent improvements across four long-context reasoning benchmarks and our alike π2\pi^{2}-Bench, with average absolute accuracy gains of +6.25% and +3.37% respectively. Through deeper analyses, we observe that reasoning style contributes little, while faithful reasoning patterns discovered by back translation and grounded realistic long context, as π2\pi^{2} is designed for, are crucial for the improvement. Our code, data, and models are fully open-source at https://github.com/vtpss/pi-squared. 1 Introduction "In all chaos there is a cosmos, in all disorder a secret order." - Carl Jung Large language models (LLMs) have made rapid progress in handling long contexts, with recent systems supporting hundreds of thousands to millions of tokens (OpenAI et al., 2025; Yang et al., 2025a; OpenAI, 2026; Anthropic, 2026; Team, 2026). This capability enables applications that require integrating information from multiple documents, such as open-domain question answering, document analysis, and web-scale search. However, improved context capacity does not translate to reasoning capacity, as current flagship models still struggle on complex reasoning over realistic long contexts (Zhu et al., 2024; Bai et al., 2025; Chen et al., 2025b; Pham et al., 2026; Opsahl-Ong et al., 2026). A key bottleneck lies in the lack of verifiable supervision for complex reasoning over realistic long context in open-domain tasks. Hugging Face (2025) and Guha et al. (2026) represent a line of works that provide complex reasoning data with high-quality supervision, however, data domains are limited to natural science or coding. In another line of works, Yang et al. (2025b); Wang et al. (2025) and Xie et al. (2026) ensure the verifiability of open-domain reasoning data, yet the contexts are synthetic or limited to tables, not realistic long documents. Meanwhile, others were built on real open-domain documents and validated via code execution on concept graphs parsed from documents (Yang et al., 2018; Trivedi et al., 2022; Chen et al., 2025a; Shen et al., 2025; Sun et al., 2026). Nonetheless, their complexity is limited to low branching-factor reasoning patterns. This creates a gap: reliable supervision on complex reasoning is common in structured domains, but remains largely absent for realistic long contexts in open-domain tasks. Figure 1: Tables bridge realistic documents and complex reasoning in open-domain tasks. They represent data across sources, while being compatible with programmatic operations. We observe that structured representations, such as tables, is a natural medium that bridges complex reasoning and real long-context open-domain data, in which the data construction and verification are otherLine truncated

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/corpus/2609.33485.txt

@@ -0,0 +1 @@
+Report GitHub Issue × Title: Content selection saved. Describe the issue below: Description: Submit without GitHub Submit in GitHub arXiv is now an independent nonprofit! Learn more × Back to arXiv Why HTML? Report Issue Back to Abstract Download PDF Abstract 1 Introduction 2 Method 2.1 The Grounding-Reasoning Interference 2.2 DISCO: A Distributed Long Context Scaling Paradigm 2.3 Query Decomposition via Directed Acyclic Graphs 1. Narrow Actions (Map: Atomic Extraction). 2. Wide Actions (Reduce: Logical Synthesis). 2.4 Dynamic Orchestration: Iterative DAG Refinement 1. Planning Phase (DAG Construction). 2. Execution Phase (Evidence Pooling). 3. Evaluation and Refinement. 2.5 Optimizing the Driver via Reinforcement Learning 3 Experimental Setup 3.1 Evaluation Protocol Baselines. Benchmarks. Models and Implementation. 3.2 Implementation Details. Training Data Construction. Training Setup. 4 Results and Analyses 4.1 Main Results Distributed Partitioning Ensures Robust Grounding at Scale. Decoupling and Replanning Unleash Reasoning Potential. Architecture Decouples Cost from Scale. 4.2 Impact of Worker LLMs Sensitivity to Worker Model Scale. 4.3 Impact of Reward Design Planning Efficiency ( RevdR_{\text{evd}}). Structural Stability ( RfmtR_{\text{fmt}}). 4.4 Inference Efficiency and Scalability 5 Related Work Distributed Computing Paradigms. Long-Context Processing in LLMs. 6 Conclusion References A Appendix A.1 Algorithm A.2 Evaluation Details Baselines. Benchmarks. A.3 Training Data Construction A.4 More Experimental Results Fault Tolerance via Iterative Replanning. Generative Worker LLM Outperforms Dense Retriever. Generalization across Driver and Worker Families. A.5 Case Studies of RL Benefits Atomic, Entity-Specific Query Decomposition. Well-Formed DAGs and Faster Convergence. License: CC BY 4.0 arXiv:2609.33485v1 [cs.CL] 27 Sep 2026 DISCO: Distributed Long Context Scaling with Grounding-Reasoning Disaggregation Guanzheng Chen ††thanks: Work done during an internship at Adobe Research. Affiliation: National University of Singapore Affiliation: Adobe Research Correspondence:qizhex@nus.edu.sg, bui@adobe.com Viet Dac Lai Affiliation: Adobe Research Correspondence:qizhex@nus.edu.sg, bui@adobe.com Subhojyoti Mukherjee Affiliation: Adobe Research Correspondence:qizhex@nus.edu.sg, bui@adobe.com Branislav Kveton Affiliation: Adobe Research Correspondence:qizhex@nus.edu.sg, bui@adobe.com Seunghyun Yoon Affiliation: Adobe Research Correspondence:qizhex@nus.edu.sg, bui@adobe.com Franck Dernoncourt Affiliation: Adobe Research Correspondence:qizhex@nus.edu.sg, bui@adobe.com Qizhe Xie ††thanks: Corresponding authors. Affiliation: National University of Singapore Trung Bui22footnotemark: 2 Affiliation: Adobe Research Correspondence:qizhex@nus.edu.sg, bui@adobe.com Abstract While Large Language Models (LLMs) advertise million-token context windows, reasoning quality often collapses as inputs grow-a phenomenon termed context rot. This failure stems from a structural entanglement in monolithic architectures, where the massive search burden of contextual grounding exhausts the representational capacity needed for complex reasoning. To resolve this, we propose Grounding-Reasoning Disaggregation via DIStributed long COntext scaling (DISCO). Inspired by distributed computing frameworks like Apache Spark, DISCO partitions long context across a fleet of Worker LLMs dedicated exclusively to parallel, localized grounding. A central Driver LLM, trained via Reinforcement Learning (GRPO) to optimize planning, orchestrates execution by dynamically mapping queries into atomic extraction tasks and reducing the gathered evidence to synthesize a final answer. By isolating reasoning from raw context noise, DISCO effectively eliminates context rot. On RULER-QA (1M tokens), it maintains 78.4% accuracy where standard baselines collapse. Furthermore, it outperforms full-context models by up to 9.8 points on LongBench v2 and matches frontier models like Gemini-3-Pro-Preview while reducing inference costs by over 80%, establishing a highly efficient paradigm for robust long-context inference. 1 Introduction Recent Large Language Models (LLMs) increasingly advertise context windows spanning millions of tokens (OpenAI, 2023; Huang and Yang, 2025; Guo et al., 2025). Yet, even well within nominal limits, reasoning quality frequently collapses as input grows-a phenomenon termed context rot (Hsieh et al., 2024; Hong et al., 2025). Consequently, the effective context window of LLMs remains severely limited (Modarressi et al., 2025), hampering their reliability in real-world applications. We argue that context rot stems from a fundamental structural asymmetry between two distinct cognitive phases: contextual grounding (identifying relevant facts) and reasoning (synthesizing those facts into an answer). As input length increases, grounding becomes a massive search problem that scales proportionally with the text, while the core reasoning task Line truncated

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/falsify_verify.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""Falsification tests: the verifier must FAIL on a fabricated quote and on a
+corrupted corpus file. Prints exit codes; exits 0 only if both tamper tests fail."""
+import json, os, re, shutil, subprocess, sys, tempfile
+
+SRC = os.path.dirname(os.path.abspath(__file__))
+REAL_RE = re.compile(r'^QUOTE: "(.+)"$', re.M)
+
+
+def first_quote(path):
+    m = REAL_RE.search(open(path).read())
+    assert m, "no QUOTE line found"
+    return m.group(1)
+results = {}
+
+for name, mutate in [("fake_quote", "quote"), ("corpus_tamper", "corpus"), ("missing_file", "missing")]:
+    d = tempfile.mkdtemp(prefix="tamper_")
+    dst = os.path.join(d, "a")
+    shutil.copytree(SRC, dst)
+    if mutate == "quote":
+        p = os.path.join(dst, "synthesis.md")
+        s = open(p).read()
+        real = first_quote(p)
+        fake = ("This paper proves that context length has no effect on reasoning accuracy at any scale, "
+                "a result the authors never measured or reported anywhere in the text.")
+        assert s.count(real) == 1
+        open(p, "w").write(s.replace(real, fake))
+    elif mutate == "corpus":
+        p = os.path.join(dst, "corpus", "2409.02465.txt")
+        with open(p, "a") as fh:
+            fh.write("X")
+    elif mutate == "missing":
+        os.remove(os.path.join(dst, "corpus", "2409.02465.txt"))
+    r = subprocess.run([sys.executable, "verify.py"], cwd=dst, capture_output=True, text=True)
+    results[name] = r.returncode
+    tail = [ln for ln in r.stdout.splitlines() if ln.startswith("  -")][:2]
+    print(f"{name}: exit={r.returncode} {tail}")
+    shutil.rmtree(d)
+
+ok = all(v != 0 for v in results.values())
+print("FALSIFICATION OK" if ok else "FALSIFICATION BROKEN")
+sys.exit(0 if ok else 1)

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/fetch_corpus.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+"""Fetch arXiv papers (HTML full text, PDF+pdftotext fallback) for the
+long-context research archive. Caches raw + plain text, records sha256."""
+import hashlib, html.parser, json, os, re, subprocess, sys, time
+
+import requests
+
+BASE = "/root/.hermes/wizard-outputs/sphinx/longctx-arxiv-archive-2026-10-20"
+CORPUS = os.path.join(BASE, "corpus")
+RAW = os.path.join(BASE, "raw")
+os.makedirs(CORPUS, exist_ok=True)
+os.makedirs(RAW, exist_ok=True)
+
+UA = {"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) research-archive/1.0 (mailto:sphinx@agents.invalid)"}
+S = requests.Session()
+S.headers.update(UA)
+
+QUERIES = [
+    'all:"long context" AND all:"reasoning"',
+    'ti:"long context" AND abs:"benchmark"',
+    'all:"long-context" AND all:"retrieval" AND all:"position"',
+]
+
+
+class TextExtractor(html.parser.HTMLParser):
+    """Strip HTML to text; keep some structure markers."""
+
+    SKIP = {"script", "style", "noscript", "svg", "head"}
+    BLOCK = {"p", "div", "li", "h1", "h2", "h3", "h4", "h5", "tr", "section", "article", "br", "table", "figcaption"}
+
+    def __init__(self):
+        super().__init__(convert_charrefs=True)
+        self.parts = []
+        self.skip_depth = 0
+
+    def handle_starttag(self, tag, attrs):
+        if tag in self.SKIP:
+            self.skip_depth += 1
+        elif tag in self.BLOCK:
+            self.parts.append("\n")
+        elif tag == "math":
+            self.parts.append(" ")
+
+    def handle_endtag(self, tag):
+        if tag in self.SKIP and self.skip_depth:
+            self.skip_depth -= 1
+        elif tag in self.BLOCK:
+            self.parts.append("\n")
+
+    def handle_data(self, data):
+        if not self.skip_depth:
+            self.parts.append(data)
+
+
+def html_to_text(raw_html):
+    p = TextExtractor()
+    p.feed(raw_html)
+    txt = "".join(p.parts)
+    txt = txt.replace("\xa0", " ").replace("’", "'").replace("&", "&")
+    txt = re.sub(r"[ \t]+", " ", txt)
+    txt = re.sub(r"\n\s*\n\s*\n+", "\n\n", txt)
+    return txt.strip()
+
+
+def get(url, timeout=60, tries=3):
+    last = None
+    for i in range(tries):
+        try:
+            r = S.get(url, timeout=timeout, allow_redirects=True)
+            return r
+        except Exception as e:  # noqa
+            last = e
+            time.sleep(2 * (i + 1))
+    raise last
+
+
+def api_search(query, max_results=30):
+    url = ("https://export.arxiv.org/api/query?search_query=" + requests.utils.quote(query)
+           + f"&start=0&max_results={max_results}&sortBy=relevance&sortOrder=descending")
+    r = get(url, timeout=60)
+    r.raise_for_status()
+    txt = r.text
+    entries = []
+    for m in re.finditer(r"<entry>(.*?)</entry>", txt, re.S):
+        e = m.group(1)
+
+        def grab(tag):
+            mm = re.search(rf"<{tag}[^>]*>(.*?)</{tag}>", e, re.S)
+            return re.sub(r"\s+", " ", html.unescape(mm.group(1))).strip() if mm else ""
+        eid = grab("id")
+        aid = re.sub(r"v\d+$", "", eid.rsplit("/", 1)[-1])
+        entries.append({
+            "arxiv_id": aid,
+            "versioned_id": eid.rsplit("/", 1)[-1],
+            "title": grab("title"),
+            "published": grab("published"),
+            "updated": grab("updated"),
+            "abstract": grab("summary"),
+            "authors": re.findall(r"<name>([^<]+)</name>", e),
+        })
+    return entries
+
+
+def fetch_paper(entry):
+    aid = entry["versioned_id"]
+    html_url = f"https://arxiv.org/html/{aid}"
+    pdf_url = f"https://arxiv.org/pdf/{aid}"
+    try:
+        r = get(html_url, timeout=90)
+        if r.status_code == 200 and len(r.content) > 20000:
+            txt = html_to_text(r.text)
+            if len(txt) > 20000:
+                return {"method": "arxiv-html", "url": html_url, "raw_path": None,
+                        "text": txt, "raw_bytes": len(r.content)}
+    except Exception as e:  # noqa
+        print("  html err", aid, type(e).__name__, file=sys.stderr)
+    try:
+        r = get(pdf_url, timeout=120)
+        if r.status_code == 200 and r.content[:4] == b"%PDF":
+            pdf_path = os.path.join(RAW, aid + ".pdf")
+            with open(pdf_path, "wb") as fh:
+                fh.write(r.content)
+            out = subprocess.run(["pdftotext", "-layout", pdf_path, "-"],
+                                 capture_output=True, text=True, timeout=180)
+            txt = out.stdout
+            if len(txt) > 20000:
+                return {"method": "arxiv-pdf+pdftotext", "url": pdf_url,
+                        "raw_path": pdf_path, "text": txt, "raw_bytes": len(r.content)}
+    except Exception as e:  # noqa
+        print("  pdf err", aid, type(e).__name__, file=sys.stderr)
+    return None
+
+
+def main():
+    seen, cands = set(), []
+    for q in QUERIES:
+        try:
+            entries = api_search(q, 25)
+        except Exception as e:  # noqa
+            print("query failed:", q, e, file=sys.stderr)
+            continue
+        for e in entries:
+            if e["arxiv_id"] in seen:
+                continue
+            seen.add(e["arxiv_id"])
+            cands.append(e)
+        print(f"query {q!r}: +{len(entries)} entries (pool {len(cands)})", file=sys.stderr)
+        time.sleep(3)
+    sources, failed = [], []
+    for e in cands:
+        if len(sources) >= 12:
+            break
+        res = fetch_paper(e)
+        if not res:
+            failed.append(e["arxiv_id"])
+            print("skip (no full text):", e["arxiv_id"], e["title"][:70], file=sys.stderr)
+            continue
+        txt = res.pop("text")
+        txt_path = os.path.join(CORPUS, e["arxiv_id"] + ".txt")
+        with open(txt_path, "w", encoding="utf-8") as fh:
+            fh.write(txt)
+        sha = hashlib.sha256(txt.encode("utf-8")).hexdigest()
+        sources.append({
+            **e,
+            "method": res["method"],
+            "source_url": res["url"],
+            "raw_path": res["raw_path"],
+            "text_path": txt_path,
+            "text_sha256": sha,
+            "text_chars": len(txt),
+            "text_words": len(txt.split()),
+            "raw_bytes": res["raw_bytes"],
+        })
+        print(f"ok {e['arxiv_id']} [{res['method']}] {len(txt)} chars :: {e['title'][:70]}", file=sys.stderr)
+        time.sleep(2)
+    with open(os.path.join(BASE, "sources.json"), "w") as fh:
+        json.dump({"query_queries": QUERIES, "sources": sources, "skipped_no_fulltext": failed},
+                  fh, indent=2)
+    print(f"SOURCES={len(sources)} FAILED={len(failed)}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/manifest.json

@@ -0,0 +1,207 @@
+[
+  {
+    "arxiv_id": "2507.06415",
+    "title": "PERK: Long-Context Reasoning as Test-Time Learning",
+    "sha256": "2fc3cc3b8de1ebf74c0af3dbdb978ee70189d7ed3c81bf2ccba854e71b75cd70",
+    "chars": 107789,
+    "words": 16431,
+    "method": "arxiv-html",
+    "url": "https://arxiv.org/html/2507.06415v3",
+    "published": "2025-07-08T21:38:45Z",
+    "authors": [
+      "Zeming Chen",
+      "Angelika Romanou",
+      "Gail Weiss",
+      "Antoine Bosselut"
+    ]
+  },
+  {
+    "arxiv_id": "2604.05114",
+    "title": "$\u03c0^2$: Structure-Originated Reasoning Data Improves Long-Context Reasoning Ability of Large Language Models",
+    "sha256": "279d4db0339ec14accdbb697bdf85b921f81e0b6dc65690ecfe51e35f61ccbe6",
+    "chars": 94666,
+    "words": 14376,
+    "method": "arxiv-html",
+    "url": "https://arxiv.org/html/2604.05114v2",
+    "published": "2026-04-06T19:19:58Z",
+    "authors": [
+      "Quyet V. Do",
+      "Thinh Pham",
+      "Nguyen Nguyen",
+      "Sha Li",
+      "Pratibha Zunjare",
+      "Tu Vu"
+    ]
+  },
+  {
+    "arxiv_id": "2505.09561",
+    "title": "Learning Long-Context Diffusion Policies via Past-Token Prediction",
+    "sha256": "64d333b9a86ab163879d0e0e021dbc1b74c34b947a146e390f467fc145211e7b",
+    "chars": 58077,
+    "words": 8209,
+    "method": "arxiv-html",
+    "url": "https://arxiv.org/html/2505.09561v2",
+    "published": "2025-05-14T17:00:47Z",
+    "authors": [
+      "Marcel Torne",
+      "Andy Tang",
+      "Yuejiang Liu",
+      "Chelsea Finn"
+    ]
+  },
+  {
+    "arxiv_id": "2603.20586",
+    "title": "MKA: Memory-Keyed Attention for Efficient Long-Context Reasoning",
+    "sha256": "5028e872acf1e0a59790b0ae34073019ceccc41dbf7259f469a60f253ef9d393",
+    "chars": 50726,
+    "words": 6519,
+    "method": "arxiv-html",
+    "url": "https://arxiv.org/html/2603.20586v2",
+    "published": "2026-03-21T01:04:03Z",
+    "authors": [
+      "Dong Liu",
+      "Yanxuan Yu",
+      "Ben Lengerich",
+      "Ying Nian Wu"
+    ]
+  },
+  {
+    "arxiv_id": "2507.06261",
+    "title": "Gemini 2.5: Pushing the Frontier with Advanced Reasoning, Multimodality, Long Context, and Next Generation Agentic Capabilities",
+    "sha256": "e89e8fe09f9a9d4e7abddaaf111f5a0637193f95d2ddd1513518834e078daadf",
+    "chars": 215441,
+    "words": 32428,
+    "method": "arxiv-html",
+    "url": "https://arxiv.org/html/2507.06261v6",
+    "published": "2025-07-07T17:36:04Z",
+    "authors": [
+      "Gheorghe Comanici",
+      "Eric Bieber",
+      "Mike Schaekermann",
+      "Ice Pasupat",
+      "Noveen Sachdeva",
+      "Inderjit Dhillon"
+    ]
+  },
+  {
+    "arxiv_id": "2609.33485",
+    "title": "DISCO: Distributed Long Context Scaling with Grounding-Reasoning Disaggregation",
+    "sha256": "bca2c8591bee48ac7108ced57c5c32ce3b2cfbab024fd89963653a36abbb653f",
+    "chars": 58262,
+    "words": 7852,
+    "method": "arxiv-html",
+    "url": "https://arxiv.org/html/2609.33485v1",
+    "published": "2026-09-27T11:52:58Z",
+    "authors": [
+      "Guanzheng Chen",
+      "Viet Dac Lai",
+      "Subhojyoti Mukherjee",
+      "Branislav Kveton",
+      "Seunghyun Yoon",
+      "Franck Dernoncourt"
+    ]
+  },
+  {
+    "arxiv_id": "2512.04307",
+    "title": "Evaluating Long-Context Reasoning in LLM-Based WebAgents",
+    "sha256": "4d7aa25dc87e202e55f5de1b1efd49bff10585ba6abcb6d57232125b6cfc9bfc",
+    "chars": 75916,
+    "words": 12070,
+    "method": "arxiv-html",
+    "url": "https://arxiv.org/html/2512.04307v1",
+    "published": "2025-12-03T22:53:10Z",
+    "authors": [
+      "Andy Chung",
+      "Yichi Zhang",
+      "Kaixiang Lin",
+      "Aditya Rawal",
+      "Qiaozi Gao",
+      "Joyce Chai"
+    ]
+  },
+  {
+    "arxiv_id": "2409.02465",
+    "title": "DetectiveQA: Evaluating Long-Context Reasoning on Detective Novels",
+    "sha256": "df0bba49bc0e680305b4777142d7e1bb89053e4b88343274f4e9c6c3038d2dbd",
+    "chars": 52235,
+    "words": 7501,
+    "method": "arxiv-html",
+    "url": "https://arxiv.org/html/2409.02465v2",
+    "published": "2024-09-04T06:28:22Z",
+    "authors": [
+      "Zhe Xu",
+      "Jiasheng Ye",
+      "Xiaoran Liu",
+      "Xiangyang Liu",
+      "Tianxiang Sun",
+      "Zhigeng Liu"
+    ]
+  },
+  {
+    "arxiv_id": "2502.13127",
+    "title": "Facilitating Long Context Understanding via Supervised Chain-of-Thought Reasoning",
+    "sha256": "0d915778445dcca79c2129d6f10ad8a4ae1e597a685228cf4a6d524f7028b7a4",
+    "chars": 68852,
+    "words": 9795,
+    "method": "arxiv-html",
+    "url": "https://arxiv.org/html/2502.13127v2",
+    "published": "2025-02-18T18:50:06Z",
+    "authors": [
+      "Jingyang Lin",
+      "Andy Wong",
+      "Tian Xia",
+      "Shenghua He",
+      "Hui Wei",
+      "Mei Han"
+    ]
+  },
+  {
+    "arxiv_id": "2511.02817",
+    "title": "Oolong: Evaluating Long Context Reasoning and Aggregation Capabilities",
+    "sha256": "c48531ba8afab0a2daf6426d6d61ecd7e69f4a1a9548523a8646001e399c5307",
+    "chars": 96818,
+    "words": 15314,
+    "method": "arxiv-html",
+    "url": "https://arxiv.org/html/2511.02817v2",
+    "published": "2025-11-04T18:42:12Z",
+    "authors": [
+      "Amanda Bertsch",
+      "Adithya Pratapa",
+      "Teruko Mitamura",
+      "Graham Neubig",
+      "Matthew R. Gormley"
+    ]
+  },
+  {
+    "arxiv_id": "2506.02483",
+    "title": "Enhancing Large Language Models with Neurosymbolic Reasoning for Multilingual Tasks",
+    "sha256": "6944178578777a8f910ea0adaf5462491dd96eeb95ec1e9021d374b0d9934eb7",
+    "chars": 44708,
+    "words": 6158,
+    "method": "arxiv-html",
+    "url": "https://arxiv.org/html/2506.02483v1",
+    "published": "2025-06-03T05:54:20Z",
+    "authors": [
+      "Sina Bagheri Nezhad",
+      "Ameeta Agrawal"
+    ]
+  },
+  {
+    "arxiv_id": "2501.15089",
+    "title": "LongReason: A Synthetic Long-Context Reasoning Benchmark via Context Expansion",
+    "sha256": "9b8890e73d5ffcf7131fd816b38cd984397e6e0df4d50000613525dbc85b759d",
+    "chars": 40808,
+    "words": 5662,
+    "method": "arxiv-html",
+    "url": "https://arxiv.org/html/2501.15089v3",
+    "published": "2025-01-25T05:32:14Z",
+    "authors": [
+      "Zhan Ling",
+      "Kang Liu",
+      "Kai Yan",
+      "Yifan Yang",
+      "Weijian Lin",
+      "Ting-Han Fan"
+    ]
+  }
+]

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/mine_quotes.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""Candidate quote mining: per source, list strong sentences with stable indices.
+The renderer consumes (source, idx) so no quote text is ever transcribed by hand."""
+import json, os, re, sys
+
+BASE = "/root/.hermes/wizard-outputs/sphinx/longctx-arxiv-archive-2026-10-20"
+CORPUS = os.path.join(BASE, "corpus")
+
+MARKERS = ["we find", "we show", "we observe", "we propose", "our results", "results show",
+           "outperform", "degrad", "accuracy", "we introduce", "we benchmark",
+           "state-of-the-art", "we address", "we evaluate", "we demonstrate"]
+BAD = re.compile(r"(arXiv:|License:|License |Back to Abstract|Download PDF|Contents$|"
+                 r"^\s*\d+(\.\d+)*\s+[A-Z]|Introduction |Conclusion |References |Appendix )")
+
+
+def sentences(t):
+    return [s.strip() for s in re.split(r"(?<=[.!?])\s+", t) if s.strip()]
+
+
+def main():
+    out = []
+    for fn in sorted(os.listdir(CORPUS)):
+        if not fn.endswith(".txt"):
+            continue
+        aid = fn[:-4]
+        txt = open(os.path.join(CORPUS, fn), encoding="utf-8").read()
+        idx = 0
+        for s in sentences(txt):
+            if idx >= 8:
+                break
+            if len(s) < 90 or len(s) > 420 or not s.endswith(".") or BAD.search(s):
+                continue
+            if not any(m in s.lower() for m in MARKERS):
+                continue
+            if s.count(",") < 2:  # require some substance
+                continue
+            out.append({"source": aid, "idx": idx, "quote": s})
+            idx += 1
+    json.dump(out, open(os.path.join(BASE, "candidates.json"), "w"), indent=2)
+    print(f"candidates={len(out)}")
+    cur = None
+    for c in out:
+        if c["source"] != cur:
+            cur = c["source"]
+            print("\n=== " + cur)
+        print(f"[{c['idx']}] {c['quote']}")
+
+
+if __name__ == "__main__":
+    main()

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/records.json

@@ -0,0 +1,218 @@
+{
+  "records": [
+    {
+      "n": 1,
+      "section": "1. The core finding: reasoning degrades as context grows",
+      "label": "webagent-degradation",
+      "claim": "Four popular agentic models lose almost all success once context grows: success falls from 40-50% in baseline conditions to under 10% in long-context scenarios.",
+      "quote": "Through extensive evaluation of four popular models, Claude-3.7, GPT-4.1, Llama 4, and o4-mini, we observe a dramatic performance degradation as context length increases, with success rates dropping from 40-50% in baseline conditions to less than 10% in long context scenarios.",
+      "arxiv_id": "2512.04307"
+    },
+    {
+      "n": 2,
+      "section": "1. The core finding: reasoning degrades as context grows",
+      "label": "aggregation-struggle",
+      "claim": "Frontier models themselves struggle specifically at information aggregation as input length grows.",
+      "quote": "(2024), inter alia), we find that models struggle with information aggregation as the input length grows.",
+      "arxiv_id": "2511.02817"
+    },
+    {
+      "n": 3,
+      "section": "1. The core finding: reasoning degrades as context grows",
+      "label": "distributed-clues",
+      "claim": "Performance depends on where the evidence sits: Claude 3.5 is much weaker when clues are spread through the context than when they are grouped together.",
+      "quote": "Additionally, we observe that for these problem types, Claude 3.5 shows much lower performance when the clues are distributed separately throughout the context, compared to when the clues are grouped together.",
+      "arxiv_id": "2501.15089"
+    },
+    {
+      "n": 4,
+      "section": "1. The core finding: reasoning degrades as context grows",
+      "label": "near-zero-accuracy",
+      "claim": "Without retrieval support, LLM-only accuracy on long multilingual context falls to almost 0% at 128K words for both GPT-4o-mini and Llama 3.2.",
+      "quote": "Context length From the results presented in Figure 2, we observe that both GPT-4o-mini and Llama 3.2 exhibit declining accuracy as context length increases in LLM only (solid lines) scenario, with accuracy dropping to almost 0% as context lengths reach 128K words.",
+      "arxiv_id": "2506.02483"
+    },
+    {
+      "n": 5,
+      "section": "1. The core finding: reasoning degrades as context grows",
+      "label": "flat-model",
+      "claim": "Not every model degrades: Gemini-1.5 Pro shows negligible drop from 8K to 128K and outperforms other closed-source models on this axis.",
+      "quote": "For long-context reasoning performance, Gemini-1.5 Pro outperforms all other closed-source models, exhibiting negligible performance drop when extending the context length from 8K to 128K.",
+      "arxiv_id": "2501.15089"
+    },
+    {
+      "n": 6,
+      "section": "2. Why it degrades: distractors, spurious correlation, lost-in-the-middle",
+      "label": "distractors",
+      "claim": "PERK attributes the degradation to two causes: more irrelevant distractor information in longer contexts and more complex multi-hop reasoning problems.",
+      "quote": "These challenges arise because longer contexts contain more irrelevant distractor information, and may also be attached to more complex reasoning problems (i.e., multiple hops), both of which degrade LLM performance (Chen et al., 2023b).",
+      "arxiv_id": "2507.06415"
+    },
+    {
+      "n": 7,
+      "section": "2. Why it degrades: distractors, spurious correlation, lost-in-the-middle",
+      "label": "context-rot",
+      "claim": "DISCO names the failure mode 'context rot' and ties it to the lost-in-the-middle phenomenon, where attention cannot separate signal from noise as sequence length grows.",
+      "quote": "This coupling creates a critical bottleneck: as LL grows, the complexity of the grounding term P\u0398\u200b(\ud835\udc9b\u2223\ud835\udc99,q)P_{\\Theta}(\\bm{z}\\!\\mid\\!\\bm{x},q) degrades rapidly due to architectural limitations (e.g., context rot and the \u201clost-in-the-middle\u201d phenomenon), where attention mechanisms fail to distinguish signal from noise.",
+      "arxiv_id": "2609.33485"
+    },
+    {
+      "n": 8,
+      "section": "2. Why it degrades: distractors, spurious correlation, lost-in-the-middle",
+      "label": "spurious-correlation",
+      "claim": "In robot policy learning, longer context raises memory cost and degrades performance through spurious correlations the policy latches onto.",
+      "quote": "As context length increases, training becomes increasingly expensive due to rising memory demands, and policy performance often degrades as a result of spurious correlations.",
+      "arxiv_id": "2505.09561"
+    },
+    {
+      "n": 9,
+      "section": "2. Why it degrades: distractors, spurious correlation, lost-in-the-middle",
+      "label": "where-ptp-helps",
+      "claim": "The benefit of Past-Token Prediction concentrates in the policy head that does sequence modelling, not in the visual encoder.",
+      "quote": "Crucially, we find that the benefits of PTP primarily emerge in the policy head for sequence modeling, rather than the visual encoder.",
+      "arxiv_id": "2505.09561"
+    },
+    {
+      "n": 10,
+      "section": "3. Benchmarks and datasets built to measure this",
+      "label": "detectiveqa-size",
+      "claim": "DetectiveQA scales narrative long-context reasoning to over 100k tokens per instance, 1200 English and Chinese questions, each with about 8 reference reasoning steps.",
+      "quote": "\u2022 We propose DetectiveQA, a human-annotated evaluation of narrative reasoning in long contexts, averaging over 100k tokens, with 1200 questions in English and Chinese, each paired with reference steps, averaging over 8 steps.",
+      "arxiv_id": "2409.02465"
+    },
+    {
+      "n": 11,
+      "section": "3. Benchmarks and datasets built to measure this",
+      "label": "longreason-construction",
+      "claim": "LongReason synthesizes long-context reasoning questions by context expansion of short-context reasoning questions, giving controlled 8K-128K variants.",
+      "quote": "To address this gap and enable a more comprehensive evaluation of the long-context reasoning capabilities of current LLMs, we propose a new synthetic benchmark, LongReason, which is constructed by synthesizing long-context reasoning questions from a varied set of short-context reasoning questions through context expansion.",
+      "arxiv_id": "2501.15089"
+    },
+    {
+      "n": 12,
+      "section": "3. Benchmarks and datasets built to measure this",
+      "label": "cot-in-synthetic-data",
+      "claim": "LongFinanceQA embeds intermediate chain-of-thought reasoning before the final answer, which the authors argue improves accuracy and interpretability.",
+      "quote": "Unlike existing long-context synthetic data, LongFinanceQA includes intermediate CoT reasoning before the final conclusion, which encourages LLMs to perform explicit reasoning, improving accuracy and interpretability in long-context understanding.",
+      "arxiv_id": "2502.13127"
+    },
+    {
+      "n": 13,
+      "section": "3. Benchmarks and datasets built to measure this",
+      "label": "what-actually-helps",
+      "claim": "Ablation in pi-squared shows reasoning style contributes little, while faithful reasoning patterns from back translation and grounded realistic long context are what matter.",
+      "quote": "Through deeper analyses, we observe that reasoning style contributes little, while faithful reasoning patterns discovered by back translation and grounded realistic long context are crucial for the improvement.",
+      "arxiv_id": "2604.05114"
+    },
+    {
+      "n": 14,
+      "section": "3. Benchmarks and datasets built to measure this",
+      "label": "table-pipeline",
+      "claim": "The pi-squared pipeline uses tables as structured intermediate representations to produce verifiable long-context reasoning data across domains.",
+      "quote": "Our contributions are as follows: \u2219\\bullet We propose \u03c02\\pi^{2}, a QA curation pipeline that leverages tables as structured intermediate representations to generate verifiable, long-context, complex reasoning data across domains (\u00a72).",
+      "arxiv_id": "2604.05114"
+    },
+    {
+      "n": 15,
+      "section": "4. Architectural and training fixes",
+      "label": "test-time-learning",
+      "claim": "PERK reframes long-context reasoning as test-time learning: the model encodes the context at inference time via gradient-based parameter adaptation.",
+      "quote": "In this work, we address these challenges of long-context reasoning by reframing it as test-time learning, enabling models to encode context at inference time using gradient-based parameter adaptation.",
+      "arxiv_id": "2507.06415"
+    },
+    {
+      "n": 16,
+      "section": "4. Architectural and training fixes",
+      "label": "length-generalization",
+      "claim": "A model trained on 8K contexts keeps working at 64K and 128K and beats models with native 512K and 1M context windows.",
+      "quote": "PERK trained on 8K-token contexts maintains decent performance on 64K and 128K windows, consistently surpassing FT-ICR length generalization, and even outperforming models with native 512K and 1M context windows.",
+      "arxiv_id": "2507.06415"
+    },
+    {
+      "n": 17,
+      "section": "4. Architectural and training fixes",
+      "label": "mka-routing",
+      "claim": "Memory-Keyed Attention splits memory into local, session and long-term levels and learns to route each query token across them.",
+      "quote": "In this paper, we propose Memory-Keyed Attention (MKA), a novel attention mechanism that hierarchically organizes memory into three levels-local (L1), session (L2), and long-term (L3)-and dynamically learns how to route each query token across these sources.",
+      "arxiv_id": "2603.20586"
+    },
+    {
+      "n": 18,
+      "section": "4. Architectural and training fixes",
+      "label": "past-token-prediction",
+      "claim": "Past-Token Prediction adds an auxiliary task in which the policy predicts past action tokens as well as future ones.",
+      "quote": "To address this, we introduce Past-Token Prediction (PTP), an auxiliary task in which the policy learns to predict past action tokens alongside future ones.",
+      "arxiv_id": "2505.09561"
+    },
+    {
+      "n": 19,
+      "section": "4. Architectural and training fixes",
+      "label": "neurosymbolic",
+      "claim": "NSAR combines symbolic logic with neural inference and substantially outperforms purely retrieval-based and neural-only methods on cross-lingual long-context tasks.",
+      "quote": "\u2022 Through extensive experiments on cross-lingual, long-context tasks, we demonstrate that NSAR substantially outperforms purely retrieval-based and neural-only methods.",
+      "arxiv_id": "2506.02483"
+    },
+    {
+      "n": 20,
+      "section": "4. Architectural and training fixes",
+      "label": "disco-rot-fix",
+      "claim": "On RULER-QA at 1M tokens, DISCO holds 78.4% accuracy while standard retrieval baselines collapse to 10.9%, i.e. it removes the context-rot penalty.",
+      "quote": "Experimental results demonstrate that DISCO effectively eliminates context rot: on RULER-QA (1M tokens), DISCO with Qwen3-8B (Qwen, 2025) maintains 78.4% accuracy while standard retrieval baselines collapse to 10.9%.",
+      "arxiv_id": "2609.33485"
+    },
+    {
+      "n": 21,
+      "section": "5. Cost, serving, and model behaviour at scale",
+      "label": "disco-cost",
+      "claim": "DISCO beats full-context models by up to 9.8 points on LongBench v2 while cutting inference cost by over 80%.",
+      "quote": "Furthermore, it outperforms full-context models by up to 9.8 points on LongBench v2 and matches frontier models like Gemini-3-Pro-Preview while reducing inference costs by over 80%, establishing a highly efficient paradigm for robust long-context inference.",
+      "arxiv_id": "2609.33485"
+    },
+    {
+      "n": 22,
+      "section": "5. Cost, serving, and model behaviour at scale",
+      "label": "refusal-behaviour",
+      "claim": "Model behaviour changes with length: at 256K GPT-5 attempts 83% of queries and answers 44.5% correctly, while GPT-5.2 attempts only 32% with 52.8% accuracy on those attempts.",
+      "quote": "This is because GPT 5.2 is much more likely to refuse to perform the task; at 256K, GPT-5 attempts 83% of queries and answers 44.5% of these correctly, while GPT-5.2 attempts only 32% with an accuracy of 52.8%.",
+      "arxiv_id": "2511.02817"
+    },
+    {
+      "n": 23,
+      "section": "5. Cost, serving, and model behaviour at scale",
+      "label": "gemini-deepthink",
+      "claim": "Gemini 2.5's Deep Think mode reaches state-of-the-art results on Olympiad math (USAMO 2025), competitive coding (LiveCodeBench) and multimodality (MMMU).",
+      "quote": "Deep Think enables Gemini to creatively produce multiple hypotheses and carefully critique them before arriving at the final answer, achieving state-of-the-art performances in challenging benchmarks such as Olympiad math (USAMO 2025), competitive coding (LiveCodeBench), and multimodality (MMMU), see more details at (Doshi, 2025b).",
+      "arxiv_id": "2507.06261"
+    },
+    {
+      "n": 24,
+      "section": "5. Cost, serving, and model behaviour at scale",
+      "label": "gemini-factuality",
+      "claim": "Gemini 2.5 is reported at state-of-the-art on factuality suites including SimpleQA, FACTS Grounding and the Vectara Hallucination Leaderboard.",
+      "quote": "These models exhibit state-of-the-art performance across a suite of factuality benchmarks, including SimpleQA for parametric knowledge (Wei et al., 2024), FACTS Grounding for faithfulness to provided documents (Jacovi et al., 2024; Jacovi et al., 2025), and the Vectara Hallucination Leaderboard (Hughes et al., 2023), cementing Gemini as the model of choice for information-seeking demands.",
+      "arxiv_id": "2507.06261"
+    },
+    {
+      "n": 25,
+      "section": "5. Cost, serving, and model behaviour at scale",
+      "label": "pai-pipeline",
+      "claim": "The PAI framework generates reasoning-augmented answers in three steps: property extraction, property-based retrieval, and summarization.",
+      "quote": "Following this methodology, we propose the Property-based Agentic Inference (PAI) framework, illustrated in Figure 2, containing three steps: (1) property extraction, (2) property-based retrieval, and (3) summarization.",
+      "arxiv_id": "2502.13127"
+    }
+  ],
+  "sources_covered": [
+    "2409.02465",
+    "2501.15089",
+    "2502.13127",
+    "2505.09561",
+    "2506.02483",
+    "2507.06261",
+    "2507.06415",
+    "2511.02817",
+    "2512.04307",
+    "2603.20586",
+    "2604.05114",
+    "2609.33485"
+  ]
+}

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/render_synthesis.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""Render synthesis.md + README.md from candidates.json + claims.json.
+Quotes are taken verbatim from candidates.json by (source, idx) — never typed by hand."""
+import json, os, re, sys
+
+BASE = "/root/.hermes/wizard-outputs/sphinx/longctx-arxiv-archive-2026-10-20"
+
+
+def main():
+    cands = {(c["source"], c["idx"]): c["quote"] for c in json.load(open(os.path.join(BASE, "candidates.json")))}
+    manifest = {m["arxiv_id"]: m for m in json.load(open(os.path.join(BASE, "manifest.json")))}
+    claims = json.load(open(os.path.join(BASE, "claims.json")))
+    records, bad = [], []
+    n = 0
+    for sec in claims["sections"]:
+        for r in sec["records"]:
+            q = cands.get((r["source"], r["idx"]))
+            if not q:
+                bad.append((r["source"], r["idx"], "no candidate"))
+                continue
+            q = re.sub(r"\s+", " ", q).strip()
+            if len(q) < 60 or len(q) > 600 or "\n" in q or '"' in q:
+                bad.append((r["source"], r["idx"], f"len={len(q)}"))
+                continue
+            if len(r["claim"]) < 40:
+                bad.append((r["source"], r["idx"], "claim too short"))
+                continue
+            if r["source"] not in manifest:
+                bad.append((r["source"], r["idx"], "unknown source"))
+                continue
+            n += 1
+            records.append({"n": n, "section": sec["title"], "label": r["label"],
+                            "claim": r["claim"], "quote": q, "arxiv_id": r["source"]})
+    if bad:
+        print("BAD records:", bad)
+        sys.exit(1)
+
+    lines = []
+    lines.append("# Long-context reasoning: a grounded arXiv archive")
+    lines.append("")
+    lines.append(f"{len(manifest)} papers, {len(records)} verbatim evidence records. Every QUOTE below is copied byte-for-byte from "
+                 "the cached paper text; `verify.py` re-checks each one against the corpus and exits nonzero on any miss.")
+    lines.append("")
+    tot = sum(m["chars"] for m in manifest.values())
+    lines.append(f"Corpus: {len(manifest)} papers, {tot:,} normalized characters cached under `corpus/` "
+                 f"(sha256 recorded in `manifest.json`). Retrieval: arXiv HTML full text.")
+    lines.append("")
+    lines.append("| arXiv id | title | chars | method |")
+    lines.append("|---|---|---|---|")
+    for aid in sorted(manifest):
+        m = manifest[aid]
+        lines.append(f"| {aid} | {m['title']} | {m['chars']:,} | {m['method']} |")
+    lines.append("")
+    for sec in claims["sections"]:
+        lines.append("## " + sec["title"])
+        lines.append("")
+        for r in sec["records"]:
+            rec = next(x for x in records if x["label"] == r["label"])
+            lines.append(f"### E{rec['n']} — {rec['label']}")
+            lines.append(f"RECORD {rec['n']}")
+            lines.append(f"CLAIM: {rec['claim']}")
+            lines.append(f'QUOTE: "{rec["quote"]}"')
+            lines.append(f"SOURCE: {rec['arxiv_id']}")
+            lines.append("")
+    with open(os.path.join(BASE, "synthesis.md"), "w") as fh:
+        fh.write("\n".join(lines) + "\n")
+
+    covered = sorted({r["arxiv_id"] for r in records})
+    md = ["# README — longctx-arxiv-archive", "",
+          "Grounded research archive for the Archive lane (long-context research).", "",
+          "## Contents", "",
+          "- `synthesis.md` — themed synthesis; each evidence record carries a verbatim quote + arXiv source id.",
+          "- `corpus/<id>.txt` — normalized plain text of each paper (single-space collapsed).",
+          "- `manifest.json` — per-paper sha256, char/word counts, retrieval method, title, authors, date.",
+          "- `candidates.json` — mined candidate sentences with stable (source, idx) keys.",
+          "- `claims.json` — operator-written claims keyed by (source, idx); quotes are never hand-typed.",
+          "- `records.json` — flattened evidence records.",
+          "- `verify.py` — independent checker; exit 0 = all quotes verbatim and corpus intact.",
+          "- `falsify_verify.py` — mutation tests: the verifier must exit nonzero on a fabricated quote, a",
+          "  corrupted corpus file, and a missing corpus file (measured: all three exit 1).", "",
+          "## Reproduce", "",
+          "```",
+          "python3 fetch_corpus.py          # arXiv HTML/PDF -> corpus/ + sources.json",
+          "python3 build_archive.py normalize   # collapse whitespace, recompute sha256 -> manifest.json",
+          "python3 mine_quotes.py           # -> candidates.json",
+          "python3 render_synthesis.py      # -> synthesis.md",
+          "python3 verify.py                # exit code is the verdict",
+          "```", "",
+          f"Coverage: {len(covered)}/{len(manifest)} sources cited; {len(records)} records; "
+          f"{sum(m['chars'] for m in manifest.values()):,} corpus characters.", ""]
+    with open(os.path.join(BASE, "README.md"), "w") as fh:
+        fh.write("\n".join(md))
+    json.dump({"records": records, "sources_covered": covered},
+              open(os.path.join(BASE, "records.json"), "w"), indent=2)
+    print(f"rendered {len(records)} records covering {len(covered)}/{len(manifest)} sources")
+
+
+if __name__ == "__main__":
+    main()

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/synthesis.md

@@ -0,0 +1,181 @@
+# Long-context reasoning: a grounded arXiv archive
+
+12 papers, 25 verbatim evidence records. Every QUOTE below is copied byte-for-byte from the cached paper text; `verify.py` re-checks each one against the corpus and exits nonzero on any miss.
+
+Corpus: 12 papers, 964,298 normalized characters cached under `corpus/` (sha256 recorded in `manifest.json`). Retrieval: arXiv HTML full text.
+
+| arXiv id | title | chars | method |
+|---|---|---|---|
+| 2409.02465 | DetectiveQA: Evaluating Long-Context Reasoning on Detective Novels | 52,235 | arxiv-html |
+| 2501.15089 | LongReason: A Synthetic Long-Context Reasoning Benchmark via Context Expansion | 40,808 | arxiv-html |
+| 2502.13127 | Facilitating Long Context Understanding via Supervised Chain-of-Thought Reasoning | 68,852 | arxiv-html |
+| 2505.09561 | Learning Long-Context Diffusion Policies via Past-Token Prediction | 58,077 | arxiv-html |
+| 2506.02483 | Enhancing Large Language Models with Neurosymbolic Reasoning for Multilingual Tasks | 44,708 | arxiv-html |
+| 2507.06261 | Gemini 2.5: Pushing the Frontier with Advanced Reasoning, Multimodality, Long Context, and Next Generation Agentic Capabilities | 215,441 | arxiv-html |
+| 2507.06415 | PERK: Long-Context Reasoning as Test-Time Learning | 107,789 | arxiv-html |
+| 2511.02817 | Oolong: Evaluating Long Context Reasoning and Aggregation Capabilities | 96,818 | arxiv-html |
+| 2512.04307 | Evaluating Long-Context Reasoning in LLM-Based WebAgents | 75,916 | arxiv-html |
+| 2603.20586 | MKA: Memory-Keyed Attention for Efficient Long-Context Reasoning | 50,726 | arxiv-html |
+| 2604.05114 | $π^2$: Structure-Originated Reasoning Data Improves Long-Context Reasoning Ability of Large Language Models | 94,666 | arxiv-html |
+| 2609.33485 | DISCO: Distributed Long Context Scaling with Grounding-Reasoning Disaggregation | 58,262 | arxiv-html |
+
+## 1. The core finding: reasoning degrades as context grows
+
+### E1 — webagent-degradation
+RECORD 1
+CLAIM: Four popular agentic models lose almost all success once context grows: success falls from 40-50% in baseline conditions to under 10% in long-context scenarios.
+QUOTE: "Through extensive evaluation of four popular models, Claude-3.7, GPT-4.1, Llama 4, and o4-mini, we observe a dramatic performance degradation as context length increases, with success rates dropping from 40-50% in baseline conditions to less than 10% in long context scenarios."
+SOURCE: 2512.04307
+
+### E2 — aggregation-struggle
+RECORD 2
+CLAIM: Frontier models themselves struggle specifically at information aggregation as input length grows.
+QUOTE: "(2024), inter alia), we find that models struggle with information aggregation as the input length grows."
+SOURCE: 2511.02817
+
+### E3 — distributed-clues
+RECORD 3
+CLAIM: Performance depends on where the evidence sits: Claude 3.5 is much weaker when clues are spread through the context than when they are grouped together.
+QUOTE: "Additionally, we observe that for these problem types, Claude 3.5 shows much lower performance when the clues are distributed separately throughout the context, compared to when the clues are grouped together."
+SOURCE: 2501.15089
+
+### E4 — near-zero-accuracy
+RECORD 4
+CLAIM: Without retrieval support, LLM-only accuracy on long multilingual context falls to almost 0% at 128K words for both GPT-4o-mini and Llama 3.2.
+QUOTE: "Context length From the results presented in Figure 2, we observe that both GPT-4o-mini and Llama 3.2 exhibit declining accuracy as context length increases in LLM only (solid lines) scenario, with accuracy dropping to almost 0% as context lengths reach 128K words."
+SOURCE: 2506.02483
+
+### E5 — flat-model
+RECORD 5
+CLAIM: Not every model degrades: Gemini-1.5 Pro shows negligible drop from 8K to 128K and outperforms other closed-source models on this axis.
+QUOTE: "For long-context reasoning performance, Gemini-1.5 Pro outperforms all other closed-source models, exhibiting negligible performance drop when extending the context length from 8K to 128K."
+SOURCE: 2501.15089
+
+## 2. Why it degrades: distractors, spurious correlation, lost-in-the-middle
+
+### E6 — distractors
+RECORD 6
+CLAIM: PERK attributes the degradation to two causes: more irrelevant distractor information in longer contexts and more complex multi-hop reasoning problems.
+QUOTE: "These challenges arise because longer contexts contain more irrelevant distractor information, and may also be attached to more complex reasoning problems (i.e., multiple hops), both of which degrade LLM performance (Chen et al., 2023b)."
+SOURCE: 2507.06415
+
+### E7 — context-rot
+RECORD 7
+CLAIM: DISCO names the failure mode 'context rot' and ties it to the lost-in-the-middle phenomenon, where attention cannot separate signal from noise as sequence length grows.
+QUOTE: "This coupling creates a critical bottleneck: as LL grows, the complexity of the grounding term PΘ​(𝒛∣𝒙,q)P_{\Theta}(\bm{z}\!\mid\!\bm{x},q) degrades rapidly due to architectural limitations (e.g., context rot and the “lost-in-the-middle” phenomenon), where attention mechanisms fail to distinguish signal from noise."
+SOURCE: 2609.33485
+
+### E8 — spurious-correlation
+RECORD 8
+CLAIM: In robot policy learning, longer context raises memory cost and degrades performance through spurious correlations the policy latches onto.
+QUOTE: "As context length increases, training becomes increasingly expensive due to rising memory demands, and policy performance often degrades as a result of spurious correlations."
+SOURCE: 2505.09561
+
+### E9 — where-ptp-helps
+RECORD 9
+CLAIM: The benefit of Past-Token Prediction concentrates in the policy head that does sequence modelling, not in the visual encoder.
+QUOTE: "Crucially, we find that the benefits of PTP primarily emerge in the policy head for sequence modeling, rather than the visual encoder."
+SOURCE: 2505.09561
+
+## 3. Benchmarks and datasets built to measure this
+
+### E10 — detectiveqa-size
+RECORD 10
+CLAIM: DetectiveQA scales narrative long-context reasoning to over 100k tokens per instance, 1200 English and Chinese questions, each with about 8 reference reasoning steps.
+QUOTE: "• We propose DetectiveQA, a human-annotated evaluation of narrative reasoning in long contexts, averaging over 100k tokens, with 1200 questions in English and Chinese, each paired with reference steps, averaging over 8 steps."
+SOURCE: 2409.02465
+
+### E11 — longreason-construction
+RECORD 11
+CLAIM: LongReason synthesizes long-context reasoning questions by context expansion of short-context reasoning questions, giving controlled 8K-128K variants.
+QUOTE: "To address this gap and enable a more comprehensive evaluation of the long-context reasoning capabilities of current LLMs, we propose a new synthetic benchmark, LongReason, which is constructed by synthesizing long-context reasoning questions from a varied set of short-context reasoning questions through context expansion."
+SOURCE: 2501.15089
+
+### E12 — cot-in-synthetic-data
+RECORD 12
+CLAIM: LongFinanceQA embeds intermediate chain-of-thought reasoning before the final answer, which the authors argue improves accuracy and interpretability.
+QUOTE: "Unlike existing long-context synthetic data, LongFinanceQA includes intermediate CoT reasoning before the final conclusion, which encourages LLMs to perform explicit reasoning, improving accuracy and interpretability in long-context understanding."
+SOURCE: 2502.13127
+
+### E13 — what-actually-helps
+RECORD 13
+CLAIM: Ablation in pi-squared shows reasoning style contributes little, while faithful reasoning patterns from back translation and grounded realistic long context are what matter.
+QUOTE: "Through deeper analyses, we observe that reasoning style contributes little, while faithful reasoning patterns discovered by back translation and grounded realistic long context are crucial for the improvement."
+SOURCE: 2604.05114
+
+### E14 — table-pipeline
+RECORD 14
+CLAIM: The pi-squared pipeline uses tables as structured intermediate representations to produce verifiable long-context reasoning data across domains.
+QUOTE: "Our contributions are as follows: ∙\bullet We propose π2\pi^{2}, a QA curation pipeline that leverages tables as structured intermediate representations to generate verifiable, long-context, complex reasoning data across domains (§2)."
+SOURCE: 2604.05114
+
+## 4. Architectural and training fixes
+
+### E15 — test-time-learning
+RECORD 15
+CLAIM: PERK reframes long-context reasoning as test-time learning: the model encodes the context at inference time via gradient-based parameter adaptation.
+QUOTE: "In this work, we address these challenges of long-context reasoning by reframing it as test-time learning, enabling models to encode context at inference time using gradient-based parameter adaptation."
+SOURCE: 2507.06415
+
+### E16 — length-generalization
+RECORD 16
+CLAIM: A model trained on 8K contexts keeps working at 64K and 128K and beats models with native 512K and 1M context windows.
+QUOTE: "PERK trained on 8K-token contexts maintains decent performance on 64K and 128K windows, consistently surpassing FT-ICR length generalization, and even outperforming models with native 512K and 1M context windows."
+SOURCE: 2507.06415
+
+### E17 — mka-routing
+RECORD 17
+CLAIM: Memory-Keyed Attention splits memory into local, session and long-term levels and learns to route each query token across them.
+QUOTE: "In this paper, we propose Memory-Keyed Attention (MKA), a novel attention mechanism that hierarchically organizes memory into three levels-local (L1), session (L2), and long-term (L3)-and dynamically learns how to route each query token across these sources."
+SOURCE: 2603.20586
+
+### E18 — past-token-prediction
+RECORD 18
+CLAIM: Past-Token Prediction adds an auxiliary task in which the policy predicts past action tokens as well as future ones.
+QUOTE: "To address this, we introduce Past-Token Prediction (PTP), an auxiliary task in which the policy learns to predict past action tokens alongside future ones."
+SOURCE: 2505.09561
+
+### E19 — neurosymbolic
+RECORD 19
+CLAIM: NSAR combines symbolic logic with neural inference and substantially outperforms purely retrieval-based and neural-only methods on cross-lingual long-context tasks.
+QUOTE: "• Through extensive experiments on cross-lingual, long-context tasks, we demonstrate that NSAR substantially outperforms purely retrieval-based and neural-only methods."
+SOURCE: 2506.02483
+
+### E20 — disco-rot-fix
+RECORD 20
+CLAIM: On RULER-QA at 1M tokens, DISCO holds 78.4% accuracy while standard retrieval baselines collapse to 10.9%, i.e. it removes the context-rot penalty.
+QUOTE: "Experimental results demonstrate that DISCO effectively eliminates context rot: on RULER-QA (1M tokens), DISCO with Qwen3-8B (Qwen, 2025) maintains 78.4% accuracy while standard retrieval baselines collapse to 10.9%."
+SOURCE: 2609.33485
+
+## 5. Cost, serving, and model behaviour at scale
+
+### E21 — disco-cost
+RECORD 21
+CLAIM: DISCO beats full-context models by up to 9.8 points on LongBench v2 while cutting inference cost by over 80%.
+QUOTE: "Furthermore, it outperforms full-context models by up to 9.8 points on LongBench v2 and matches frontier models like Gemini-3-Pro-Preview while reducing inference costs by over 80%, establishing a highly efficient paradigm for robust long-context inference."
+SOURCE: 2609.33485
+
+### E22 — refusal-behaviour
+RECORD 22
+CLAIM: Model behaviour changes with length: at 256K GPT-5 attempts 83% of queries and answers 44.5% correctly, while GPT-5.2 attempts only 32% with 52.8% accuracy on those attempts.
+QUOTE: "This is because GPT 5.2 is much more likely to refuse to perform the task; at 256K, GPT-5 attempts 83% of queries and answers 44.5% of these correctly, while GPT-5.2 attempts only 32% with an accuracy of 52.8%."
+SOURCE: 2511.02817
+
+### E23 — gemini-deepthink
+RECORD 23
+CLAIM: Gemini 2.5's Deep Think mode reaches state-of-the-art results on Olympiad math (USAMO 2025), competitive coding (LiveCodeBench) and multimodality (MMMU).
+QUOTE: "Deep Think enables Gemini to creatively produce multiple hypotheses and carefully critique them before arriving at the final answer, achieving state-of-the-art performances in challenging benchmarks such as Olympiad math (USAMO 2025), competitive coding (LiveCodeBench), and multimodality (MMMU), see more details at (Doshi, 2025b)."
+SOURCE: 2507.06261
+
+### E24 — gemini-factuality
+RECORD 24
+CLAIM: Gemini 2.5 is reported at state-of-the-art on factuality suites including SimpleQA, FACTS Grounding and the Vectara Hallucination Leaderboard.
+QUOTE: "These models exhibit state-of-the-art performance across a suite of factuality benchmarks, including SimpleQA for parametric knowledge (Wei et al., 2024), FACTS Grounding for faithfulness to provided documents (Jacovi et al., 2024; Jacovi et al., 2025), and the Vectara Hallucination Leaderboard (Hughes et al., 2023), cementing Gemini as the model of choice for information-seeking demands."
+SOURCE: 2507.06261
+
+### E25 — pai-pipeline
+RECORD 25
+CLAIM: The PAI framework generates reasoning-augmented answers in three steps: property extraction, property-based retrieval, and summarization.
+QUOTE: "Following this methodology, we propose the Property-based Agentic Inference (PAI) framework, illustrated in Figure 2, containing three steps: (1) property extraction, (2) property-based retrieval, and (3) summarization."
+SOURCE: 2502.13127
+

wizard-work/sphinx/longctx-arxiv-archive-2026-10-20/verify.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Independent verifier for the long-context archive.
+Exit 0 = every claim is grounded in the cached corpus and the corpus is intact.
+Exit nonzero = at least one fabricated/mismatched quote, or corrupted corpus."""
+import hashlib, json, os, re, sys
+
+BASE = os.path.dirname(os.path.abspath(__file__))
+CORPUS = os.path.join(BASE, "corpus")
+
+fails, checks = [], 0
+
+
+def ck(cond, msg):
+    global checks
+    checks += 1
+    if not cond:
+        fails.append(msg)
+
+
+def main():
+    manifest = json.load(open(os.path.join(BASE, "manifest.json")))
+    synth = open(os.path.join(BASE, "synthesis.md"), encoding="utf-8").read()
+
+    # --- corpus integrity -------------------------------------------------
+    texts = {}
+    for m in manifest:
+        aid = m["arxiv_id"]
+        p = os.path.join(CORPUS, aid + ".txt")
+        ck(os.path.exists(p), f"missing corpus file for {aid}")
+        if not os.path.exists(p):
+            continue
+        raw = open(p, "rb").read()
+        sha = hashlib.sha256(raw).hexdigest()
+        ck(sha == m["sha256"], f"sha256 mismatch for {aid}: manifest {m['sha256'][:12]} vs disk {sha[:12]}")
+        txt = raw.decode("utf-8")
+        ck(len(txt) == m["chars"], f"char count mismatch for {aid}")
+        texts[aid] = txt
+    ck(len(manifest) >= 10, f"only {len(manifest)} sources archived")
+
+    # --- evidence records -------------------------------------------------
+    blocks = re.findall(r'^RECORD (\d+)\nCLAIM: (.+)\nQUOTE: "(.+)"\nSOURCE: (\S+)$',
+                        synth, re.M)
+    ck(len(blocks) >= 25, f"only {len(blocks)} evidence records found (need >= 25)")
+
+    seen_ids, covered = set(), set()
+    for num, claim, quote, src in blocks:
+        ck(num not in seen_ids, f"duplicate RECORD number {num}")
+        seen_ids.add(num)
+        ck(len(claim.strip()) >= 40, f"RECORD {num}: claim too thin ({len(claim)} chars)")
+        ck(60 <= len(quote) <= 600, f"RECORD {num}: quote length {len(quote)} out of range")
+        ck(src in texts, f"RECORD {num}: cited source {src} not in corpus")
+        if src not in texts:
+            continue
+        cnt = texts[src].count(quote)
+        ck(cnt >= 1, f"RECORD {num}: QUOTE NOT FOUND verbatim in {src} corpus text")
+        others = [a for a, t in texts.items() if a != src and quote in t]
+        ck(len(others) == 0, f"RECORD {num}: quote is not source-specific (also in {others})")
+        ck(quote not in ("", " " * len(quote)), f"RECORD {num}: blank quote")
+        covered.add(src)
+    ck(len(covered) == len(manifest),
+       f"only {len(covered)}/{len(manifest)} sources cited: missing {sorted(set(texts) - covered)}")
+
+    # --- no stubs ---------------------------------------------------------
+    for marker in ("TODO", "TBD", "FIXME", "<placeholder", "XXX"):
+        ck(marker not in synth, f"stub marker {marker!r} present in synthesis.md")
+
+    print(f"checks run: {checks}")
+    print(f"evidence records: {len(blocks)}  sources cited: {len(covered)}/{len(manifest)}")
+    if fails:
+        print(f"FAIL ({len(fails)}):")
+        for f in fails[:20]:
+            print("  -", f)
+        return 1
+    print("ALL CHECKS PASSED: every quote is verbatim in its cited source; corpus sha256 intact")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())