Skip to content

archived edition · 2026-10-13

PaperraftFind the AI research
worth testing.

Understand what a paper changes, what it costs, and whether it fits your next build. Explore research on faster LLM inference, agent memory, and evaluation, with the original sources in reach.

Explore the researchHow papers are assessed

Start with a brief. Follow the evidence. Choose a test.

edition
2026-10-13
briefs
43
research areas
13
independent implementations
37

22 of 43 papers in the index (51%) have no independent implementations.

Research index

Search by topic, browse a research area, or sort by date. Read a brief, open the original paper, and inspect the available evidence before deciding what to test.

showing30 of 43
sort by
arXiv 2609.07966
First page of MetaKV: Adaptive KV Cache Compression for Constrained LLM Inference
KV cachetest

MetaKV: Adaptive KV Cache Compression for Constrained LLM Inference

MetaKV replaces a single fixed KV cache compression configuration with per-prompt selection among existing methods (KVQuant, H2O, RocketKV, FP16) guided by lightweight predictors of latency, peak memory, and correctness. The cost is training and maintaining three prediction models plus a selection step per prompt, adding engineering complexity and a small inference-time overhead on top of the underlying compressors. It can fail if the accuracy or latency predictors mispredict on out-of-distribution prompts or on hardware and models different from the evaluation setup, causing constraint violations or suboptimal choices.

observed signal
2impl.
0stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2609.20152
First page of MTVA-Bench: Evaluating the Language Model Inside Cascaded Voice Agents
agent evaluationtest

MTVA-Bench: Evaluating the Language Model Inside Cascaded Voice Agents

MTVA-Bench replaces end-to-end voice pipeline scoring and generic LLM benchmarks with an isolated evaluation of the language model under realistic call conditions (ASR errors, split utterances, script and language constraints), using an LLM caller, a mock backend, deterministic tool-call checks, and two citation-requiring LLM judges across 490 scenarios in 7 languages. Adopting it costs the engineering effort of integrating an agent harness and mock backends plus recurring LLM judge inference, with no model retraining required. It can fail through judge unreliability or citation gaming, limited scenario coverage relative to a real production domain, and overfitting to the benchmark's simulated caller rather than actual human callers.

observed signal
3impl.
4stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.12569
First page of SWE-Duel: Towards a Self-Scaling Arena for Coding Agents
agent evaluationwatch

SWE-Duel: Towards a Self-Scaling Arena for Coding Agents

SWE-Duel replaces static, leak-prone coding benchmarks (e.g., SWE-bench-style fixed task sets) with evaluation-time task generation, where agents alternately author buggy pull requests and review each other's under mirrored Red-Blue turns with test-based oracles. The cost is substantial: each turn requires three context-isolated Red sessions plus a blind repair check and a Blue review, and the reported tournament ran 1,500 turns across 11 frontier model-harness pairs, which is entirely API- or compute-billed agent execution rather than a one-time benchmark download. It can fail as a procurement signal because the oracle only checks test outcomes (subtle bugs can slip through if feature and bug tests are weak), results depend heavily on the harness rather than the model alone, and a two-agent duel format is a research artifact with no production role for a small team.

observed signal
2impl.
18stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.13116
First page of DRYLAB-Bench: Benchmarking the Biosecurity Risk of Agentic LLM Mutation Design
safety and guardrailswatch

DRYLAB-Bench: Benchmarking the Biosecurity Risk of Agentic LLM Mutation Design

DRYLAB-Bench replaces knowledge-based biosecurity questionnaires with agentic mutation-design tasks scored against 187,695 empirical wet-lab measurements via a Biosecurity Risk Score. Adoption costs nothing in model training but requires access to frontier LLM APIs and biological design tools, plus domain expertise to interpret multi-round agent trajectories. Findings may not transfer: scores derive from ProteinGym and ViroGym variant data, so risk estimates for pathogens or phenotypes outside these datasets, or for future tools, can diverge.

observed signal
3impl.
142stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.13021
First page of EmbodiedCLBench: Evaluating Continual Learning for Self-Evolving Embodied Agents
agent evaluationwatch

EmbodiedCLBench: Evaluating Continual Learning for Self-Evolving Embodied Agents

