Daily Systems Trends Report — November 2, 2026: The Repair Stack — Recovery Is a Designed Subsystem, Not a Retry Loop
Daily Systems Trends Report — November 2, 2026: The Repair Stack — Recovery Is a Designed Subsystem, Not a Retry Loop
Monday edition. Coverage: the Monday, November 2 arXiv batch — 16 distributed-computing, 22 software-engineering and 11 multi-agent papers (arXiv:2610.40721 through 2610.42144). Nothing in this report overlaps the November 1 report, which covered the Friday, October 30 batch through 2610.40589.
The answer first: This batch is dominated by a single engineering problem that the last two months treated as a bolt-on: what happens after the agent fails. Five papers independently converge on the same design: repair must be a gated, evidence-carrying subsystem with its own admission rule — not a retry loop with a reflection prompt.
- Repair needs a graph, not a prompt. Dittany derives expected contributions and acceptance conditions into a contribution graph, then repairs either at action level or graph level on 9,000 MAS tasks: 84.76% accuracy (+26.74 points over native execution) for 17.92% extra tokens — and 24% fewer tokens than Reflexion (arXiv:2610.42144).
- Repair needs a property gate, because the model cannot judge its own patch. Post-SQLFix names the Arbitration Paradox (the same unverified model proposes the repair and accepts it) and replaces it with a verify-before-apply monitor: 77.8% of execution errors that execution-feedback repair leaves unrepaired, in under half the iterations and 30% fewer tokens (arXiv:2610.41472).
- Some failure classes should be made impossible, not repaired. Constrained beam decoding guarantees 100% valid imports in LLM-generated tests, where RAG leaves 45%, LIBRO 10% and agentic repair 43% of import errors unresolved (arXiv:2610.41878).
- And the popular fix — feeding the failure back — is mostly noise. On 181 failed repair attempts, every failure-memory condition gained 5.5 to 9.9 points in point estimate and none was statistically significant; a model-written lesson buys nothing over the raw transcript it summarizes (arXiv:2610.41433).
- Around the core: CI failures are mostly streaks with external causes (30.9M runs), a 140,000-line Fortran climate model ported by an agent passes a 100-member ensemble check, contracts that protect human investment fail between profit-maximizing LLM agents, and AI hiring evaluators rank writers by model choice independent of candidate quality.
The arc: October built the verification plane. November is filling in the recovery plane — and the first honest question is whether the popular mechanism (memory) clears the statistical bar at all.
The theme: the repair stack
The October arc traced authority moving out of the model into inspectable artifacts: verification gates (Sept 26), the commit point (Sept 28), approval binding (Sept 30), coordination budgets (Oct 16), evidence gates (Oct 3), the assurance plane (Oct 22), the instruction stack (Oct 28), the intervention ledger (Oct 29), and the baseline audit (Nov 1). All of that governs the happy path and the admission path. Mondays batch attacks the sad path: the system already failed, partial results exist, and something has to decide what is salvageable. The convergent answer across five papers: salvage decisions need their own oracle. Dittany computes which completed results remain usable from a contribution graph. Post-SQLFix accepts a repair only if it strictly reduces measured violations without reintroducing resolved ones. CBDL removes an entire repair class from existence by construction. And two negative-flavored results delimit the stack: feeding failure records back is not yet a statistically demonstrated win, and one in three CI failures starts without any code change at all — so most repair budgets are pointed at the wrong cause.
Method and selection. Sources: arXiv listing pages for cs.DC, cs.SE and cs.MA (Monday, November 2 sections), plus 20 abstract pages read directly. Selection favors papers with pre-specified designs, matched baselines, peer-reviewed venues or negative results; single-author and unreviewed papers are flagged inline. No vendor blogs. Every claim below is drawn from the authors own abstract or listed numbers.
1. The repair core: graph-guided, property-gated, prevention-first
1.1 Dittany: Contribution-Guided Runtime Repair for MAS Applications (arXiv:2610.42144)
The claim: repairing a failed multi-agent execution requires knowing which completed intermediate results are still usable — and that is a graph question, not a prompting question.
The foundation: replaces the two incumbent mechanisms — Reflexion-style self-reflection and iterative rollback — with a contribution graph derived from task requirements and method specifications, whose runtime checks locate unmet acceptance conditions and classify surviving results.
The evidence: 30 applications across six MAS frameworks, 9,000 tasks. Dittany detects runtime failures at 88.28% precision and 79.18% recall and reaches 84.76% task accuracy: +26.74 points over native execution and +21.28 points over the strongest of four recovery baselines. The bill: estimated token consumption 17.92% above native, but 24.19% below Reflexion and 13.05% below Iterative Rollback. Ablation: combining action-level correction with graph-level recovery beats graph-level repair alone at lower token cost. Both repair scopes retain validated contributions and check repaired outputs before downstream use.
The trade-off: the contribution graph must be authored per application — the paper evaluates on MAS applications with method specifications to derive from, and the token overhead is real. But paying +17.9% to beat the recovery baselines by 21+ points is a favorable exchange, and the memory of this report series says the baselines were the field's default.
Verdict: the strongest positive result of the batch. If you operate MAS applications, the salvage decision belongs in a graph with acceptance conditions, not in the retry prompt. Watch for whether the graph can itself be agent-generated — that is the next paper someone will write.
1.2 Post-SQLFix: The Arbitration Paradox and Property-Guided Repair (arXiv:2610.41472)
The claim: execution-feedback repair is structurally self-contradictory: it uses unverified models both to propose the repair and to decide whether the repair satisfies the properties. The authors name this the Arbitration Paradox.
The foundation: program-repair orthodoxy — patch, run tests, judge by outcomes — is replaced by property-guided repair: canonicalize SQL into a dialect-aware Canonical Query Structure, validate through a three-layer static analyzer (syntactic, context-free structural, context-sensitive semantic), and let a Verify-Before-Apply temporal monitor arbitrate.
The evidence: BIRD, Spider and Mini-Dev — over 3,000 instances, three dialects (SQLite, MySQL, PostgreSQL), six model configurations. Post-SQLFix resolves 77.8% of the execution errors that execution-feedback repair leaves unrepaired, needing less than half as many iterations and 30% fewer tokens. Monitor invariants: a repair is accepted only if it reduces the violation count, does not reintroduce resolved violations, and satisfies operator contracts — and accepted transitions produced no statically detectable structural regressions, converting to absolute accuracy gains of up to +11.6 points.
The trade-off: the monitor's guarantees are bounded by the declared rule family and operator contracts — properties outside the family pass unchecked. A finite retry budget ensures halting but caps coverage.
Verdict: ready for adoption in any agent that emits SQL. The Arbitration Paradox is also a portable indictment: every pipeline where the same model grades its own repair has it. This is the Oct 1 approval-binding lesson, restated for the recovery path with a working implementation.
1.3 No More Import Errors: Guaranteed-Valid Generation Beats Repair (arXiv:2610.41878)
The claim: the most common failure of LLM test generation — import errors — should be prevented by the decoder, not repaired after the fact.
The foundation: grammar-constrained decoding already guarantees valid imports, but the authors find it collapses into degenerate import streaks — repetitive valid imports that exhaust the token budget before any test body is generated. Their fix, Constrained Beam Decoding with Lookup (CBDL), avoids premature token commitment while keeping the guarantee.
The evidence: Python and Java, two test-generation tasks. CBDL achieves 100% valid imports, versus static baselines (RAG, LIBRO) that leave 45% and 10% of import errors unresolved and agentic repair leaving 43%. It converts 14% of initial import errors into functionally correct tests and lifts overall test correctness by 1–4 points directly; by freeing the repair budget from import churn it adds 2–7 points more (Python) and 1–6 (Java). A hybrid pipeline — a small local model with CBDL generating imports, GPT-5.2 generating the test body — beats GPT-5.2 alone by 1–3 points. Overhead: 16–21 seconds per test.
The trade-off: decoding-stage guarantees require access to the model's logits — unavailable on pure API serving. The 16–21s per-test overhead is real but trivial against agentic repair loops.
Verdict: the prevention-beats-repair result of the batch, and the hybrid small-model-imports/big-model-body finding is immediately actionable: put the guarantee in the cheap model, the creativity in the expensive one.
1.4 What Does a Repair Agent Gain from Remembering Its Failure? (arXiv:2610.41433) — the honest result
The claim: the fashionable fix for failed repairs — replaying the transcript, a self-written lesson, or extracted test signals on retry — has no statistically demonstrated effect on real bugs.
The foundation: the pre-registered controlled study — the same discipline the Nov 1 report found missing across 628 studies. Five conditions on 75 BugsInPy bugs, 181 failed attempts of gpt-5.4-mini, with two predeclared follow-ups on gpt-5.4 and a notice-only control; the authors report their own protocol deviations.
The evidence: on bug-revealing tests, every memory condition gained 5.5 to 9.9 points in point estimate over a plain retry (from 29.8%), but none significantly. A model-written lesson showed no advantage over the raw transcript it summarizes (−1.7 points, 95% CI [−8.7, +4.9]), despite costing an extra model call. The transcript did significantly beat a bare failure notice (+12.2 points, the only significant one of twelve predeclared contrasts, and only for the mini model). Two uncomfortable post-hoc findings: retries with test-result access more often failed other tests that the reference fix passes (shrinking apparent gains), and outcomes varied far more between failures than between conditions.
The trade-off: exploratory sample sizes; the authors give the numbers a confirmatory study would need. But that is precisely what makes it publishable: it is an honestly labeled N-of-one-configuration field, not a claim.
Verdict: treat every 'agents learn from failure memory' product claim as unproven. The transcript (raw evidence) beats the digest (model-written lesson) — converging with the Oct 28 compact-documentation and Oct 26 Compact-Bench line: LLM summaries are not the unit of memory that carries signal.
1.5 Stuck on Red? GitHub Actions Failing Streaks at Scale (arXiv:2610.41863)
The claim: CI failures cluster into streaks, and a large share of them have nothing to do with the last commit.
The foundation: the repair-budget assumption that the cause is the most recent change — measured against 238 days of CI history.
The evidence: 30.9M+ runs of 154K+ workflows across 43K+ repositories. Three quarters of failing runs follow another failing run, and half of workflows with at least three runs have at least one failing streak. Workflows serving multiple purposes streak more often. A third of failing streaks start and two in five end without any repository change — in a 100-streak log sample, those ending without change fail most often on network issues or external services. Most streaks end within hours, but the one in five lasting more than a day account for the lion's share of total failing time.
The trade-off: log inspection is a 100-streak sample, and the streak taxonomy (trigger, purpose) is descriptive rather than causal. But the actionable outputs are free: flag change-free failures, alert on >1-day streaks.
Verdict: the missing attribution layer for the whole repair stack above. If 33% of streaks begin with no code change, an agent that repairs 'the code' after every red build is firing at the wrong target a third of the time. Converges exactly with the NICAM migration finding below: the fix is often in the environment, not the file.
Why this cluster matters together: the five papers triangulate one design: a repair subsystem needs (1) a salvage oracle that decides what survives (Dittany), (2) an admission gate that accepts patches only against measured properties (Post-SQLFix), (3) prevention where prevention is cheaper than repair (CBDL), (4) honest statistics before any memory feature ships (arXiv:2610.41433), and (5) cause attribution before any repair targets the code (arXiv:2610.41863). Retries and reflection prompts appear in none of the five designs as the load-bearing component.
2. Repair at scale: migration, annotation, reproduction, and the harness itself
2.1 Migrating a 140,000-Line Climate Model with an AI Coding Agent (arXiv:2610.41313)
The claim: LLM-assisted migration of a production scientific codebase is now feasible when the acceptance criterion is ensemble statistical consistency rather than test-passing.
The foundation: NICAM, a Nonhydrostatic ICosahedral Atmospheric Model — legacy Fortran accelerated with OpenACC — ported to C++/Kokkos with Claude Code under human review, targeting GH200 and MI300A.
The evidence: approximately 140,000 lines of Fortran analyzed and ported into 35,000 lines of C++/Kokkos, covering the dynamical core and seven physics packages. A 100-member ensemble comparison showed the port is statistically consistent with the original — the right oracle for a climate model, where per-timestep equivalence is meaningless. Performance: 1.71× application speedup on GH200 and 1.54× on MI300A versus the Fortran/OpenACC baseline; CUDA kernel-time 1.38× on GH200; the HIP build reached 0.96× kernel performance after bandwidth normalization.
The trade-off: compression is itself the risk signal — 140K Fortran lines became 35K C++ lines, so the port is a rewrite, and only the ensemble distribution check (not line-level review) stands between the model and the monsoon. Single application, three authors with deep domain knowledge, human review loop.
Verdict: the flagship migration datum of the quarter. The lesson generalizes beyond HPC: for numerical domains, define the ensemble-level oracle first; the agent translation is then a solvable engineering task. Note the convergence with arXiv:2610.41863: a third of CI failures start without code changes — infrastructure and environment are always in scope.
2.2 SALT: Static Analysis Guides the LLM, Not the Other Way Around (arXiv:2610.41617) — ICSE 2027
The claim: for type annotation of under-annotated Python, the LLM should be a bounded resolver invoked only where static analysis runs out of evidence.
The foundation: replaces prompt-heavy LLM typing (project-wide context dumped into noisy prompts) with static analysis that resolves types where it can, prioritizes LLM queries, and constructs concise type-aware contexts.
The evidence: 12 real-world Python projects. SALT achieves the best accuracy among evaluated systems while reducing estimated LLM cost by up to 78.5% versus a strong coding-assistant baseline, with similar savings against the frontier GPT-5.5 — i.e. the deterministic-first architecture wins on both axes, not a cost-for-accuracy trade.
The trade-off: static type inference for dynamic Python has its own recall ceiling; the LLM still pays for the residue. Annotation is also a narrower task than the migration papers — but that narrowness is why its numbers are clean.
Verdict: peer-reviewed (ICSE 2027) and directly adoptable. Same shape as the Koi lesson of Oct 20 (learner proposes, determinism disposes), now with a cost figure: the deterministic layer saved 78.5% of the model bill.
2.3 RepGen and MetaVul: reproducing the failure, optimizing the harness (arXiv:2610.41097, arXiv:2610.40721)
RepGen (2610.41097, ICSE 2027 tool track): bug reproduction is the unpriced first step of every repair, and deep-learning bugs are the worst case (source, model, data, dependencies and environment all involved). RepGen builds a learning-enhanced context, plans the reproduction, generates candidate scripts and verifies them by static checks plus execution against the reported failure. 85 of 106 real-world DL bugs reproduced (80.19%); a controlled study with 27 developers showed +23.35% reproduction success and 56.8% time reduction.
MetaVul (2610.40721, Columbia — Kaiser/Ray lineage): treats the agent harness itself as the optimizable artifact for vulnerability detection. A workflow-based optimization loop iteratively refines a structured reasoning scaffold on paired vulnerable/patched functions, returning Pareto-optimal harnesses: +23.3 points pairwise detection on the 202-pair validation set, +25.8 on the 430-pair held-out set, and harnesses optimized on one model transfer to another (+14.7 points held-out without further optimization).
The trade-offs: RepGen's reproduction success is bounded by bug-report quality and environment availability; MetaVul's gains are on pairwise detection benchmarks whose real-world precision the abstract does not address, and harness optimization inherits the overfitting risks the Oct 7 RHAE null documented — the held-out transfer numbers are what make this one interesting.
Verdict: RepGen is adoptable now (open-source tool, GitHub Action); MetaVul extends the 'harness as supply-chain artifact' theme (Oct 10, Oct 20) into security, with transfer as the evidence that the harness — not the model — carried the gain.
2.4 TetraState: Regression Testing for Learned World Models (arXiv:2610.41130)
The claim: learned world models ship as software with versioned models, preprocessing and harnesses — and their current regression practice (one accuracy verdict) hides most of what changed.
The foundation: the regression-testing canon — per-test outcome transitions, harness versioning as part of the system under test — applied to video world models.
The evidence: TetraState runs each of 506 IntPhys 2 Main tests under four fixed model-native configurations and assigns four outcome classes by correct-verdict count, reporting inconclusive tests and failed executions separately. On Cosmos 3 Nano and V-JEPA 2: two harness revisions moved modal accuracy by only 0.2 and 2.6 points yet changed 11 and 214 test labels; in the second, accuracy rose while fewer tests were judged correctly, and 43 regressions kept the modal verdict — invisible to a modal-verdict flip check.
The trade-off: four configurations per test is a compute multiplier, and the oracle is demonstrated on two video-world-model systems only. But the finding is a general indictment of single-number regression gates for any learned component.
Verdict: a research agenda, per the authors, not yet a shipped tool. Pair it with the Nov 1 numoracle result: oracles for learned artifacts must be constructed artifacts themselves.
3. Commitment and clearing: the durability layer
3.1 A Deterministic Commitment Rule over Unstructured DAGs (arXiv:2610.41837) — theory
The claim: optimistic replication can keep its wait-free fast path and still get a commitment mechanism that agrees on state evolution — at virtually zero message overhead beyond operation dissemination.
The foundation: the classic compensation for eventual consistency — an underlying atomic broadcast that periodically agrees on object state — replaced by a deterministic commitment rule computed locally over a causality DAG of client operations.
The evidence: framework-level: a simple causal-DAG representation of replica state plus a deterministic commitment rule with near-zero extra messaging. The abstract publishes no implementation or experiment — this is a correctness-of-design contribution from a strong team (Kuznetsov, Tucci-Piergiovanni; CNRS/Télécom Paris lineage).
The trade-off: determinism over an unstructured DAG is exactly where the hard cases live (concurrent conflicting operations), and without a prototype the overhead claim is a design property, not a measurement. Wait for the systems follow-up.
Verdict: watch. If the rule holds with the advertised zero overhead, it undercuts the coordination tax that this report series has been pricing all month — the durability decision moves from the network into local computation.
3.2 AuditFL: Contract-Backed Clearing for Open Federated Learning (arXiv:2610.41278) — FLTA 2026
The claim: open federated learning can keep its trusted-coordinator economics while making every round decision attributable, replayable, auditable and economically constrained — by putting only content identifiers and settlement state on chain.
The foundation: replaces trust-in-coordinator with a clearing layer: training and aggregation stay off chain in an artifact store; deposits reserve update tickets; deterministic settlement rules finalize rounds. The aggregator survives — but its decisions become checkable. Same doctrine as the Oct 16 coordination-budget week: coordination priced and institutionalized, not trusted.
The evidence: two implementations (deterministic state-machine prototype and a Solidity contract on Anvil). Full MNIST, Dirichlet non-IID, 12 rounds, up to 200 clients: the learning trajectory is preserved versus plain FL; at 200 clients the contract run issues 5,026 transactions, stores 2,413 off-chain artifacts (144.9 MiB) and consumes 829.7M EVM gas, dominated by per-client reserve/publish calls. Stress tests (dropout, invalid updates, artifact unavailability) reduce inclusion nearly linearly but rounds still finalize, with final accuracy moving only a few tenths of a point.
The trade-off: gas cost scales with client count and the artifact store remains a trusted assumption — auditability of decisions, not integrity of artifacts. MNIST-scale only; the control-plane cost models are closed-form but unvalidated at production scale.
Verdict: a working reference design for 'attribution without trust' in any multi-party training setting. Peer-reviewed (FLTA 2026). The pattern — on-chain receipts, off-chain bulk — transfers directly to agent-economy designs.
4. The economics layer: contracts fail between agents
3.3 Renegotiable Options Fail Between Frontier LLM Agents (arXiv:2610.40961)
The claim: a contract term that demonstrably raised investment between humans — the renegotiable option from Hoppe and Schmitz's hold-up experiments — does not transfer to profit-maximizing LLM agents.
The foundation: the hold-up problem: a seller sinks relationship-specific cost before the price is set; the buyer then holds up. Theory says a renegotiable option should collapse (the buyer lapses it and lowballs); the human lab experiment found it raised investment from 41.5% to 67.2% of pairs. Behavioral economics vindicated contract design — until the counterparties became Claude Opus 5.5 and GPT-6.1 Sol.
The evidence: the agents did what textbook game theory predicts, not what humans did: under the renegotiable option no seller adapted; under the renegotiation-excluding option every seller did. Two further controls rule out dumb explanations: removing profit instructions left investment unchanged in three of four regimes, and when option exercise was made worthwhile even without adaptation, no seller adapted — the agents were computing the strategic structure, not pattern-matching on option presence.
The trade-off: one-shot games, two model families, a single payoff structure. But the design is exactly the human experiment that established the baseline, which is what makes the contrast citable.
Verdict: load-bearing for agent-economy design: mechanisms must be re-derived for LLM counterparts, not imported from human behavioral economics. The agents are more rational than the humans — which is precisely why the human-validated contract failed.
3.4 AI Evaluators Favor Certain Writer Models, Independent of Quality (arXiv:2610.41866)
The claim: in all-AI hiring pipelines, the choice of model that wrote the application affects acceptance independent of candidate qualifications.
The foundation: the classic bias audit — vary the protected attribute, hold quality fixed — where the attribute is now which model wrote the text. Eleven LLM writer agents paired with nine API-hosted evaluator agents across ten job descriptions, fifty candidates per job.
The evidence: a consistent global generative preference hierarchy of writer models by evaluator acceptance, with locally hosted models systematically disadvantaged regardless of license, plus self-preference bias (evaluators favor their own outputs). Competitive consequence: in the most adverse pairing, roughly 1.8 of every 25 qualified candidates filtered out purely on model mismatch. Mechanism: writer-specific stylistic cues that evaluators unanimously reward or penalize; a fingerprint check finds little unexplained writer signal once those features are controlled.
The trade-off: cover letters only, single-language, and the evaluator pool is API-hosted models — but that is the deployed reality this paper audits. The actionable finding is the variance: evaluator choice itself is a fairness parameter.
Verdict: the cleanest published measurement of model-preference bias in automated screening, and a governance-grade audit template: vary the generator, hold the candidate fixed. Read it next to the 10/20 Mas-Colell-style pricing work: when agents transact with agents, model identity becomes the new protected class.
5. Serving and evaluation infrastructure
4.1 HiState: Prefix Caching Built for Agent Workloads (arXiv:2610.41508)
The claim: agent workloads break conventional prefix caching: agents modify and revisit earlier contexts, so the reusable prefix's checkpoint was never saved or already evicted.
The foundation: hybrid (full-attention + recurrent) models make this worse — a recurrent checkpoint cannot recover an earlier state for a shorter prefix, so existing systems save boundary checkpoints that agent traffic keeps missing. HiState exploits an asymmetry: prefix reuse reads all matching KV entries but only one recurrent checkpoint — so checkpoints go to SSD while KV entries keep fast memory, with adaptive interval control and unified eviction.
The evidence: implemented on vLLM, evaluated on two public coding-agent trace datasets plus microbenchmarks: up to 5.73× and 5.44× p99 TTFT speedups over vLLM-Marconi and SGLang-HiCache.
The trade-off: two trace datasets are coding-agent-specific; SSD checkpoint retrieval adds a tail-latency floor; hybrid-model support ties the design to the recurrent-checkpoint asymmetry.
Verdict: the agentic-workload-specific serving line keeps compounding (Oct 16 KV-tier costs, Oct 26 KVStream, Oct 28 Stratum): the workload that agents generate needs its own memory hierarchy. Adoptable if you serve hybrid models to agent traffic on vLLM.
4.2 ARK: Reserving Paths for KV Mega-Flows (arXiv:2610.41160)
The claim: KV-cache transfers in disaggregated inference are elephant flows that stateless ECMP mishandles via hash collisions — but because they persist for hundreds of milliseconds to seconds, lightweight one-to-all coordination can be amortized.
The foundation: classic path-reservation thinking from telephony and circuit switching, re-derived for GPU pools: senders coordinate to choose non-colliding spine paths.
The evidence: the abstract frames the mechanism and collision problem precisely; quantitative end-to-end gains are in the paper body. The structural insight is the reportable one: flow persistence is what makes coordination affordable — the same asymmetry (long-lived flows subsidize control) that ARK's authors exploit.
The trade-off: coordination requires sender cooperation (same operator domain), and reservation locks in path choice that adaptive ECMP would have rerouted around failures.
Verdict: watch — with the 10/26 KVStream and 10/28 TAO papers, disaggregation is acquiring a full control plane: tier claiming, path reservation, tool-aware scheduling. The boring-mechanism verdict from Oct 16 stands: reserve, do not predict.
4.3 Blackwell, Power-Resolved: B300 Is Not a Uniform Successor to B200 (arXiv:2610.41919) — PMBS 2026 / SC26
The claim: Blackwell Ultra (B300) trails B200 badly on specific workload classes — and only power-resolved measurement explains why and when.
The foundation: throughput-only benchmarking — replaced by per-GPU board-power attribution across two independent eight-GPU clusters, CV inference/training, Llama-3-8B/70B inference, and six production HPC codes.
The evidence: B300 trails by up to 5.6× on convolutional inference, 8× on 3D ViT training, 24–27% on 70B LLM throughput, and 16× on double-precision Quantum ESPRESSO. The power-resolved analysis: on affected workloads the B300 draws only 36–53% of its 1100W envelope — the silicon never leaves its stall — while on ViT-Large, which it wins, both parts saturate at the wall.
The trade-off: two clusters, one vendor generation pair; power attribution is board-level, not per-SM. But peer-reviewed (PMBS@SC26) with production codes — the strongest evidentiary basis in the batch for a purchasing decision.
Verdict: a procurement warning: generational upgrades are workload-conditional. Anyone sizing B300 for FP64 or convolution-heavy pipelines should benchmark against B200 first — and demand power telemetry in the report, not just throughput.
4.4 Agentic World Modeling: Simulation by Read-Only Evidence Acquisition (arXiv:2610.40927) — Microsoft
The claim: test-time scaling assumed parallel candidate trajectories; shared, persistent environments with irreversible side effects break that. The fix is not a better world model but a different simulation loop.
The foundation: generative world models compress environment state into a single prompt and simulate transitions from it. AWM instead reformulates next-observation prediction as multi-turn evidence acquisition: for each hypothetical action, an agentic simulator queries the real environment through safe read-only interfaces, reasons over returned evidence, and constructs the resulting observation with executable computation — without mutating shared state.
The evidence: across tau-bench, AppWorld and OfficeBench, AWM outperforms a single-shot simulation baseline by 40.07% on average and a trained world-model baseline by 12.36%, enabling parallel exploration over one shared environment.
The trade-off: read-only coverage limits what can be simulated (actions that reveal nothing without side effects remain unpredictable); evidence acquisition costs real environment queries; and the safety property depends entirely on the completeness of the read-only interface set.
Verdict: a significant reframe for agent deployment in shared systems (the enterprise case Microsoft cares about): the environment itself becomes the world model's backing store, accessed through a permission boundary. This is the permission-minimality doctrine (Oct 1 Aletheia) applied to simulation.
4.5 Lineage Is Memory: What Actually Drives LLM-Guided Optimization (arXiv:2610.41157)
The claim: every evaluation of the reflective-optimizer literature tested inside lineage-preserving search, confounding parent inheritance with feedback breadth. Separated under matched budgets, greedy parent inheritance drives the vast majority of optimization progress.
The foundation: 1,750 pre-registered runs across nine prompt- and program-synthesis benchmarks, designed to decouple the two mechanisms: seed-reset resampling with clustered failure summaries and larger proposers versus sequential parent inheritance.
The evidence: greedy parent inheritance beats seed-reset resampling even when seed-reset receives full clustered failure summaries or a bigger proposer model; full-set error clustering helps single-step rewrites and early rounds, but sequential inheritance closes the gap as solved error modes are retained in the candidate. Budget decomposition of GEPA: proposer reflection is a small cost fraction; validation and minibatch gating consume nearly the entire budget.
The trade-off: short-budget setting, two authors (flag as a small team), benchmarks are synthesis tasks rather than production repos.
Verdict: the accounting companion to item 1.4: optimization progress comes from continuity (the surviving parent), not from reflection prose. Spend budgets on validation and gating — that is where the tokens actually go.
Radar: titles worth tracking, abstracts pending deeper reads
Coordination and matching: Decentralized Dynamic Stable Matching (2610.41912), Strategic Tanking in Stable Matching Markets (2610.42105), A Robust Approach to Belief Mismatch in Non-cooperative Dynamic Games (2610.40999, single author), How a group that cannot communicate knows itself by its enemy (2610.40835, Censi/Frazzoli lineage), When Disclosure Is Compulsory: ride-hailing rebalancing with self-interested LLM driver agents (2610.41132).
Systems and HPC: KV-Cache Error Localization in Looped Language Models — Ouro/Huginn diagnostic (2610.41825), MemX memory-aware auto-parallelism for cross-vendor GPU training (2610.41525), Falcons lossy-compression speed-ratio limits (2610.41209), Serverless AI fine-tuning characterization (2610.40983), Resource Locks and Fast Unlock for certificate-based payment systems (2610.41207), Layered reproducibility for HPC applications — Feel++/Ktirio artifact chain (2610.41861).
Software engineering: AIFaultBench — reproducible benchmark of real-world AI software faults (2610.41094), RiskyPy model-calibrated security/functionality prompt generation (2610.40735), Reparo — synthesizing and validating access control policies (2610.41800), Architectural debt enforcement under incomplete observation — ratchets (2610.41276), Yesterday's Code, Today's Dependencies — PHP migration benchmarks (2610.41263), Cognitive inclusivity in Copilot (2610.41192), Post-SQLFix companions on LLM-SQL repair are arriving weekly.