Skip to content

archived edition · 2026-09-30

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.

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

edition
2026-09-30
briefs
42
research areas
15
independent implementations
28

24 of 42 papers in the index (57%) 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 42
sort by
First page of When Agents Slow Down: Understanding LLM Agents' Test-Time Strategies via Elo-per-token Analysis
agent evaluationtest

When Agents Slow Down: Understanding LLM Agents' Test-Time Strategies via Elo-per-token Analysis

The method replaces uninstrumented agent budget allocation and single-score leaderboards with a per-token best-solution curve aggregated across tasks via a Bradley-Terry Elo model, using independent sampling as a reference to locate the point where marginal gains diminish. It costs additional evaluation infrastructure: tasks must expose continuous intermediate scores, trajectories must be logged per token, and Elo estimation plus reference sampling add compute and engineering effort on top of the agent runs themselves. It can fail when benchmarks lack intermediate scoring, when the independent-sampling reference is unrepresentative of the task, or when the empirically estimated inflection point does not transfer across models, tasks, or budget regimes.

observed signal
2impl.
0stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of Pruning for Efficiency, Paying in Fairness: Demographic Disparities in Pruned Speech-LLMs
sparsity and pruningadopt

Pruning for Efficiency, Paying in Fairness: Demographic Disparities in Pruned Speech-LLMs

The paper is an evaluation study, not a new compression method: it replaces the practice of selecting pruned speech-LLM checkpoints using aggregate WER alone with selection that also tracks per-demographic-group WER and the worst-performing group's error rate. The cost is additional evaluation compute (one inference pass per demographic slice per checkpoint) and extra analysis and dataset labeling, which is small relative to deployment risk. What can fail: the fairness effects are dataset-dependent (gaps widened on Fair-Speech but not clearly on Common Voice), so per-group metrics must be measured on the target population, and LoRA recovery after pruning can widen disparities even while improving every group's absolute WER.

observed signal
1impl.
1stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of Context Language Models
memory and contexttest

Context Language Models

Replaces externally engineered context-management harnesses (truncation, summarization, retrieval heuristics) with the model itself editing its context as a file, using only prompting of existing models at the zero-shot level. The zero-shot variant costs prompt overhead for file-update operations and adds harness complexity for parsing and applying edits, while the reported RL training and Suffix Cache Reuse serving gains require training infrastructure and custom serving beyond the reader's budget. The model can delete or corrupt information it later needs, behavior depends heavily on base-model capability, and benchmark gains may not transfer to the reader's specific workloads without validation.

observed signal
3impl.
156stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of EngiWorld: What Can Frontier Agents Deliver in Professional Engineering Environments?
agent evaluationwatch

EngiWorld: What Can Frontier Agents Deliver in Professional Engineering Environments?

EngiWorld replaces ad-hoc or GUI-only evaluation of agents with an artifact-centric benchmark: 1,301 tasks across CAD, CAE, CAM, BIM, EDA, and visualization platforms, verified programmatically for geometric validity, physical feasibility, and rule compliance, with continuous scoring by specification attainment. For a reader with constrained infrastructure, adopting it costs access to 26 commercial engineering platforms, GUI-capable agent harnesses, and per-task API or compute spend on frontier models, since local 24 GB models are unlikely to score meaningfully. It can fail as an adoption guide because results are specific to professional engineering workflows and do not transfer to general coding, RAG, or business-automation agents the reader is more likely to deploy.

observed signal
3impl.
164stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of STEPQuant: When and Where Errors Matter in Delta-Rule Recurrent State Quantization
quantizationwatch

STEPQuant: When and Where Errors Matter in Delta-Rule Recurrent State Quantization

STEPQuant replaces full-precision (FP32/INT8) recurrent states in Delta-rule linear-attention models with a post-training, spatial-temporal quantization scheme that allocates bits by error magnitude and memory lifetime, with key-row and value-column scales fitted jointly. It costs only offline calibration plus custom SGLang GPU kernels, adds no inference latency penalty per the reported integration, and yields over 5x state compression with up to 68.7% total serving memory reduction. It can fail if the reader's models use conventional softmax attention with KV caches (where it does not apply), if production state distributions drift from calibration data causing accuracy degradation at low bit-widths, or if the custom kernels do not support the reader's serving stack.

