The Reading Path

The November papers stand on a short, readable literature. This page orders the prerequisite entries as a curriculum: interfaces and benchmarks first (the ground the loops stand on), then the prompt-optimization generation the November papers build past, then the harness-optimization ancestors, then the weight-space alternative, then the measurement-integrity cluster, then the cyber instances. One line each on what to take from it.

Evidence level: every entry here is abstract-level. Bibliographic details (title, authors, arXiv ID) were checked against arXiv records on Nov 20, 2026, and each entry's headline numbers come from its abstract or record, not from a full-text read. CyberGym-E2E was checked on its arXiv HTML page rather than a separate abstract page. The "Take" lines are the site's reading of why each entry matters. If time is short, read one ancestor in full: Meta-Harness, entry 11.

Stage 1: The interface and the benchmarks

  1. SWE-bench: Can Language Models Resolve Real-World GitHub Issues? (Jimenez et al., arXiv:2310.06770, 2023). 2,294 tasks mined from real GitHub issues and merged pull requests across 12 Python repositories; grading by fail-to-pass and pass-to-pass tests; the best model at publication solved 1.96%. Take: the task shape (issue, patch, test verdict) and grading discipline that Papers 1 and 3 both operate on, and Paper 3's sourcing method in embryo: landed changes as tasks.
  2. SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering (Yang et al., arXiv:2405.15793, 2024). A purpose-built interface between model and computer (file viewers with line ranges, edit commands with lint checks) makes the same model markedly better: 12.5% pass@1 on SWE-bench, state of the art at the time. Take: the founding demonstration that the harness is a performance variable independent of the model, the premise of this entire site. Paper 1's accepted action-interface edit is this thesis applied by an optimizer.
  3. Training Software Engineering Agents and Verifiers with SWE-Gym (Pan et al., arXiv:2412.21139, 2024). Packages 2,438 real tasks with executable runtimes; trains agents on trajectories sampled inside the environment, and trains verifiers on those trajectories to rank candidate solutions. Take: the two inherited ideas: the gym (a runnable task environment, the precondition for any optimization loop) and the verifier as a separable, trainable component.
  4. Terminal-Bench (Merrill, Shaw, Carlini et al., arXiv:2601.11868, 2026). 89 curated tasks in Terminal-Bench 2.0, in real terminal environments, each with a unique environment, a human-written solution, and comprehensive verification; frontier agents scored under 65% at release. Take: the shift from repo-bound tasks to open-ended environment tasks, the shape a cyber range's tasks take; and Paper 2's coding domain (its versions 2.1 and 4 are that paper's cross-dataset transition).

Stage 2: Optimizing prompts and programs around a frozen model

  1. Reflexion: Language Agents with Verbal Reinforcement Learning (Shinn et al., arXiv:2303.11366, 2023). An agent fails, reflects verbally on the feedback, stores the reflection in a memory buffer, and retries, learning with no weight updates. Take: the seed of the family, and, read through Paper 1, the cautionary tale: single-trajectory reflection invents rules for failures that never happened. Paper 2's memory is what you get when you fix Reflexion's: structured by root cause, with predictions and outcomes attached.
  2. Self-Refine: Iterative Refinement with Self-Feedback (Madaan et al., arXiv:2303.17651, 2023). One model as generator, critic, and refiner, improving its own outputs in a loop with no external check. Take: the intra-task version of the loop (improve the answer), which the November papers lift to the inter-task level (improve the system that answers), and the reason the lift requires an external verifier: a self-critic suffices for style, not for systems.
  3. DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines (Khattab et al., arXiv:2310.03714, 2023). Declare an LM program as modules with signatures; a compiler searches over instructions and demonstrations to maximize a metric on a dev set. Take: the field's central abstraction, the program as a compilable artifact optimized against a metric by a separate optimizer, and the vocabulary (modules, optimizers, dev/test splits) every later paper inherits.
  4. MIPRO: Optimizing Instructions and Demonstrations for Multi-Stage Language Model Programs (Opsahl-Ong et al., arXiv:2406.11695, 2024). Joint, credit-aware, budget-aware optimization of every module's instructions and demonstrations, with a surrogate model over mini-batch evaluations. Take: the mature form of generation-2 search, and the discipline Paper 1 moves from prompts to code: optimize modules separately, respect their interactions.
  5. TextGrad: Automatic "Differentiation" via Text (Yuksekgonul et al., arXiv:2406.07496, 2024). Backpropagation with language as the gradient: an LLM critic generates textual feedback describing how each component's output should change, routed backward through the system to the responsible component. Take: the conceptual bridge between gradient learning and this family: improvement signal as rich natural-language feedback with credit assignment. Paper 1's diagnose-then-patch is this idea made architectural.
  6. GEPA: Reflective Prompt Evolution Can Outperform Reinforcement Learning (Agrawal et al., arXiv:2507.19457, 2025). Evolutionary prompt search with natural-language reflection and a Pareto archive of candidates; outperforms GRPO by about 6% on average across six tasks with up to 35 times fewer rollouts. Take: the strongest published evidence for the family's core bet, that reflective search over a frozen model's surroundings can beat weight-space RL per unit of compute. Both Google November papers cite it.

Stage 3: Optimizing the harness itself

  1. Meta-Harness: End-to-End Optimization of Model Harnesses (Lee et al., arXiv:2603.28052, 2026). An outer-loop proposer searches over harness code with access to source, scores, and full execution traces of all prior candidates through a filesystem, not compressed scalar feedback. Gains include +7.7 points over a state-of-the-art context-management system on online text classification at 4 times fewer context tokens. Take: the direct ancestor: Paper 2's formulation follows it, its classification environment is Paper 2's text-classification domain, and its raw-trace ablation is the evidence that diagnosis needs uncompressed traces. If you read one ancestor in full, read this one.
  2. Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents (Zhang et al., arXiv:2505.22954, 2025). A coding agent rewrites its own code, including the code that does the modifying; variants are validated on benchmarks and kept in an open-ended archive of diverse agents. SWE-bench 20.0% to 50.0%, Polyglot 14.2% to 30.7%. Take: the recursive end of Paper 1's design space, and a clear demonstration of both the power and the hazard: unconstrained self-modification compounds gains and invites overfitting. The November papers are, in different ways, proposals for the discipline this system lacks.
  3. AlphaEvolve: A Coding Agent for Scientific and Algorithmic Discovery (Novikov et al., DeepMind, arXiv:2506.13131, 2025). An evolutionary coding agent scored by automated evaluators, with an evaluation cascade and a diversity-maintaining database; it improved 4x4 complex matrix multiplication for the first time in 56 years and recovered about 0.7% of Google's worldwide compute with a scheduling heuristic. Take: the proof that the loop pattern discovers genuinely new artifacts when the evaluator is trustworthy, and, read in reverse, that the method does not exist without one. The template for applying the skeleton outside agent harnesses entirely.

Stage 4: The weight-space alternative

  1. DeepSeekMath and GRPO (Shao et al., arXiv:2402.03300, 2024). Group Relative Policy Optimization: score a group of sampled outputs, update toward the above-average ones using the group mean as baseline, no critic network. Take: the standard weight-space optimizer the artifact-space methods define themselves against. GRPO keeps the reward scalar and moves the weights; the November papers keep the reward scalar, freeze the weights, and move the code. See Two Spaces.
  2. Tulu 3 and RLVR (Lambert et al., AI2, arXiv:2411.15124, 2024). A fully open post-training recipe whose named contribution, Reinforcement Learning with Verifiable Rewards, trains on mechanically checkable answers with the binary verdict as reward, plus a rigorous decontamination discipline. Take: the reason "verifier" is the load-bearing word of the era, and the training-side instance of the contamination discipline in Stage 5.
  3. Scaling LLM Test-Time Compute Optimally (Snell et al., arXiv:2408.03314, 2024). The optimal way to spend inference compute depends on problem difficulty; a compute-optimal strategy improves efficiency over best-of-N by more than 4 times, and test-time compute lets a smaller model beat a 14-times larger one where it has non-trivial success. Take: why evolved harnesses must be compared against compute-matched best-of-N baselines, and the theory behind Paper 1's Best-of-3 null result: retries help when failures are independent, and a structural defect makes every retry fail the same way.

Stage 5: Measurement integrity

  1. SpecBench: Measuring Reward Hacking in Long-Horizon Coding Agents (Zhao et al., arXiv:2605.21384, 2026). Splits each task into visible validation tests and held-out tests over composed features; the gap between the two pass rates is the reward-hacking measurement. Across 30 systems tasks, every frontier agent tested saturates the visible suite while the held-out gap persists, growing about 28 points per tenfold increase in code size. Take: Goodhart's law with a lab instrument, and the cleanest quantification of why no loop in this family may see its final exam. See Verifiers and Graders.
  2. SWE-bench Goes Live! (Zhang et al., Microsoft, arXiv:2505.23419, 2025). Static benchmarks rot and leak; this replaces the artifact with a pipeline that continuously builds tasks from GitHub issues created since 2024 (1,319 tasks, 93 repositories at initial release), on which models score substantially lower than on the static benchmark. Take: when the artifact contaminates, automate the artifact's production. Paper 3 is this move plus automated validation.

Stage 6: The cyber instances

  1. CyberGym: Evaluating AI Agents' Real-World Cybersecurity Capabilities at Scale (Wang et al., UC Berkeley, arXiv:2506.02548, 2025). 1,507 real vulnerabilities from OSS-Fuzz across 188 projects; the agent must produce a proof-of-concept that reproduces the vulnerability, an execution-based verdict that cannot be argued with. Top combinations reach only about 20% single-trial success. Agents working in the benchmark also discovered 34 zero-day vulnerabilities and 18 historically incomplete patches per the v3 abstract; Berkeley's project page reports 35 and 17, and the discrepancy should be resolved before either figure is published. Take: the cyber instance of the SWE-bench pattern, and the demonstration that cyber owns an honest verifier class. The natural target domain for the whole skeleton; see the cyber version.
  2. CyberGym-E2E (Shi et al., arXiv:2606.04460, 2026). Extends CyberGym across the full vulnerability lifecycle: detection, PoC generation, patch generation, post-patch functionality testing; 920 real vulnerabilities across 139 projects, built by an automated, agent-enhanced pipeline. Agents are comparatively good at patches; detection and PoC generation are the bottleneck. Take: the end-to-end shape of a find, prove, fix, re-verify loop, with the empirical warning that the middle of the chain is the weak link, and a construction method that is Paper 3's pattern in cyber clothing.

November family additions

Beyond the prerequisites, the November 2026 cluster itself: the three main papers and TRUST (arXiv:2611.10787), the statistical gate. A late-October sidebar, verified to exist but not deep-read for this site: HarnessMM (arXiv:2610.32813), recursive self-improvement for harness token efficiency; The Trinity (arXiv:2610.36077), capability-driven RSI for multimodal agents; Skill∞ (arXiv:2610.35434), RSI over agent skills. Also load-bearing in the November papers' own citations, characterized in their texts rather than independently read here (cited, not verified): RRSI and ModularRSI (2026 preprints cited by both Google papers), Continual Harness (arXiv:2605.09998, cited by Paper 2), and HarnessBank (arXiv:2607.13683, the mutation-library system both reference). Together with entries 11 to 13 above, these are the spine of a "the field in 2026" timeline.

A note on what is deliberately missing. The adversarial review panel suggested further late-2026 family papers (among them a regret-gated harness-evolution system it called GUARD). None of them was verified for this site, so none is listed here. Each needs an existence check against arXiv before it appears on any page. The panel also cited a differently authored paper with a similar title to Paper 1 (arXiv:2606.09498), a reminder that title matches are not identity.