EmbodiedCLBench replaces ad hoc or non-embodied continual-learning evaluation with a compositional benchmark in embodied simulation, testing whether skills from basic tasks recombine to solve unseen advanced tasks. Adopting it costs embodied-simulator infrastructure, agent harness integration, and evaluation compute rather than a single API call, and it yields a measurement tool rather than a capability improvement. It can fail to transfer: results are confined to the benchmark's simulated tasks, and its central finding that agents cannot extract value from additional experience may not hold for methods or domains outside those tested.

observed signal
3impl.
365stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2609.03430
First page of Random Attention: Rethinking KV Cache Eviction for Efficient Reasoning
KV cacheadopt

Random Attention: Rethinking KV Cache Eviction for Efficient Reasoning

Random Attention replaces score-based KV cache eviction policies (such as H2O-style importance scoring) with uniform random eviction within each attention head, while always retaining the prompt, eliminating all per-token scoring computation. It costs nothing in memory or latency beyond the eviction itself and adds almost no implementation complexity, since the selection signal is removed entirely; quality is reported to match the best prior evictor on reasoning workloads. It can fail on workloads where the reasoning trace does not restate needed information or where redundancy across heads is insufficient, and on non-reasoning tasks or cache configurations where the prompt is not the dominant fragile component, since the findings are validated on reasoning traces with long chains of thought.

observed signal
3impl.
73stars
0citations
1.43xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.12582
First page of One Model to Loop Them All: Elastic Latent Recurrence for Language Models
efficient architectureswatch

One Model to Loop Them All: Elastic Latent Recurrence for Language Models

The method replaces the standard practice of serving a fixed-depth non-recurrent transformer (or maintaining separate checkpoints per accuracy/latency tier) with a single recurrently applied block whose loop count is chosen at inference, while removing the usual one-loop accuracy penalty through gated state updates, mixed loop counts in training, and loop-index conditioning. The cost is that the gains require modifying pretraining: the recipe must be trained in, and all reported results come from models the authors trained themselves, including a late-stage mixed-depth schedule that still adds training compute. It can fail for a constrained-infrastructure adopter because no pretrained foundation model can be retrofitted with ELR via fine-tuning alone with validated results, the accuracy-per-loop gains on downstream production workloads are unverified outside the authors' benchmarks, and multi-loop serving multiplies per-request latency and compute on a single 24 GB GPU where a 4B-class model is already near the practical ceiling.

observed signal
2impl.
126stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.12570
First page of Contextual Correction of Parallel Draftsfor Speculative Decoding
speculative decodingtest

Contextual Correction of Parallel Draftsfor Speculative Decoding

DCOCO replaces the top-1 commitment of parallel diffusion-based drafters (e.g., DFlash) by retaining multiple candidate tokens per draft position and scoring their contextual compatibility across adjacent positions in parallel, restoring intra-block dependencies without sequential drafting. It costs an additional lightweight correction stage per draft block, extra candidate storage, and integration into a diffusion-drafter serving stack, and it is not drop-in for conventional autoregressive speculative decoding. It can fail when the verifier or drafter backbone differs from the evaluated configurations, when the correction overhead erodes gains at low batch sizes, or when sequential correctors under load are the actual bottleneck it claims to avoid.

observed signal
2impl.
149stars
0citations
6.6xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.12611
agent evaluationwatch

SoftwareGym: Scaling Computer-Use Agent Training with Diverse Synthesized Software Environments

The method replaces hand-constructed native application environments and shallow browser-hosted environments with an automated pipeline that generates, runs, and runtime-verifies diverse GUI software for agent training and evaluation. The cost is a multi-stage generation, execution, and GUI-evaluation-with-repair pipeline plus trajectory collection and model training, which exceeds a single-GPU budget in engineering effort and compute. Failure modes include synthesized applications not matching the interaction complexity and visual distribution of real software, functional bugs surviving the 91.5%-reliable verification loop, and overfitting to generator-induced interface patterns that may not transfer beyond the reported OSWorld setting.

observed signal
1impl.
14stars
0citations
1.38xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.12668
First page of Recurrent Harness for Agentic Continual Learning
memory and contexttest

Recurrent Harness for Agentic Continual Learning

It replaces forward-only memory/reflection harnesses (and replay- or validation-based harness optimization) with a strictly online scheme that, after each streamed instance, revises previously retrieved reflections using the resulting trajectory as backward feedback. The cost is extra inference calls per instance for revision, added harness complexity, and growth/maintenance of a textual state, all feasible on a single 24 GB GPU or via APIs. It can fail if revisions propagate errors from noisy trajectories, if the workload lacks distribution shift or long interaction streams where continual adaptation matters, or if revision quality depends on backbone strength not matched in the reader's deployment.

