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.
Start with a brief. Follow the evidence. Choose a test.
edition
2026-09-16
briefs
42
research areas
13
independent implementations
23
25 of 42 papers in the index (60%) 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.
AsymSpec replaces the standard lossy choice between input compression and full-context inference by letting a lightweight drafter read the full input while the large verifier generates against a compressed view, fusing their logits with a contrastive delta-fusion and a divergence-aware acceptance gate. The cost is running two models (drafter plus verifier) with dual context representations and a non-standard decoding loop, which increases memory footprint and implementation complexity relative to plain compression or off-the-shelf speculative decoding served through third-party APIs. It can fail when the divergence gate misjudges draft reliability, collapsing acceptance rates and erasing the speedup, and the reported gains are on isolated capabilities and two benchmarks, so end-to-end agentic workloads with heavy tool-call branching may see smaller benefits.
The method replaces undefended agent execution with a layered defense stack: Isolation Forest anomaly detection to filter attacker-injected tools, restoration of the original toolset before planning, plus Chain-of-Thought prompting, self-reflection, and task paraphrasing. It costs additional inference passes for reasoning and paraphrasing (raising latency and API spend), a white-box toolset snapshot requirement, and an anomaly detector that needs tuning against false positives on legitimate tools. It can fail against adaptive attacks crafted to evade the anomaly detector, against novel attack vectors outside the four studied categories, and through over-filtering that removes tools needed for task completion.
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.
LCAP replaces per-device optimization-based calibration of photonic neural network chips with a shared population correction plus feed-forward latent personalization inferred from 32 unlabeled output probes. It costs an offline stage requiring 80 historical calibrated chips to learn the shared correction and latent space, and the reported gains are demonstrated only on a three-layer MZI simulator, not fabricated hardware. It can fail if the target fleet's error distribution drifts from the historical population, if 32 probes insufficiently identify a device's latent coordinates, or if simulator-modeled noise (phase variation, crosstalk, quantization) underestimates real fabrication effects.
Emergence World replaces single-response model evaluation with continuous adversarial stress-testing of long-horizon multi-agent systems, injecting prompt injection, misinformation, and memory exposure through ordinary interaction surfaces after operational state accumulates. The cost is prohibitive for constrained infrastructure: the study required 16 days, eight parallel worlds, over 850,000 LLM calls, and roughly 50 billion tokens, plus substantial engineering of persistent memory, tools, and shared institutions. What can fail in adoption is that results from large homogeneous frontier-model worlds may not transfer to a small production deployment, and the paper offers findings rather than mitigations, so detected failure modes such as memory poisoning and delayed action on adversarial content remain unsolved.
The method replaces the ad-hoc choice between reloading all prior engineering evidence (tests, type checks, proofs, static analyses) or discarding it, by computing a minimum-cost subset of evidence whose forward-chaining closure over a typed inference graph re-establishes the properties a code change must preserve. The cost is building and maintaining the typed inference graph from prior agent-run artifacts, specifying per-task obligations, and running a CP-SAT solver plus closure validation; solve time is small in practice (median under 20 ms at 500-evidence graphs) but the approach presumes obligations are known, which the authors state remains an open problem. It can fail when no subset of current evidence re-establishes a required property (the envelope does not exist), when graphs contain many alternative derivations per target (solver timeouts at far smaller sizes), or when obligations are mis-specified, since correctness depends entirely on the graph and requirements supplied to it.
Blindspot replaces single-turn or binary attack-success safety evaluation with trajectory-level adjudication of long-horizon tool-using agents, classifying each run as Safe Completion, Correct Refusal, Unsafe Completion, Over-Refusal, or Indeterminate across 22 attack families and 35 stateful scenarios. Adopting it costs multi-turn simulation infrastructure: stateful tool execution, adaptive adversarial interaction, execution-grounded adjudication, and API or GPU compute for trajectories averaging 14.7 turns, which at 2,500 trajectories implies a non-trivial evaluation budget. It can fail through adjudication errors in the Indeterminate category, scenario coverage gaps relative to the reader's actual tool surface, and results that depend heavily on which models and policies are instantiated, so benchmark rankings may not transfer to a specific production agent.
This method replaces pure prompt engineering for controlling agent behavior in simulations with direct manipulation of internal activations: sparse autoencoders decompose representations into interpretable features, and probe-derived steering vectors then push behavior in a target direction. It costs white-box access to the model (ruling out most third-party APIs), an open-weight model that fits the 24 GB GPU, plus the engineering effort to train or obtain SAEs and probes and validate steering per behavior. It can fail when no pretrained SAE exists for the chosen model, when steering vectors generalize poorly across tasks or model versions, when steering degrades unrelated capabilities, and when the claimed advantage over well-designed prompting does not replicate on the reader's workload.
RepoAtlas replaces static or full-graph repository context in coding agents with a training-free select--project--refresh loop that maintains a bounded, evolving visual-plus-textual view of a code graph. It costs graph construction per repository, a rendering and refresh pipeline, and added orchestration complexity, though it modestly reduces token and call counts. It can fail if the selection step misses the truly relevant code region, if refresh triggers lag exploration and serve stale views, or if the target model's multimodal handling degrades with dense graph renderings.
The method replaces purely outcome-based RL reward for tool-use policies with a dense, decision-level reward in which an LLM judge scores the necessity of each tool call. It costs judge inference on every tool decision during training, adds a judge-dependence and reward-design burden, and assumes the reader is already running RL fine-tuning of a tool-using agent. It can fail if the judge itself inherits cue biases or misjudges necessity, and the paper's evidence is limited to synthetic factual-QA and math environments, so transfer to production tool stacks is unverified.
EchoPath replaces repeated fresh observe-plan-ground-act loops for recurrent GUI tasks with validated, parameterized, callable memories that are deterministically replayed via image-based target re-aiming. The cost is building and maintaining an artifact-validated trajectory store, plus the engineering complexity of precondition checks, input rebinding, and fallback to bounded grounding repair or fresh planning when replay is rejected. Replay can fail when the GUI changes beyond what coordinate re-aiming can correct, when stored state preconditions no longer match the runtime, or when tasks are not actually recurrent enough to amortize memory creation.
The method replaces reliance on single-token zero-shot scoring and translated English benchmarks with native-language minimal-pair evaluation, tokenizer-swap sensitivity checks, and placebo-controlled prompting when assessing small language models. It costs little: no additional training or hardware, only extra evaluation passes and the effort of constructing or adopting native minimal-pair benchmarks, plus rank-16 LoRA fine-tuning for task evaluation. It can fail if native benchmarks do not exist for the target language or domain, if results are overgeneralized from the 125M child scale to production-size models, or if the diagnostics are treated as a substitute for task-relevant evaluation rather than a complement to it.
The technique replaces per-specialist re-prefilling of a shared context by computing the backbone's prefix KV cache once and reusing it across already-trained standard LoRA adapters. The cost is a small, inconsistent quality degradation on held-out tasks (e.g., -4.6 to -0.8 EM on GSM8K depending on token budget and seed), and the tested implementation copied rather than physically shared KV storage, yielding only 12% lower two-branch peak memory. It can fail when adapter quality degrades beyond tolerance, since no boundary-selection rule or quality equivalence is established and partial recomputation showed no demonstrated benefit.
Replaces single-turn alignment objectives (PPO, DPO, GRPO) with a turn-level weighted, asymmetric token-level objective for multi-turn agent post-training. Costs: requires preference or positive/negative trajectory data across multi-turn tasks, a modified training loop, and post-training compute that on one 24 GB GPU realistically limits model size (roughly 7B-class with parameter-efficient methods or heavy quantization). Can fail because abstract-level claims of competitive performance provide no verified magnitude, turn-weighting hyperparameters may not transfer to a different tool-use distribution, and small teams bear the engineering cost of integrating a nonstandard objective over mature GRPO/DPO tooling.
The method replaces LLM-inferred joins and free-form tool calls over heterogeneous data sources with an ontology-constrained Virtual Knowledge Graph and deterministic pre-execution validation, so a question becomes one validated graph traversal. It costs the upfront effort of building and maintaining a domain ontology and mapping data sources into the graph, plus added system complexity around the validation layer. It can fail when the ontology is incomplete or drifts from the underlying schema, when questions fall outside the modeled domain, or when the validation layer rejects legitimate queries, and the reported gains come from a single telemetry domain and may not transfer.
SEAA replaces static prompts and passive text memory with an editable HMM state-transition matrix encoding behavioral inertia, updated by a reflexive metacognition loop and social comparison among agents. Costs include added architectural complexity, extra LLM calls for reflection, and a state-update mechanism whose stability must be maintained, with no claim of task-performance improvement. It can fail through oscillating or collapsing HMM state transitions, unbounded personality drift in the opposite direction, and self-narratives that are artifacts of prompting rather than functional behavior; it addresses research questions about emergent agent identity, not production reliability or capability.
LACE replaces single shared segmentation boundaries in dynamic frame-rate neural audio codecs with an independent compression step at each quantization layer, plus union alignment and boundary anchors so layer token streams stay duration-consistent for TTS. The cost is added codec complexity: per-layer compression modules and alignment logic must be trained and maintained, and adoption requires integrating the ESPnet3 codec recipe and retraining or fine-tuning the codec and downstream TTS model. It can fail if layer-specific boundaries interact poorly with an existing TTS stack, if reconstruction gains do not transfer to your data domain beyond LibriTTS, or if the alignment mechanisms erode the frame-rate reduction under different speech characteristics.
The method replaces vanilla offline SFT on raw teacher traces with SFT over teacher trajectories rewritten into explicit observation-thought-action chains, plus sample reweighting that favors post-edit verification behavior. The cost is access to strong-agent teacher trajectories from the target environment, trajectory rewriting, and fine-tuning capacity for a 30B model, which exceeds a single 24 GB GPU without aggressive quantization and is easier via rented compute. It can fail when teacher behavior does not transfer to the reader's task distribution, when rewritten chains teach superficial reasoning formats, and because the gains are demonstrated only in one arena-style benchmark, not general coding workloads.
This replaces the assumption that fixed-state recurrences (linear attention, SSMs) are inherently poor at associative recall: it attributes the gap to the missing short convolution and to training interference, and fixes both via a convolution plus a distance or accuracy-gated curriculum. The cost is architectural modification to the recurrent cell and a curriculum schedule with per-seed retraining, all on synthetic benchmarks rather than validated production tasks. It can fail because results are confined to synthetic masked multi-query recall, lock-in remains a seed lottery (7/10, not 10/10), the uniform curriculum and simple ramp collapse at longer lengths, and transfer to real language-modeling workloads is unproven.
DDO replaces per-checkpoint safety finetuning against Refusal Feature Ablation with a post-hoc weight edit that injects a high-magnitude nonlinear decoy signal into MLP neurons, corrupting the attacker's contrastive estimator of the refusal direction. It requires no base-model finetuning and runs at 30 to 450 times lower optimization cost than trained baselines, so it is feasible on a single 24 GB GPU. It can fail under adaptive multi-phase attacks, where worst-case ASR still reaches 65%, and it only defends against ablation-style attacks, not finetuning-based removal of safety behavior or other jailbreak classes.
The paper is a governance review, not an engineering method: it proposes replacing ad-hoc or absent biosecurity controls with tiered, capability-threshold-linked responsibilities across the biological AI stack, rather than replacing any specific model component. Adopting its framework costs organizational effort—capability evaluations, screening-evasion benchmarks, and audit processes—rather than GPU memory or latency, though any applied safeguards can add refusal overhead and false-positive blocking of legitimate queries. It can fail because alignment techniques transfer poorly to biological foundation models, so hazardous capabilities may persist undetected despite applied mitigations, and current uplift evidence is largely in-silico, meaning thresholds may be miscalibrated.
This is an evaluation benchmark, not a production technique; it replaces ad hoc testing of computer-use agents on CAD workflows with 200 executable-check FreeCAD tasks, so it supersedes manual or screenshot-level evaluation only if the reader builds engineering computer-use agents. Adoption costs include setting up a FreeCAD environment, running long GUI interaction episodes (expensive against third-party API pricing), and maintaining task-specific artifact validators. It can fail to transfer: benchmark tasks target FreeCAD GUI manipulation, and agent scores on it may not predict reliability in the reader's own workflows, tool stacks, or artifact schemas.
AgentGuard replaces manually written safety rules for coding agents with guardrails automatically mined from anomalous execution trajectories and injected as a lightweight skill that activates only rules relevant to the current instruction. Costs include collecting and labeling execution traces from your own agent stack, an additional retrieval-and-injection step in the agent loop, and extra context tokens per instruction; the paper itself notes a trade-off between safety and task completion. It can fail through rules that do not generalize across agents, models, or repositories, through overly restrictive constraints that block legitimate actions, and because a 26.7% residual abnormal execution rate remains.
The method replaces unconstrained context growth and naive trimming (recency, relevance, or summarization-based) with protocol-aware selection plus adaptive retained-context budgets that protect protocol-critical state in agentic workflows. It costs implementation complexity: the system must identify protocol-critical state (instructions, tool states, unresolved dependencies) and maintain budget-enforcement logic, and it retains roughly 44% more tokens than the most aggressive conventional trimming. Failure risk concentrates below 25% retained-context budgets, where failure odds rise 10.92-fold, and critical thresholds increase with workflow complexity, so a static configuration can silently degrade on harder tasks.
This paper does not propose a replacement technique; it provides a measurement framework (coupling-based decomposition and residual-branch conditional Monte Carlo) that quantifies how KV-cache eviction policies such as SnapKV and recent-token retention diverge from full-cache generation. Adopting the analysis itself costs nothing at inference but requires instrumented paired trajectories to estimate divergence timing and exposure, which adds engineering complexity without changing serving performance. What can fail is transferability: the finding that 85-90% of mismatch mass comes from post-divergence exposure is an exploratory result on 288 documents and two 7-8B models, so eviction-policy rankings and window conclusions may not hold for other workloads, models, or retention budgets.
GrowMTP replaces the separate pretraining or warm-up phase required to obtain a speculative-decoding draft head by training that head from scratch inside the RL loop, using rollout verification signals as supervision with gradients detached from the policy backbone. The cost is additional training compute and integration complexity within the RL framework, plus acceptance-rate variance while the head converges early in the run. It can fail to deliver end-to-end gains if rollouts are not the wall-clock bottleneck, if the workload's rollout distribution is too broad for the head to learn useful drafts, or when the model already ships with a strong draft head, where the reported gain shrinks to 1.20x.
The paper shows that in Noise2Noise-style clean-reference-free denoising, matching the training pair distribution to the target sensor noise replaces both clean ground-truth supervision and careful loss-function tuning as the dominant design decision. The cost is acquiring representative noisy-noisy pairs from the deployment domain (e.g., real camera data), plus a standard small denoiser training run that fits easily on a single 24 GB GPU; loss choice between L1 and L2 is nearly free either way. It fails when domain-matched noisy pairs cannot be collected, since a mismatched synthetic noise model caps gains at a few dB regardless of loss.
TEMPO replaces single-observation inference in pretrained VLA policies with two added inputs: a motion summary from a frozen video foundation model and a compact proprioceptive history, requiring no backbone modification. The cost is the additional frozen video model inference at runtime and minimal training/deployment compute overhead, plus dependency on annotated temporal data (the authors release a 50k-frame benchmark). It can fail if the frozen video encoder's motion summaries do not transfer to the reader's camera setup or task dynamics, if proprioceptive history is unavailable or noisy on the target robot, and gains are demonstrated on only four dynamic manipulation tasks.
LRQS replaces location-scale and post-nonlinear bivariate causal models with a low-rank decomposition of a monotonically transformed conditional quantile surface, fitted by alternating rank-constrained approximation and isotonic regression. The cost is a nonparametric, discretization-dependent fitting procedure that is restricted to bivariate cause-effect pairs and requires sufficient samples to estimate conditional quantiles reliably. Identifiability fails for exceptional, fine-tuned cause marginals where the reverse direction is also representable, and the score can degrade under strong nonlinear observation distortion, poor quantile discretization, or small sample sizes.
CLARE replaces full sequential fine-tuning and prompt/expanding-adapter continual-learning baselines with a two-stage procedure: identify a sparse task-critical parameter mask via a sparsity-inducing objective, then fine-tune only the masked parameters so all tasks share one adapter space. It costs an additional mask-identification training stage per task, extra mask bookkeeping, and hyperparameter tuning of sparsity levels, while remaining trainable on a single GPU since it only fine-tunes a pretrained backbone. It can fail if the sparsity objective selects poor masks for heterogeneous task distributions, if the shared adapter saturates on very long task sequences beyond the validated 100-task regime, or if the deployment problem is not class-incremental learning at all.
The method replaces monolithic multitask policies (a task-conditioned recurrent controller) with a shared recurrent core modulated by discrete, adapter-like low-rank perturbations that a frozen high-level policy sequences into novel movements. The cost is training a closed-loop biomechanical control stack end-to-end plus a discrete latent selection mechanism, which is a research training pipeline rather than an inference-time optimization. It can fail when the target domain is not closed-loop motor control: the discrete option structure and emergent low-rank subspaces are demonstrated only in biomechanical simulation, and the claim does not transfer to language, vision, or general production ML workloads.
This replaces convex-relaxation matrix completion solvers (nuclear-norm minimization) with nonconvex Riemannian gradient descent and Gauss--Newton that match convex sample complexity, O(μnr log n log(nκ)), while converging linearly or quadratically. The cost is implementing a custom Riemannian optimizer with a multiscale residual initialization, plus assumptions (low rank, incoherence, bounded condition number) that the data must actually satisfy. It can fail when the target matrix is not genuinely low-rank or incoherent, when the observation pattern is adversarial rather than random, or when initialization requirements are not met in practice.
This is a network-on-chip topology-routing co-design that replaces a standard mesh interconnect with a mesh augmented by a few traffic-aware express links placed under a fixed wire budget, using greedy placement refined by simulated annealing and committed top-K adaptive routing. It costs wire-budget allocation, placement optimization compute, and routing logic complexity, all at chip-design level. It can fail when traffic patterns deviate from those used to guide link placement, and it is entirely irrelevant to ML inference or training on a single 24 GB GPU or API-based stack.
ADORE replaces separate LIME/SHAP-style local explanations and global feature-importance analyses with a single derivative-based framework that uses first- and second-order derivatives, randomized SVD, and dynamic sparsity detection. It costs integration effort into existing explanation pipelines, requires differentiable model access or reliable derivative approximations, and adds implementation complexity relative to mature libraries like SHAP, though an open-source package is available. It can fail if the target model's gradients are unavailable or noisy (e.g., black-box APIs or non-smooth tree ensembles), if the claimed efficiency gains do not hold at the reader's data scale, or if explanations prove unstable under the randomized decomposition.
LoopSpec replaces standard autoregressive decoding in Looped Transformers with a training-free self-speculative scheme in which early recurrent depths draft tokens, deeper depths optionally re-propose, and the full model verifies, pipelined so drafting overlaps verification. It costs additional implementation complexity in the decoding loop and extra compute for verification and the selective second proposal, though it requires no auxiliary draft model and no retraining. It can fail to deliver speedup if draft acceptance rates are low on the target workload, and it applies only to Looped Transformer architectures, which are not the mainstream open-weight models the reader is likely to deploy.
Replaces draft-model-free speculative decoding methods (and the need for a separate draft model) by reusing early-layer bonus logits for cheap multi-step draft-tree exploration while final-layer logits verify and correct paths in a low-frequency outer loop. Costs a one-shot fine-tuning pass for the bonus logits, plus implementation complexity in tree construction and state reuse; it adds no extra deployment parameters and claims negligible runtime overhead. It can fail when the fine-tuned early-layer logits miscalibrate on domain-shifted workloads, when GPU memory pressure from tree verification erodes gains, and it is unusable for models accessed only through third-party APIs since it requires access to internal layer activations.
Cartridges replace passing documents in the context window (or fine-tuning them into parameters) with pre-trained KV-cache representations that are loaded at inference time. The cost is a training pass per document collection to produce the cartridges, storage of the resulting KV caches, and a 6% degradation on control benchmarks (13% on coding) due to catastrophic forgetting. The main failure modes are forgetting on unrelated tasks and degraded accuracy when Compaction is substituted at compression rates above 50x, where it trails parametric methods by 10 points.
The method replaces manual, expert-driven performance tuning across the serving stack (GPU kernels, framework computation graph, model server such as Triton's C++ code, and a Python feature-transformation service) with an AI agent that discovers and applies optimizations across those heterogeneous layers. The cost is building or obtaining an extensible agent framework with per-layer tooling, benchmarks, and validation infrastructure, plus the inference cost of the agent itself; no off-the-shelf artifact or released system is described that a small team could install directly. Failures after adoption can include agent-generated optimizations that pass benchmarks but violate correctness or stability under production traffic, regressions when workloads evolve and discovered optimizations go stale, and maintenance burden for agent-written changes in low-level codebases the team does not fully understand.
Replaces rank-based interpretation of small SWE-bench score gaps with a five-step audit: shared-outcome profiling, paired McNemar tests, tier grouping with multiple-comparison correction, and instance-budget estimation for resolving differences. Costs only analysis effort on existing published submissions, requiring no model runs, GPU time, or new infrastructure, though applying it to private systems requires access to per-instance outputs. Can mislead if non-rejection is read as equivalence, if the observational scaffold comparisons are treated as causal, or if the comparison set is unrepresentative of the reader's actual workload.
The paper replaces the folklore rationale for splitting tasks across agent trees with a retention model showing each tier discards a fixed fraction of leaf findings, so it argues against default hierarchical decomposition rather than proposing a new method. Adoption of its guidance costs nothing in infrastructure but forgoes decomposition's real benefits: bounding root-context exposure to N^(1/k) items and lower billing at very large finding counts. What can fail is applying the population-level parameters (delta=0.34, C=0.571, mu=0.939) to a workload whose item granularity, tool boundaries, or brief quality differ, misjudging the rare cases where delegation genuinely pays.
JustFit replaces the standard mlx-vlm runtime's eager KV allocation and full-component residency with just-in-time materialization, compressed KV execution, and state-preserving transitions, independent of weight quantization. The cost is a specialized MLX-based runtime restricted to Apple Silicon, added systems complexity in state lifecycle management, and reliance on MXFP4-class compressed execution whose latency at long contexts (19.11 tokens/s at 32K input) is modest. Failure modes include reconstruction or swap errors corrupting long reasoning chains, degraded throughput under multi-request contention, and fragility outside the tested Qwen/MLX stack, with the AIME result serving as anecdotal rather than systematic quality evidence.
This is an evaluation study, not a new compression method: it assesses existing depth, width, hybrid, and expert pruning (followed by SFT) as replacements for full-size models in smart-home tool calling. The cost of adopting pruning is a post-pruning fine-tuning stage plus evaluation effort, with dense models showing narrow safe pruning regions before sharp degradation, while MoE models tolerate substantially more pruning. After adoption, failures are non-obvious: grounded specificity (device, argument, value correctness) degrades before schema-level intent, so aggregate accuracy can mask broken tool calls, and aggressive dense pruning can cause systematic over-refusal.
Try another term or clear the filters to explore the archive.
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
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.
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.
speculative decoding · test · 2 of 3 implementations are independent · 1.7x gain in speed (reported by the authors; not independently verified)
AsymSpec replaces the standard lossy choice between input compression and full-context inference by letting a lightweight drafter read the full input while the large verifier generates against a compressed view, fusing their logits with a contrastive delta-fusion and a divergence-aware acceptance gate. The cost is running two models (drafter plus verifier) with dual context representations and a non-standard decoding loop, which increases memory footprint and implementation complexity relative to plain compression or off-the-shelf speculative decoding served through third-party APIs. It can fail when the divergence gate misjudges draft reliability, collapsing acceptance rates and erasing the speedup, and the reported gains are on isolated capabilities and two benchmarks, so end-to-end agentic workloads with heavy tool-call branching may see smaller benefits.
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.