observed signal
2impl.
122stars
—citations
3.19xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of KUPAS MASTER: Distilling the Tacit Expertise of Master Practitioners into Agent-Ready Experience Corpora
retrieval and RAGtest

KUPAS MASTER: Distilling the Tacit Expertise of Master Practitioners into Agent-Ready Experience Corpora

It replaces naive retrieval over raw work records with a curated experience corpus (rules, constraints, negative examples, corner cases, callable skills) built from practitioner records and interviews through a nine-layer extraction process. The cost is primarily human and engineering effort: interviews, semantic alignment, cross-review, and ongoing consolidation of 1,576 source files into tens of thousands of curated assets, rather than GPU or model-training spend. It can fail when expert time is unavailable, when domains drift so curated rules and boundaries go stale, or when the reported gains do not transfer since evaluation is internal, sample-based (20 practitioners), and lacks independent replication or public tooling.

observed signal
2impl.
132stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of EvoOntology: A Self-Evolving Ontology Layer for Data Agents
tool usetest

EvoOntology: A Self-Evolving Ontology Layer for Data Agents

EvoOntology replaces two prior strategies: letting agents directly explore raw heterogeneous data (schemas, files, databases) through generic tools, and injecting manually built semantic layers into prompts; it substitutes an automatically built, self-evolving ontology served as an MCP server with schema, content, and tool layers. The cost is an additional builder agent, an evolution loop with attribution-guided typed edits and backbone-conditional paired evaluation before edits are accepted, plus ongoing LLM calls for construction, evaluation, and ontology maintenance. It can fail when the builder induces incorrect ontology entries that misguide queries, when edit acceptance is too permissive or too strict for a given backbone, or when the ontology drifts from changing data sources and silently degrades agent answers.

observed signal
2impl.
543stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of Follow the Entities: A Corpus Map for Agentic Search
retrieval and RAGtest

Follow the Entities: A Corpus Map for Agentic Search

CorpusMap replaces repeated per-query rediscovery of cross-document relationships in agentic search with an offline-built graph of entity pages that aggregate mentions and link to all referencing documents. It costs an offline entity-resolution and indexing pipeline over the corpus, ongoing maintenance as documents change, and added prompt/context structure for the agent to traverse the graph. It can fail when entity resolution produces incorrect merges or splits, when queries involve entities not recurring enough to have pages, or when corpus updates leave the offline index stale relative to the documents.

observed signal
1impl.
10stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of SelfSearch: Reward-Free Search for Self-Improving Agents
coding agentstest

SelfSearch: Reward-Free Search for Self-Improving Agents

SelfSearch replaces evaluation-guided agent search (repeated downstream benchmark scoring during optimization) with reward-free self-modification driven by records of prior improvement episodes. Cost is low, on the order of single-digit dollars per search plus the engineering effort to log and replay self-modification traces, with no extra serving memory or latency. It can fail because gains are benchmark- and model-specific (population-mean improvements with individual runs varying up to 11.2 points), self-modifications may overfit to logged experience, and unconstrained agent self-editing carries regression and safety risks in production harnesses.

observed signal
2impl.
132stars
—citations
1.6xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of Learning Meta-Skills for Agent Harness Design in Test-Time AI4AI
multi-agent orchestrationtest

Learning Meta-Skills for Agent Harness Design in Test-Time AI4AI

Replaces hand-designed or ad-hoc agent scaffolding (tools, prompts, execution support) with a Builder model that learns reusable 'meta-skill' principles from Target execution feedback on a development set and constructs harnesses for unseen tasks, all with frozen weights. Costs an extra Builder inference pass per task plus a development-set learning loop, adding orchestration complexity and API or GPU compute spend. Can fail when development tasks do not transfer to the production task distribution, when learned principles encode benchmark-specific artifacts, or when the Builder's constructed harness degrades the Target on out-of-distribution inputs.

observed signal
2impl.
132stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of Foundations of Proactive Agents: Principles, Technical Layers, and Proactivity-Gym
agent evaluationwatch

Foundations of Proactive Agents: Principles, Technical Layers, and Proactivity-Gym