observed signal
1impl.
14stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.12756
First page of How Do Hardware Faults Manifest Differently in LLM Agents?
agent evaluationwatch

How Do Hardware Faults Manifest Differently in LLM Agents?

This is an empirical evaluation, not a deployable method: it replaces the assumption that model-level hardware fault behavior predicts agent-level behavior by tracing two-bit weight faults through 6,814 agent executions. Adopting its practice would require a fault-injection harness and repeated agent benchmark runs, costing GPU time and engineering effort with no direct performance return. The findings imply risk rather than mitigation: faults can produce silent semantic errors, elevated execution cost, and altered safety behavior that standard accuracy checks will not catch.

observed signal
1impl.
14stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.12813
First page of VEPA: Verified Evolving Formal Policy for Lifelong LLM Agent Guardrails
safety and guardrailstest

VEPA: Verified Evolving Formal Policy for Lifelong LLM Agent Guardrails

VEPA replaces LLM-inference-based adaptive guardrails and static pre-deployment formal policies with deterministic symbolic rules that an LLM patches from deployment feedback, gated by a deterministic verifier and an evidence-threshold activation layer. It costs additional infrastructure: typed event schemas, a rule engine, a patch-verification pipeline, evidence tracking, and LLM calls for policy proposals, plus latency for rule evaluation before each guarded action. It can fail when feedback is corrupted or sparse so valid risks never accumulate enough evidence to activate rules, when the LLM proposes patches the verifier cannot reconcile with existing behavior, and when agent actions are not cleanly expressible as typed events, leaving gaps in coverage.

observed signal
1impl.
14stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.12984
First page of Work2Skill: Capturing Human GUI Experience for Reusable Agent Skill Induction
planning and decompositiontest

Work2Skill: Capturing Human GUI Experience for Reusable Agent Skill Induction

The method replaces hand-written prompts, scripts, or manual in-context instructions for GUI agents with skills automatically induced from synchronized human screen, mouse, keyboard, and accessibility-tree recordings. It costs infrastructure for capturing and aligning demonstrations (WorkRecorder), an agentic induction pipeline that inspects recorded evidence, and the added context length of injecting skills at execution time; no model training is required, so it fits API-based operation. It can fail when workflows change with software updates, when demonstrations omit edge cases or encode task-specific details as rules, and the gains are validated on only two benchmarks with 350 demos, so transfer to a given production application is unproven.

observed signal
1impl.
14stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.12596
First page of SpireBench: Evaluating Long-Horizon Strategic Play of Agentic Models with Slay the Spire
agent evaluationwatch

SpireBench: Evaluating Long-Horizon Strategic Play of Agentic Models with Slay the Spire

SpireBench replaces short, episodic agent benchmarks with full Slay the Spire runs at maximum difficulty, offering diagnostics that separate stored knowledge, reasoning, and luck across a long horizon. It costs integration effort with a custom game harness and significant API spend per run, since complete playthroughs at frontier difficulty are long and token-heavy, and it provides no deployable model or pipeline improvement. Findings can fail to transfer: renaming experiments show part of measured performance rests on prior game knowledge, so scores on this benchmark may not predict competence on a reader's proprietary long-horizon tasks.

observed signal
2impl.
136stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.12655
First page of CLEAT: Learning Value-Guided Clarification for Interactive Agents
otherwatch

CLEAT: Learning Value-Guided Clarification for Interactive Agents

CLEAT replaces heuristic or fixed prompting strategies for deciding when an agent should ask clarifying questions with a learned controller and task policy co-trained via paired rollouts that estimate residual query value. It costs an RL training pipeline with paired rollout collection from identical interaction histories, iterative controller-guided data generation, and retraining as the policy evolves, which exceeds typical 24 GB single-GPU and small-budget constraints even at 4B scale. After adoption, value estimates can become stale or biased as the policy shifts, clarification behavior may overfit the training benchmarks' underspecification patterns, and the controller can mispredict query value on real users whose answers differ from simulated interaction outcomes.

observed signal
2impl.
136stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.12757
First page of MADS: Multi-Agent Dialog Simulation for Robust Conversational Agents
agent evaluationtest

MADS: Multi-Agent Dialog Simulation for Robust Conversational Agents

MADS replaces hand-collected or purely cooperative dialogue corpora with a multi-agent simulation pipeline that injects adversarial user behavior, plus an associated benchmark (six domains, 55 personas, 1095 conversations, ~66% failure-prone trajectories) for training and evaluating tool-calling agents. The cost is the generation and validation compute (feasible via third-party LLM APIs on a constrained budget), pipeline engineering effort, and a two-stage SFT-plus-RLVR training regime that itself requires non-trivial infrastructure if replicated. What can fail: simulated adversarial personas may not match real user distributions, the abstract reports no quantified robustness improvement over baselines, and RLVR on a single 24 GB GPU is practical only for small models, so gains may not transfer to the reader's deployment scale.

observed signal
2impl.
136stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.12789
First page of EvoBelief: Falsifiable World Models for Self-Improving LLM Agents
memory and contexttest

EvoBelief: Falsifiable World Models for Self-Improving LLM Agents

It replaces opaque accumulation of experience, reflections, or skills with an explicit, versioned store of environment rules stated as falsifiable hypotheses, each validated by independent observations or controlled experiments before guiding the frozen LLM's plans. It costs additional API calls and latency for hypothesis formation, validation experiments, and rule scoping, plus the engineering complexity of maintaining the evidence-linked rule store. Incorrect or prematurely validated rules can propagate across tasks, and validation experiments may be unsafe or impossible in environments without a resettable sandbox.

observed signal
2impl.
136stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.12514
First page of CORAL-KV: Compact Cross-Layer Prediction and Residual Coding for Autoregressive Video KV Caches
KV cachetest

CORAL-KV: Compact Cross-Layer Prediction and Residual Coding for Autoregressive Video KV Caches

Coral-KV replaces clustering-based video KV-cache quantization (e.g., QVG-4/QVG-Pro) with cross-layer prediction: compact block-diagonal-plus-low-rank predictors estimate keys and values in later layers from earlier cache states, and only the residuals are quantized. The cost is fitting and storing the predictors, an optional per-video refit of block-diagonal components for higher fidelity, and added implementation complexity, with latency reported as comparable to baselines. It can fail if cross-layer dependencies are weak in a different model architecture, if residual coding error still compounds over very long generations, or if the reusable predictors do not transfer to videos outside the calibration distribution.

observed signal
1impl.
25stars
0citations
1.92xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.13075
First page of LongHarness: Advancing Agentic Reasoning over 100M-Token Corpora via Stateful Evidence Management
memory and contexttest

LongHarness: Advancing Agentic Reasoning over 100M-Token Corpora via Stateful Evidence Management

LongHarness replaces implicit evidence tracking in a growing interaction history with an explicit Evidence-Conclusion Coevolution loop, in which unresolved conclusions direct retrieval and new evidence revises conclusions, plus lifecycle management that keeps evidence current and traceable. The cost is additional orchestration complexity and more model calls per query, since state must be maintained, updated, and consulted throughout the interaction, increasing latency and API spend relative to single-pass retrieval. It can fail when the conclusion state itself is wrong and steers exploration away from relevant evidence, when lifecycle updates drop or mislabel evidence, and on workloads whose questions do not require cross-document evidence integration, where the added machinery yields little over simpler RAG.

observed signal
1impl.
132stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.13152
First page of Quality, Not Just Outcome: A Structural Scoring Framework for Selecting Coding-Agent Trajectories for Supervised Fine-Tuning
coding agentstest

Quality, Not Just Outcome: A Structural Scoring Framework for Selecting Coding-Agent Trajectories for Supervised Fine-Tuning

TQS replaces outcome-only filtering and LLM-judge-based selection of coding-agent SFT trajectories with a linear-time structural score measuring information focus, intent-action alignment, and policy dynamics. It costs only the scoring pass over an existing trajectory corpus, but presupposes that the reader has or can generate a large pool of successful trajectories and the budget to run SFT experiments. It can fail if the structural heuristics do not transfer to the reader's agent framework, tool schema, or task distribution, since the ranking signal was validated on one public corpus and one benchmark.

observed signal
1impl.
132stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.07730
First page of SanSi: A Looped Typed Decision Model for System 1.5 Thinking
efficient architecturestest

SanSi: A Looped Typed Decision Model for System 1.5 Thinking