This work replaces ad-hoc design and single-dimension evaluation of proactive LLM agents with a joint Task Capability–Temporal Allocation–Trust (3T) framework, a five-dimension design space, and Proactivity-Gym, a simulation testbed with multi-day stateful scenarios and persona-conditioned simulated users. It costs no GPU training but requires building persona-based user simulators and stateful multi-day environments, plus human validation, since the paper shows LLM judges conflate task capability with trust. What can fail after adoption: simulated users may not predict real user trust dynamics, evaluation results across harnesses may not transfer to the reader's domain, and optimizing one 3T axis alone (e.g., correct output) can still produce sharp trust declines from misaligned interventions.

observed signal
1impl.
131stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of SkillGym: Training Skill-Use Agents with Automatic Verifiable Environment Generation
efficient trainingwatch

SkillGym: Training Skill-Use Agents with Automatic Verifiable Environment Generation

The method replaces manual curation of skill-use training data and ad hoc prompting with an automatic pipeline that builds executable, verifier-backed environments and uses the resulting verified trajectories for supervised finetuning. The cost is a crawl-filter-build-verify infrastructure (6.8k environments, 19k trajectories, builder-reviewer LLM calls) plus SFT compute, which exceeds a single 24 GB GPU budget at the paper's scale, though LoRA finetuning of a 7-9B model on a smaller trajectory set is feasible. Failure modes include verifier false positives contaminating SFT data, distribution mismatch between crawled skills and the reader's domain-specific skills, and gains that may not transfer if the production harness differs from the training environments.

observed signal
1impl.
131stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of FOCUS: Training-Free Decision-Preserving Context Compression for LLM Agents
memory and contexttest

FOCUS: Training-Free Decision-Preserving Context Compression for LLM Agents

Replaces offline-trained context compressors (guideline optimization, distilled compressors, learned compression policies) with a test-time, training-free layer that selects which past interaction units causally shape future decisions, attachable to closed-API models. Costs additional inference-time computation per compression step to identify decision-relevant units, plus integration complexity in the agent loop; no fine-tuning or extra hardware required. Can fail if the causal relevance scoring misidentifies which history units matter, silently dropping information needed later in long trajectories, and the reported gains may not transfer to the reader's specific tools, tasks, or base model.

observed signal
1impl.
131stars
—citations
1.92xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of EnterpriseBench: Benchmarking LLM Agents on Enterprise-Level Strategic Reasoning and Decision-Making
agent evaluationtest

EnterpriseBench: Benchmarking LLM Agents on Enterprise-Level Strategic Reasoning and Decision-Making

EnterpriseBench replaces ad hoc or static QA-based evaluation of enterprise agents with a unified suite spanning foundational QA plus three interactive settings (consulting case diagnosis, Beer Game inventory control, and an enterprise digital-twin simulator). It costs evaluation budget and engineering effort: running multi-turn, long-horizon simulations against API-backed models consumes tokens and time without improving any production system directly. It can fail by overfitting agent design to the benchmark's three simulated domains, which may not transfer to the reader's actual enterprise workflows, and its finding that nine agent methods lack cross-task reliability indicates no off-the-shelf agent configuration is validated as dependable.

observed signal
1impl.
131stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of ContextRender: From Execution Dependencies to Agent Context
memory and contexttest

ContextRender: From Execution Dependencies to Agent Context

It replaces passing the full tool-result history (or recency/relevance-only truncation) with a renderer that selects results using observed reuse from tool-flow analysis, recency, and semantic relevance under a fixed token budget. The cost is engineering complexity: building and maintaining a persistent execution-dependency graph and a tool-flow analysis pass around the agent loop, plus minor per-step selection overhead. It can fail when the dependency analysis misses implicit reuse of earlier results, when tasks lack clear tool-result dependency structure, or when the 6K budget assumption does not transfer to the reader's workload and models.

observed signal
1impl.
131stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of UserProxyBench: Evaluating LLM User Simulators for Agent Benchmarks and Training
agent evaluationtest

UserProxyBench: Evaluating LLM User Simulators for Agent Benchmarks and Training

The method replaces agent-only scoring in tau-bench-style interactive benchmarks with an additional evaluation layer (UFS) that scores the LLM user simulator's adherence to its private instructions via task-grounded rubrics. It costs an extra rubric-based judging pass per episode, adding LLM-judge inference cost and benchmark instrumentation complexity, and requires access to the task's private user instructions. It can fail if rubric judging is itself unreliable or miscalibrated, and fidelity scores computed on one benchmark family may not transfer to custom in-house agent evaluations.