SanSi replaces generated chain-of-thought reasoning and large single-pass classifiers with a small looped language model that recursively re-applies its layers before a single typed readout, with one model serving any compute budget from one to eight loops. It costs a looped pre-trained backbone, multi-loop training with a proper scoring rule, and up to 8x the forward-pass latency of a single-pass model, though with no KV growth from generated tokens. It can fail on tasks needing explicit intermediate text, on decision formats outside the declared-option setting, or if the reported gains do not transfer from the paper's 59-source benchmark to the reader's domain, and adopting it requires reproducing the authors' specific training recipe rather than fine-tuning an off-the-shelf model.

observed signal
0impl.
2stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.07767
First page of TRACE: Rollout-Guided Quantization-Aware Training for FP4 Reinforcement Learning of MoE Language Models
quantizationwatch

TRACE: Rollout-Guided Quantization-Aware Training for FP4 Reinforcement Learning of MoE Language Models

TRACE replaces independent train-side and rollout-side FP4 quantization in RL post-training with rollout-guided quantization-aware training that aligns the two quantized execution paths, plus a caching scheme that selectively stores mantissa and scale data from deeper layers. It costs additional training-time machinery: quantization-information caching and communication between rollout and training paths, implementation complexity in the RL stack, and reliance on FP4-capable hardware to realize the speedup. It can fail if the target hardware lacks native FP4 support (negating throughput gains), if the workload is inference rather than RL training (where the method does not apply), or if train-rollout discrepancy is not the accuracy bottleneck in the reader's setting.

observed signal
0impl.
10stars
0citations
5.4xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.07780
First page of APEX: Speculate smarter, not deeper
speculative decodingtest

APEX: Speculate smarter, not deeper

It replaces fixed speculative decoding configurations (a single drafting method and a constant draft depth) with a request-level router among EAGLE-3, n-gram, and draft-model speculation plus block-level depth adaptation driven by verifier feedback. It costs training and maintenance of a learned survival-model controller, integration changes in the serving stack (vLLM), and the presence of multiple draft mechanisms resident in memory, though the target model and its verification procedure are unchanged. It can fail when controller signals mispredict acceptance on out-of-distribution workloads, when EAGLE-3 or draft-model heads are unavailable for the deployed model, or when the speedup does not transfer from the reported Qwen3-8B setup to other models or traffic mixes.

observed signal
0impl.
0stars
0citations
4.27xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.07781
First page of Quantization Effects on Tool-Failure Recovery Vary Across Prompts and Evaluation Designs
agent evaluationadopt

Quantization Effects on Tool-Failure Recovery Vary Across Prompts and Evaluation Designs

This replaces ad hoc robustness evaluation (single prompt, fault-screened task subsets, implicit scoring policy) with a protocol requiring matched-task comparison, full-pipeline success reporting, stated scoring policies, and task-level uncertainty quantification. It costs additional evaluation runs across multiple prompts and scoring variants, plus the effort to rerun logs under different executor leniency settings; it requires no new infrastructure beyond what an engineer already uses for offline benchmarking. It can fail if treated as a one-time checklist: the paper shows conclusions reverse across prompts and scoring policies, so a deployment decision based on a single configuration remains unreliable even after adopting the protocol partially.

observed signal
0impl.
0stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.07782
First page of Persistent Memory in Multi-Agent LLM Inference: What It Costs, What It Buys, and When You Can Tell
agent evaluationtest

Persistent Memory in Multi-Agent LLM Inference: What It Costs, What It Buys, and When You Can Tell

A persistent memory tier storing and recalling reasoning traces replaces per-call re-derivation of intermediate reasoning, layered on top of multi-agent decomposition that bounds the active KV cache. It costs +0.368 MiB of peak cache per query plus the engineering complexity of trace storage, retrieval, and mandatory state reset between independent queries, with no measured accuracy benefit on single-question benchmarks. It fails when tasks supply their own evidence and are scored independently, since recalled traces then contain nothing informative, and poorly controlled ablations can hide this null behind measurement artifacts.

observed signal
0impl.
0stars
0citations
2.48xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.07816
First page of Do I Need the Cloud? Uncertainty-Aware Step-Level Handoff for Small Language Model Agents
tool usetest

Do I Need the Cloud? Uncertainty-Aware Step-Level Handoff for Small Language Model Agents

Replaces once-per-query model routing (or always-on cloud inference for agents) with per-step uncertainty scoring that escalates only difficult agent actions from a local SLM to a stronger backend. Costs a scoring/escalation mechanism per step, roughly 30% cloud action volume, and the engineering complexity of maintaining two model backends plus threshold calibration. Can fail if the uncertainty signal miscalibrates on out-of-distribution tasks, since evidence comes from one model family, one stronger backend, scripted tasks, and small test sets.

observed signal
0impl.
0stars
0citations
1.23xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.07822
First page of Nucleus Speculative Decoding: Plausibility-Aware Verification Beyond Exact Distribution
speculative decodingtest

Nucleus Speculative Decoding: Plausibility-Aware Verification Beyond Exact Distribution

NSD replaces the standard exact-distribution acceptance rule in speculative decoding with a relaxed rule that also accepts draft tokens inside the target model's nucleus. It costs no extra model or memory beyond an existing draft-target setup, but introduces bounded distributional deviation that scales with the draft's excess probability inside the target nucleus and can accumulate across the sequence. It can fail when the relaxed acceptance degrades output quality on distribution-sensitive tasks, so fidelity on the actual workload must be validated before production use.

observed signal
0impl.
0stars
0citations
3.15xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.07853
First page of Lost in the bf16 Cast: Exporting Ternary Language Models Can Revert Most Low-Learning-Rate Code Changes
quantizationadopt

Lost in the bf16 Cast: Exporting Ternary Language Models Can Revert Most Low-Learning-Rate Code Changes

The technique replaces the standard ternary export path (cast latent weights to bf16, then requantize with the stock exporter) with either writing the training quantizer's codes directly or adjusting bf16 inputs so unchanged tools emit the correct codes. It costs nothing in memory, latency, or model quality; the only cost is a small modification to the export/save pipeline and a validation pass comparing exported codes against the training quantizer. What can fail: teams unaware of the issue may ship silently corrupted models, since bf16 rounding maps near-threshold values to zero and can revert most low-learning-rate fine-tuning changes, and the fix only matters if the reader actually fine-tunes or exports ternary models such as BitNet, Falcon-E, or BitCPM.

observed signal
0impl.
0stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.07859
First page of Tram-FL: Reducing Communication and Computation Costs through Sequential Model Circulation in Decentralized Federated Learning
efficient trainingnot applicable

Tram-FL: Reducing Communication and Computation Costs through Sequential Model Circulation in Decentralized Federated Learning

Tram-FL replaces conventional decentralized federated learning, where every client holds a model copy, updates it locally, and exchanges and aggregates copies, with a single model circulated sequentially among nodes along a scheduled route with allocated update iterations and quantized momentum. The cost is the loss of parallel client computation: training is serialized over the circulation route, so wall-clock training time grows with the number of nodes, and the mechanism requires solving a scheduling problem for route and iteration allocation plus implementing quantized momentum. It can fail through slow convergence on a poorly chosen circulation schedule, sensitivity to node stragglers or dropouts since the single circulating model is a serialization point, and irrelevance outside federated settings since the method presumes distributed data ownership that most production teams do not have.

observed signal
0impl.
0stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.07863
First page of ReFold: Training-Free Reversible Inter-Turn Context Folding for Long-Horizon Agents
memory and contextadopt

ReFold: Training-Free Reversible Inter-Turn Context Folding for Long-Horizon Agents

ReFold replaces predictive context-management methods (auxiliary model calls, heuristic rules, or trained compression policies) with a training-free rendering layer that stubs content already displayed in earlier turns and folds agent-reported-finished turns into one-line notes, using chunked rendering that rewrites the cached prefix only every few steps. It costs implementation effort in the prompt-rendering layer of the harness and occasional one-step restores from the preserved history when a removal proves wrong, plus minor prefix-cache rewrites at chunk boundaries. It can fail when the agent incorrectly marks a turn as finished and later needs its details, requiring restores that add latency, and the reported gains may not transfer to workloads with low inter-turn redundancy or non-ReAct harness structures.

observed signal
0impl.
0stars
0citations
3.4xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗

Research signals

Three views of the same evidence: adoption against attention, publication cadence by research area, and reported gains when coverage is sufficient.

color = research area

01 · attention × adoption

The research frontier

Look to the upper left for independent implementation before mass attention.