observed signal
1impl.
131stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of Thinking Before Thinking: Scaling Agentic Inference Through Meta-Reasoning
multi-agent orchestrationtest

Thinking Before Thinking: Scaling Agentic Inference Through Meta-Reasoning

It replaces direct single-loop agent control with an explicit controller that consolidates progress, evaluates options against remaining budget, and dispatches workers using compact summaries from persistent memory rather than full history replay. It costs additional inference calls for controller reasoning plus engineering complexity for memory and dispatch logic, and it degrades performance at small compute budgets where the control overhead outweighs reuse benefits. It can fail through controller misjudgment of option value, loss of critical detail in the compact run summary, or selection errors despite higher coverage of correct intermediate solutions.

observed signal
1impl.
131stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of Encore: Few-Shot Agentic Discovery of Manipulation Strategies
othernot applicable

Encore: Few-Shot Agentic Discovery of Manipulation Strategies

ENCORE replaces training-data-style imitation learning and hand-crafted robot policy specification with a pipeline in which demonstrations are distilled into keyframe and trajectory packs that a coding agent reads to write and iteratively refine a policy program against a fixed perception/action API. It costs a small set of demonstrations per task (five on the real robot), development rollouts, and the deterministic distillation infrastructure, plus robotics hardware and a simulation benchmark that the reader's setup does not include. It fails when demonstrations are absent or instructions leave the goal unstated (no success on RoboDojo without demonstrations), and frozen programs can overfit to development rollouts since the sealed evaluation signal is hidden.

observed signal
1impl.
224stars
—citations
1.078xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of ToolFence: Fine-Grained Authorization for Secure Tool-Using LLM Agents
safety and guardrailstest

ToolFence: Fine-Grained Authorization for Secure Tool-Using LLM Agents

ToolFence replaces content-based input filters and multi-path consensus defenses (and offers a lower-latency alternative to data-flow control systems like CaMeL) by compiling a typed authorization blueprint before execution, enforcing it with a deterministic monitor, and escalating only missing capabilities to a judge model. It costs the engineering effort of defining typed blueprints and provenance tracking per tool, a small runtime overhead from the monitor, occasional judge-model calls, and a measured 3.80-point utility loss on clean tasks. It can fail when blueprints are incomplete or mis-specified for the production tool set, when the judge incorrectly grants a maliciously requested capability, and its results are validated only on AgentDojo with a frontier model, so transfer to other workloads is unverified.

observed signal
0impl.
1stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of DatalogBench: Evaluating Large Language Models on Text-to-Datalog Synthesis
agent evaluationwatch

DatalogBench: Evaluating Large Language Models on Text-to-Datalog Synthesis

DatalogBench is a benchmark, not a deployable technique; it replaces ad hoc or example-based assessment of LLM-generated Datalog with execution-grounded grading against a mutation-validated oracle across 136 tasks. Adopting it costs only benchmark integration effort and LLM inference, but it consumes engineering time without itself improving any production system. Its findings can mislead if generalized beyond Datalog synthesis, and the reported agent gains are model-dependent with recursion-related semantic errors unresolved.

observed signal
0impl.
0stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of Do Agent Benchmarks Do What They Say? An Executable-Contract Audit of Tool-Using Agent Environments
agent evaluationadopt

Do Agent Benchmarks Do What They Say? An Executable-Contract Audit of Tool-Using Agent Environments

The method replaces trusting a tool's self-reported success messages and benchmark scores with executable contracts that check each mutating tool's implementation against its advertised interface and trace evaluator verdicts back to the state a defective tool should have written. It costs engineering effort to write per-tool contracts and probes plus a static/dynamic checking pass, but runs on ordinary development infrastructure with no GPU or training requirement. It can fail by missing defects the contracts nominally cover when no probe exposes them (29 of 33 scored misses), so a clean audit does not certify correctness.

observed signal
0impl.
0stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of Scale Sensitivity in Low-Bit Post-Training Quantization: Curvature of the Quantization Error Landscape
quantizationtest

Scale Sensitivity in Low-Bit Post-Training Quantization: Curvature of the Quantization Error Landscape

This replaces the max-based or grid-searched scale selection in GPTQ-family post-training quantization with a closed-form Gaussian-optimal scale derived from a proved limit of the quantization error landscape, combined with Hadamard incoherence preprocessing. The cost is modest: a Hadamard transform per layer and the Gaussian-optimal scale computation, which removes the per-layer scale search but adds preprocessing complexity to the quantization pipeline. It can fail on raw weights without incoherence processing, where the Gaussian-optimal scale underperforms, and it remains clearly worse than searched rules at 2 bits, so it does not solve the extreme low-bit regime.

observed signal
0impl.
0stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of Hierarchical Compression of Vision-Language Model Benchmarks
agent evaluationtest

Hierarchical Compression of Vision-Language Model Benchmarks

PRIMEBench replaces running full vision-language benchmark suites by hierarchically cleaning non-visual or saturated items, selecting one representative benchmark per capability category, and pruning items via a vision-aware variance score computed from multimodal embeddings. It costs a one-time item-selection pipeline requiring embeddings and a panel of models, plus acceptance that rankings are preserved only statistically rather than exactly. It can fail when evaluating models far outside the selection panel, when capability categories drift as new benchmarks and models appear, and when fine-grained capability diagnosis (not just ranking) is needed, since pruning discards per-item signal.

observed signal
0impl.
0stars
—citations
20xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of DScale: Scaling Block-Diffusion Speculative Decoding with Adaptive Verification
speculative decodingtest

DScale: Scaling Block-Diffusion Speculative Decoding with Adaptive Verification

DScale replaces uniform-truncation verification in block-diffusion speculative decoding with path-aware tiles, dynamic verify-length packing, fixed-address graph-reusing workspaces, and a 112K-parameter acceptance predictor, while preserving drafter weights and full draft length. The cost is systems complexity: it requires an existing block-diffusion speculative decoding stack (it is benchmarked only against DFlash/DSpark/Domino on A100-40GB with Qwen3 models), plus integration of the predictor and custom workspace/graph management, not a drop-in change to standard autoregressive serving. It can fail if the reader's workload is autoregressive rather than block-diffusion, if acceptance behavior shifts on domains outside the four evaluated datasets (the predictor is frozen per target), or if the engineering cost of reimplementing the scheduling and graph-reuse machinery exceeds the throughput benefit at the reader's concurrency levels.

observed signal
0impl.
0stars
—citations
1.44xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of GraphVQ: Structure-Aware Autoregressive Decoding over Context-Quantized Graph Tokens
otherwatch

GraphVQ: Structure-Aware Autoregressive Decoding over Context-Quantized Graph Tokens

GraphVQ replaces one-pass autoregressive graph generation conditioned on a single global summary with a two-stage pipeline: a VQ-VAE tokenizes node contexts into a shared codebook, and a structure-aware decoder emits the adjacency from pair-level token features. The cost is training and maintaining two models (tokenizer plus pair decoder), which is feasible on a single 24 GB GPU for small molecular/protein-scale graphs but adds pipeline complexity, and the authors themselves report failure on MUTAG where the unweighted edge target under-generates. The method's gain vanishes on the random-label control, so it depends on genuine attribute-topology coupling in the data and offers no benefit where node attributes carry no edge-relevant signal.

observed signal
0impl.
1stars
—citations
2.7xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of SPLASH: Switching Parallel Layouts of Attention with Seamless Handoff for LLM Serving
serving and batchingwatch

SPLASH: Switching Parallel Layouts of Attention with Seamless Handoff for LLM Serving

The method replaces serving engines that fix one attention parallel layout (tensor, data-parallel, or context parallelism) at launch with a system that switches layouts during request execution, reusing already-placed KV cache and weights and handing off at batch boundaries, plus a new Decoupled Ownership Parallelism layout offering 27-60% more KV capacity. The cost is substantial systems complexity: background state migration, a transition-aware scheduler, and a multi-GPU serving stack that the reader does not operate. It can fail when its layout decoupling assumption (few or no KV heads, as in MLA-style models) does not hold, when migration bandwidth contention erodes the near-free switch claim, or when load does not actually shift between layout regimes.

observed signal
0impl.
0stars
—citations
1.73xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of RLTL;DR: Self-improvement by Internalizing Self-generated Feedback
efficient trainingtest

RLTL;DR: Self-improvement by Internalizing Self-generated Feedback