compare by
Each point represents one paper. Higher means more independent implementations; farther right means more GitHub stars.Random Attention: Rethinking KV Cache Eviction for Efficient Reasoning: 73 GitHub stars; 3 independent implementationsMetaKV: Adaptive KV Cache Compression for Constrained LLM Inference: 0 GitHub stars; 2 independent implementationsMTVA-Bench: Evaluating the Language Model Inside Cascaded Voice Agents: 4 GitHub stars; 3 independent implementationsSanSi: A Looped Typed Decision Model for System 1.5 Thinking: 2 GitHub stars; 0 independent implementationsTRACE: Rollout-Guided Quantization-Aware Training for FP4 Reinforcement Learning of MoE Language Models: 10 GitHub stars; 0 independent implementationsAPEX: Speculate smarter, not deeper: 0 GitHub stars; 0 independent implementationsQuantization Effects on Tool-Failure Recovery Vary Across Prompts and Evaluation Designs: 0 GitHub stars; 0 independent implementationsPersistent Memory in Multi-Agent LLM Inference: What It Costs, What It Buys, and When You Can Tell: 0 GitHub stars; 0 independent implementationsDo I Need the Cloud? Uncertainty-Aware Step-Level Handoff for Small Language Model Agents: 0 GitHub stars; 0 independent implementationsNucleus Speculative Decoding: Plausibility-Aware Verification Beyond Exact Distribution: 0 GitHub stars; 0 independent implementationsLost in the bf16 Cast: Exporting Ternary Language Models Can Revert Most Low-Learning-Rate Code Changes: 0 GitHub stars; 0 independent implementationsTram-FL: Reducing Communication and Computation Costs through Sequential Model Circulation in Decentralized Federated Learning: 0 GitHub stars; 0 independent implementationsReFold: Training-Free Reversible Inter-Turn Context Folding for Long-Horizon Agents: 0 GitHub stars; 0 independent implementationsApexQuant: Data-Free Elastic Quantization by Residual Re-Isotropization: 0 GitHub stars; 0 independent implementationsHE-OFT: Privacy-Preserving One-Shot Federated Fine-Tuning under Homomorphic Encryption: 0 GitHub stars; 0 independent implementationsThe Harness as the Only Mutable Surface: Compliance-Bounded Self-Evolution of LLM Agents in Credit Pipelines, with a Measured Admission Gate: 1 GitHub star; 0 independent implementationsBRANCH: Bypassing Multi-Scanner AI Guardrails: 1 GitHub star; 0 independent implementationsCORAL-KV: Compact Cross-Layer Prediction and Residual Coding for Autoregressive Video KV Caches: 25 GitHub stars; 1 independent implementationCircuitTree: Composing Circuits into A Syllable Transcriber: 4 GitHub stars; 0 independent implementationsBehind-the-Meter Photovoltaic Visibility from Net Smart Meters: Deployment Regimes and Operational Insights: 4 GitHub stars; 0 independent implementationsSWE-Duel: Towards a Self-Scaling Arena for Coding Agents: 18 GitHub stars; 2 independent implementationsContextual Correction of Parallel Draftsfor Speculative Decoding: 149 GitHub stars; 2 independent implementationsOne Model to Loop Them All: Elastic Latent Recurrence for Language Models: 126 GitHub stars; 2 independent implementationsSpireBench: Evaluating Long-Horizon Strategic Play of Agentic Models with Slay the Spire: 136 GitHub stars; 2 independent implementationsSoftwareGym: Scaling Computer-Use Agent Training with Diverse Synthesized Software Environments: 14 GitHub stars; 1 independent implementationCLEAT: Learning Value-Guided Clarification for Interactive Agents: 136 GitHub stars; 2 independent implementationsKronecker Product Attention: Memory-Efficient KV Compression via Structured Factorization: 4 GitHub stars; 0 independent implementationsRecurrent Harness for Agentic Continual Learning: 14 GitHub stars; 1 independent implementationByzantine-Resilient Federated Large Language Model via Hypergraph Message Passing: 4 GitHub stars; 0 independent implementationsZebra3D: Efficient Hybrid Foundation Models For Scalable 3D Reconstruction: 1510 GitHub stars; 1 independent implementationHow Do Hardware Faults Manifest Differently in LLM Agents?: 14 GitHub stars; 1 independent implementationMADS: Multi-Agent Dialog Simulation for Robust Conversational Agents: 136 GitHub stars; 2 independent implementationsEvoBelief: Falsifiable World Models for Self-Improving LLM Agents: 136 GitHub stars; 2 independent implementationsVEPA: Verified Evolving Formal Policy for Lifelong LLM Agent Guardrails: 14 GitHub stars; 1 independent implementationVulnerable Models in the AI Supply Chain: An Empirical Study of Adoption, Propagation, and Usage Patterns: 4 GitHub stars; 0 independent implementationsWork2Skill: Capturing Human GUI Experience for Reusable Agent Skill Induction: 14 GitHub stars; 1 independent implementationEmbodiedCLBench: Evaluating Continual Learning for Self-Evolving Embodied Agents: 365 GitHub stars; 3 independent implementationsDon't Guess, Just Ask: Evaluating Interactive Requirement Clarification for Repository-Level Software Development: 0 GitHub stars; 0 independent implementationsEvo$^2$: Evolving the Evolver through Weight-Harness Co-Evolution: 122 GitHub stars; 0 independent implementationsTestSuiteBench: Coding Agents Struggle to Generate Strong Test Suites from Specifications: 1 GitHub star; 0 independent implementationsLongHarness: Advancing Agentic Reasoning over 100M-Token Corpora via Stateful Evidence Management: 132 GitHub stars; 1 independent implementationDRYLAB-Bench: Benchmarking the Biosecurity Risk of Agentic LLM Mutation Design: 142 GitHub stars; 3 independent implementationsQuality, Not Just Outcome: A Structural Scoring Framework for Selecting Coding-Agent Trajectories for Supervised Fine-Tuning: 132 GitHub stars; 1 independent implementation