Replaces full-rollout RLVR (and classical SFT on complete solution traces) with sequential rollouts conditioned on self-written 'TL;DR' insights, ultimately reducible to SFT on compact (task, insight) tuples. Costs an iterative generate-critique-retry loop at training time and still requires fine-tuning a mid-size policy, though the SFTL;DR variant fits a single 24 GB GPU with parameter-efficient methods. Can fail where no reliable verifier exists to ground the feedback, where the base model cannot produce useful insights about its own failures, and the reported gains are limited to tool-calling and coding benchmarks on one 9B model.

observed signal
0impl.
0stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of Zephyr: An Efficient Audio Denoising System Using Spiking Neural Networks Enabled With A Sparsity-Aware Flexible FPGA PE Array
othernot applicable

Zephyr: An Efficient Audio Denoising System Using Spiking Neural Networks Enabled With A Sparsity-Aware Flexible FPGA PE Array

Replaces conventional neural network audio denoising inference on edge devices with a spiking neural network (converted Spiking-FullSubNet via QAT and activation simplification) executed on a custom sparsity-aware FPGA processing-element array. Costs include designing and validating custom digital hardware, FPGA-specific engineering, and potential denoising quality degradation from quantization-aware training and simplified activations, none of which the paper's abstract quantifies on the quality side. Adoption fails for anyone without FPGA hardware and hardware-design capacity, and the 28x power claim is a calculated figure for hypothetical 45nm silicon rather than a measured result.

observed signal
0impl.
0stars
—citations
28xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of Predictive Geometry of Hidden Trajectories in Transformers
sparsity and pruningtest

Predictive Geometry of Hidden Trajectories in Transformers

The method replaces attention-magnitude heuristics for token pruning and uniform rank allocation with a loss-aware, Fisher-weighted tokenwise curvature score and layerwise observable-subspace ranks computed from the terminal-loss geometry. It costs matrix-free Jacobian-vector and vector-Jacobian products through the remaining transformer blocks per analyzed token, adding implementation complexity and extra backward-pass compute during model analysis and distillation setup, though inference itself is unaffected. It can fail off successful low-loss trajectories, since the Fisher characterization is local and the pruning or rank-allocation signal may misestimate sensitivity on out-of-distribution inputs or when the low-loss residual terms are not small.

observed signal
0impl.
0stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
First page of Foundation Neural-Network Quantum States for Molecular Potential Energy Surfaces in Second Quantization
othernot applicable

Foundation Neural-Network Quantum States for Molecular Potential Energy Surfaces in Second Quantization

The method replaces per-geometry independent optimization of neural-network quantum states with a single autoregressive model trained on sparse anchor geometries, using orbital alignment to enable zero-shot wavefunction evaluation at untrained geometries. The cost is the upfront training of the shared model plus the orbital alignment procedure, and property predictions emerge only as byproducts of energy-trained wavefunctions without property labels. Failure modes include demonstrated dependence on training seeds (alignment was required to reduce errors from 34-37 mHa to below 0.1 mHa), validation limited to small systems (N2, CO, H4), and no demonstrated scaling to larger or chemically diverse molecules.

observed signal
0impl.
0stars
—citations
25.8xclaimed 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.When Agents Slow Down: Understanding LLM Agents' Test-Time Strategies via Elo-per-token Analysis: 0 GitHub stars; 2 independent implementationsEvoOntology: A Self-Evolving Ontology Layer for Data Agents: 543 GitHub stars; 2 independent implementationsToolFence: Fine-Grained Authorization for Secure Tool-Using LLM Agents: 1 GitHub star; 0 independent implementationsFollow the Entities: A Corpus Map for Agentic Search: 10 GitHub stars; 1 independent implementationDatalogBench: Evaluating Large Language Models on Text-to-Datalog Synthesis: 0 GitHub stars; 0 independent implementationsFoundations of Proactive Agents: Principles, Technical Layers, and Proactivity-Gym: 131 GitHub stars; 1 independent implementationDo Agent Benchmarks Do What They Say? An Executable-Contract Audit of Tool-Using Agent Environments: 0 GitHub stars; 0 independent implementationsEncore: Few-Shot Agentic Discovery of Manipulation Strategies: 224 GitHub stars; 1 independent implementationScale Sensitivity in Low-Bit Post-Training Quantization: Curvature of the Quantization Error Landscape: 0 GitHub stars; 0 independent implementationsHierarchical Compression of Vision-Language Model Benchmarks: 0 GitHub stars; 0 independent implementationsDScale: Scaling Block-Diffusion Speculative Decoding with Adaptive Verification: 0 GitHub stars; 0 independent implementationsSkillGym: Training Skill-Use Agents with Automatic Verifiable Environment Generation: 131 GitHub stars; 1 independent implementationFOCUS: Training-Free Decision-Preserving Context Compression for LLM Agents: 131 GitHub stars; 1 independent implementationGraphVQ: Structure-Aware Autoregressive Decoding over Context-Quantized Graph Tokens: 1 GitHub star; 0 independent implementationsSPLASH: Switching Parallel Layouts of Attention with Seamless Handoff for LLM Serving: 0 GitHub stars; 0 independent implementationsRLTL;DR: Self-improvement by Internalizing Self-generated Feedback: 0 GitHub stars; 0 independent implementationsEnterpriseBench: Benchmarking LLM Agents on Enterprise-Level Strategic Reasoning and Decision-Making: 131 GitHub stars; 1 independent implementationKUPAS MASTER: Distilling the Tacit Expertise of Master Practitioners into Agent-Ready Experience Corpora: 132 GitHub stars; 2 independent implementationsEngiWorld: What Can Frontier Agents Deliver in Professional Engineering Environments?: 164 GitHub stars; 3 independent implementationsZephyr: An Efficient Audio Denoising System Using Spiking Neural Networks Enabled With A Sparsity-Aware Flexible FPGA PE Array: 0 GitHub stars; 0 independent implementationsPredictive Geometry of Hidden Trajectories in Transformers: 0 GitHub stars; 0 independent implementationsContext Language Models: 156 GitHub stars; 3 independent implementationsFoundation Neural-Network Quantum States for Molecular Potential Energy Surfaces in Second Quantization: 0 GitHub stars; 0 independent implementationsContextRender: From Execution Dependencies to Agent Context: 131 GitHub stars; 1 independent implementationThinking in Depth, Speaking Directly: Recurrent Latent Reasoning for Paralinguistically Grounded Spoken Dialogue: 121 GitHub stars; 0 independent implementationsJoint Effects of GPU Server Topology, Parallelism, and Congestion Control on MoE Inference: A Controlled Simulation Study: 0 GitHub stars; 0 independent implementationsScaling Influence Functions in LLMs through Eigenbasis-Corrected One-Bit Gradient Projection: 0 GitHub stars; 0 independent implementationsStorage Is Not Strategy: State-Conditioned Support Control for LLM Unlearning: 0 GitHub stars; 0 independent implementationsAgentBug-Smith: Automatically Reproducing Real-World Harness Bugs in Agentic Systems: 0 GitHub stars; 0 independent implementationsBehavioral Capacity Certificates for Quantized Language Models: 0 GitHub stars; 0 independent implementationsRLX: A Unified Multi-Backend Tensor Compiler and Distributed Runtime in Rust: 0 GitHub stars; 0 independent implementationsSelfSearch: Reward-Free Search for Self-Improving Agents: 132 GitHub stars; 2 independent implementationsMerged, Not Measured: An Empirical Study of Performance Issues Fixed by Coding Agents: 0 GitHub stars; 0 independent implementationsRetrieval-Augmented Skill Optimization via Cross-Harness Adaptation: 121 GitHub stars; 0 independent implementationsUserProxyBench: Evaluating LLM User Simulators for Agent Benchmarks and Training: 131 GitHub stars; 1 independent implementationMira: Memory-Efficient MoE Inference Using Adaptive Caching and Predictive Expert Staging: 1 GitHub star; 0 independent implementationsPruning for Efficiency, Paying in Fairness: Demographic Disparities in Pruned Speech-LLMs: 1 GitHub star; 1 independent implementationWUSH-KV: KV Cache Quantization with Data-Adaptive Transforms: 1 GitHub star; 0 independent implementationsLearning Meta-Skills for Agent Harness Design in Test-Time AI4AI: 132 GitHub stars; 2 independent implementationsThinking Before Thinking: Scaling Agentic Inference Through Meta-Reasoning: 131 GitHub stars; 1 independent implementationLeapQuant: Efficient Linear Attention with Accurate Recurrent State Quantization: 1 GitHub star; 0 independent implementationsSTEPQuant: When and Where Errors Matter in Delta-Rule Recurrent State Quantization: 122 GitHub stars; 2 independent implementations

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 9Sep 26: 2 papersSep 26Sep 26efficient architecturesmax 9Sep 26: 1 paperSep 26Sep 26agent evaluationmax 9Sep 26: 9 papersSep 26Sep 26KV cachemax 9Sep 26: 1 paperSep 26Sep 26speculative decodingmax 9Sep 26: 1 paperSep 26Sep 26sparsity and pruningmax 9Sep 26: 2 papersSep 26Sep 26memory and contextmax 9Sep 26: 3 papersSep 26Sep 26multi-agent orchestrationmax 9Sep 26: 2 papersSep 26Sep 26othermax 9Sep 26: 4 papersSep 26Sep 26quantizationmax 9Sep 26: 4 papersSep 26Sep 26retrieval and RAGmax 9Sep 26: 2 papersSep 26Sep 26safety and guardrailsmax 9Sep 26: 2 papersSep 26Sep 26serving and batchingmax 9Sep 26: 4 papersSep 26Sep 26efficient trainingmax 9Sep 26: 3 papersSep 26Sep 26tool usemax 9Sep 26: 2 papersSep 26Sep 26

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