Papers above 1000 stars or 200 citations are not scored. They have already broken through the attention threshold, while Paperraft is designed to identify earlier signals.

02 · cadence

Research areas over time

Compare monthly publication volume on a shared scale and calendar.

coding agentsmax 10Sep 26: 0 papersOct 26: 2 papersSep 26Oct 26efficient architecturesmax 10Sep 26: 0 papersOct 26: 2 papersSep 26Oct 26agent evaluationmax 10Sep 26: 1 paperOct 26: 10 papersSep 26Oct 26KV cachemax 10Sep 26: 2 papersOct 26: 2 papersSep 26Oct 26speculative decodingmax 10Sep 26: 0 papersOct 26: 3 papersSep 26Oct 26sparsity and pruningmax 10Sep 26: 0 papersOct 26: 2 papersSep 26Oct 26memory and contextmax 10Sep 26: 0 papersOct 26: 4 papersSep 26Oct 26othermax 10Sep 26: 0 papersOct 26: 2 papersSep 26Oct 26planning and decompositionmax 10Sep 26: 0 papersOct 26: 1 paperSep 26Oct 26quantizationmax 10Sep 26: 0 papersOct 26: 3 papersSep 26Oct 26safety and guardrailsmax 10Sep 26: 0 papersOct 26: 7 papersSep 26Oct 26efficient trainingmax 10Sep 26: 0 papersOct 26: 1 paperSep 26Oct 26tool usemax 10Sep 26: 0 papersOct 26: 1 paperSep 26Oct 26

Every panel uses the same calendar and vertical scale. An empty column means no papers were recorded.

Method under scrutiny

Inspect the highest-ranked paper, every repository behind its signal, and the rule used to classify each one.

MetaKV: Adaptive KV Cache Compression for Constrained LLM Inference

KV cache · test · 2 of 2 implementations are independent

MetaKV replaces a single fixed KV cache compression configuration with per-prompt selection among existing methods (KVQuant, H2O, RocketKV, FP16) guided by lightweight predictors of latency, peak memory, and correctness. The cost is training and maintaining three prediction models plus a selection step per prompt, adding engineering complexity and a small inference-time overhead on top of the underlying compressors. It can fail if the accuracy or latency predictors mispredict on out-of-distribution prompts or on hardware and models different from the evaluation setup, causing constraint violations or suboptimal choices.

Exclusions and controls

Every exclusion is counted and published.

Exclusion counts were not recorded for this edition.

0 previously indexed papers were rechecked in this run.

Paperraft tracks one signal: how many independent implementations a paper attracts on GitHub after author-owned repositories are removed. This is a discovery signal to investigate, not a measure of implementation quality.

It does not claim that a method works. Paperraft runs no reproduction benchmarks. Reported gains remain author claims until independently tested. Papers above the attention threshold are excluded because this publication is designed to identify research before consensus forms.