03 · reported results

Claimed performance gains

Gains stated in the abstract: reported by the authors; not independently verified.

Factors reported by the authors and not independently verified. The vertical axis uses a logarithmic scale; the baseline is 1x.reported factor · log scaleEncore: Few-Shot Agentic Discovery of Manipulation Strategies: 1.078x in quality (author-reported)Hierarchical Compression of Vision-Language Model Benchmarks: 20x in cost (author-reported)DScale: Scaling Block-Diffusion Speculative Decoding with Adaptive Verification: 1.44x in speed (author-reported)FOCUS: Training-Free Decision-Preserving Context Compression for LLM Agents: 1.92x in memory (author-reported)GraphVQ: Structure-Aware Autoregressive Decoding over Context-Quantized Graph Tokens: 2.7x in quality (author-reported)SPLASH: Switching Parallel Layouts of Attention with Seamless Handoff for LLM Serving: 1.73x in speed (author-reported)Zephyr: An Efficient Audio Denoising System Using Spiking Neural Networks Enabled With A Sparsity-Aware Flexible FPGA PE Array: 28x in cost (author-reported)Foundation Neural-Network Quantum States for Molecular Potential Energy Surfaces in Second Quantization: 25.8x in cost (author-reported)Thinking in Depth, Speaking Directly: Recurrent Latent Reasoning for Paralinguistically Grounded Spoken Dialogue: 34x in speed (author-reported)Joint Effects of GPU Server Topology, Parallelism, and Congestion Control on MoE Inference: A Controlled Simulation Study: 4.35x in speed (author-reported)Scaling Influence Functions in LLMs through Eigenbasis-Corrected One-Bit Gradient Projection: 16x in memory (author-reported)RLX: A Unified Multi-Backend Tensor Compiler and Distributed Runtime in Rust: 1.61x in speed (author-reported)SelfSearch: Reward-Free Search for Self-Improving Agents: 1.6x in cost (author-reported)Mira: Memory-Efficient MoE Inference Using Adaptive Caching and Predictive Expert Staging: 5.71x in speed (author-reported)LeapQuant: Efficient Linear Attention with Accurate Recurrent State Quantization: 1.47x in speed (author-reported)STEPQuant: When and Where Errors Matter in Delta-Rule Recurrent State Quantization: 3.19x in memory (author-reported)

16 of 42 papers report a quantified gain. The scale is logarithmic; a research-area trend line appears only with at least five papers in the quarter.

Method under scrutiny

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

When Agents Slow Down: Understanding LLM Agents' Test-Time Strategies via Elo-per-token Analysis

agent evaluation · test · 2 of 2 implementations are independent

The method replaces uninstrumented agent budget allocation and single-score leaderboards with a per-token best-solution curve aggregated across tasks via a Bradley-Terry Elo model, using independent sampling as a reference to locate the point where marginal gains diminish. It costs additional evaluation infrastructure: tasks must expose continuous intermediate scores, trajectories must be logged per token, and Elo estimation plus reference sampling add compute and engineering effort on top of the agent runs themselves. It can fail when benchmarks lack intermediate scoring, when the independent-sampling reference is unrepresentative of the task, or when the empirically estimated inflection point does not transfer across models, tasks, or budget regimes.

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.