Skip to content

archived edition · 2026-10-08

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-08
briefs
43
research areas
16
independent implementations
32

26 of 43 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.

showing30 of 43
sort by
arXiv 2608.26480
First page of Zero-Shot Self-Orchestration with Ledger-Based Control for Improved LLM Coding Performance
multi-agent orchestrationtest

Zero-Shot Self-Orchestration with Ledger-Based Control for Improved LLM Coding Performance

The method replaces single-pass LLM code generation with a manager-worker scaffold in which short worker calls share state through a filesystem ledger, requiring no training or per-benchmark tuning. It roughly triples the token bill per problem, though it can buy accuracy more cheaply than upgrading to a larger model and is self-hostable on a 24 GB GPU only via small open-weight workers such as Qwen-27B-class models. It can fail because gains are strongly model-conditional: some models show null or negative deltas (e.g., Qwen3.6-35B, -1 to -9 points with reasoning off), and large reasoning-enabled models gain little, so the extra token cost may buy nothing on a given workload.

observed signal
4impl.
2stars
0citations
5.2xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2608.21690
First page of Context as an Environment: Programmatic Context Management for Long-Horizon Agents
memory and contexttest

Context as an Environment: Programmatic Context Management for Long-Horizon Agents

Scroll replaces prompt-side history compression and fixed memory representations with an append-only event log plus a persistent sandboxed Python kernel, where the model writes code to search and materialize state and only printed projections enter the working context. It costs engineering effort to build and sandbox the kernel and eviction index, adds code-execution latency per turn, and its reported results depend on a strong proprietary backbone. It can fail if the model writes faulty state-management code, if eviction landmarks mislead retrieval of evicted regions, or if sandboxing is insufficient against unsafe exec output.

observed signal
6impl.
6stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2608.15008
First page of Harness the Memory: A Holistic Evaluation of Memory Substrates in Memory Agents
memory and contexttest

Harness the Memory: A Holistic Evaluation of Memory Substrates in Memory Agents

This is a benchmark study, not a method: it replaces the implicit practice of committing to a single memory substrate (dense retrieval, sparse index, text record, structural or hierarchical store) with the finding that no substrate dominates and that retrieval breadth should be routed by task regime and history length. Adopting its guidance costs engineering effort to instrument memory metrics and to build routing logic over existing memory stores, with no additional model or training cost. It can fail because the substrate rankings may not transfer to a different backbone model, benchmark, or production workload, and code was not yet released, so reproducing the harness requires independent implementation.

observed signal
2impl.
2stars
0citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09877
First page of Layerwise Error Attribution for Fast and Robust Mixed-Precision Post-Training Quantization
quantizationtest

Layerwise Error Attribution for Fast and Robust Mixed-Precision Post-Training Quantization

Replaces solver-based or search-based mixed-precision bit-allocation methods in post-training quantization with a separable layerwise score derived from a probabilistic decomposition of propagated versus local quantization error, computed without external solvers. Costs are low: a small calibration set and a fast scoring pass, with allocation overhead reduced by orders of magnitude, though the method still requires per-layer sensitivity computation and calibration data. Can fail when the probabilistic layerwise error assumptions do not hold for a given architecture, and its evidence base is denoising networks (DRUNet) and diffusion models, so gains on LLMs or other production workloads are not established.

observed signal
1impl.
4stars
—citations
28xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09832
First page of SkillForge: Co-Evolving Skills and Agents via Dynamic Skill Lifecycles
memory and contextwatch

SkillForge: Co-Evolving Skills and Agents via Dynamic Skill Lifecycles

The method replaces indiscriminate accumulation of skill memory in memory-augmented agent RL with a lifecycle that trials, stabilizes, mutates, and retires skills based on measured fitness, including a pre-RL filtering phase before supervised fine-tuning. It costs a full RL training pipeline with repeated model rollouts, fitness evaluation, and LLM-guided mutation at each iteration, which demands substantial compute and infrastructure beyond a single 24 GB GPU or API budget. It can fail through mislabeled skill fitness that retires useful skills or retains harmful ones, and the co-evolution of library and policy may not transfer to a frozen API model the reader cannot fine-tune.

observed signal
3impl.
132stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.10498
First page of EmbodiedRSI: Active Continual Robot Learning Through Hypothesis-Guided Co-Evolution
othernot applicable

EmbodiedRSI: Active Continual Robot Learning Through Hypothesis-Guided Co-Evolution

EmbodiedRSI replaces undirected trial-and-error adaptation in self-evolving robot harnesses with a Fast-Slow dual-system architecture that maintains competing code and skill hypotheses in a graph and selects physical experiments by value of information. Its costs are a robot embodiment (or simulator) for physical interaction, substantial orchestration complexity across hypothesis graphs, hierarchical memory, and co-evolution loops, plus dependence on an underlying robot foundation model. Failure modes include hypothesis graphs that diverge from true failure causes, unsafe or destructive physical exploration on hardware, memory entries selected by reward that do not generalize, and degradation when the base visuomotor model drifts outside the harness's repair capacity.

observed signal
3impl.
132stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09710
First page of SpikingVLA: Asynchronous Spiking Vision-Language-Action Models
efficient architectureswatch

SpikingVLA: Asynchronous Spiking Vision-Language-Action Models

Replaces direct ANN VLA inference and prior high-timestep spiking VLA methods with an ANN-to-SNN conversion using Dendritic Integrate-and-Fire neurons plus asynchronous cross-component execution. The cost is a conversion pipeline, custom neuron and execution machinery tied to SNN simulation or neuromorphic runtimes, and possible residual accuracy loss from few-timestep conversion. It can fail if no suitable SNN runtime exists for the target hardware, if activation distributions in the reader's pretrained VLA differ from the navigation benchmark, or if asynchronous execution introduces timing nondeterminism in control loops.

observed signal
2impl.
121stars
—citations
11.2xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09681
First page of Cost-Efficient Theorem Proving via Agent Orchestration in Program Verification
multi-agent orchestrationtest

Cost-Efficient Theorem Proving via Agent Orchestration in Program Verification

The method replaces fixed-budget LLM provers and monolithic frontier coding agents with symbolic goal selection over two-level proof graphs plus a metalevel router that prices and dispatches bounded specialist agent invocations. It costs the engineering of a proof-graph infrastructure and routing layer, requires Lean 4 toolchain integration, and depends on third-party API calls whose per-invocation pricing must be tracked. It can fail if routing rules overfit to the evaluated benchmarks, if specialist agents behave differently on out-of-distribution proof obligations, or if the orchestration overhead outweighs savings on small proof workloads.

observed signal
1impl.
14stars
—citations
1.45xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09872
First page of LiveMACE: Process-Aware Evaluation of LLM Agent Capabilities in Evolving Markets
agent evaluationwatch

LiveMACE: Process-Aware Evaluation of LLM Agent Capabilities in Evolving Markets

The benchmark replaces outcome-only agent evaluation with trace-level diagnostics that separately measure tool use, persistent memory, rule following, and multi-agent collaboration in a live financial-market environment. It requires running five frontier LLM agents for 30 days against live markets via paid APIs, plus infrastructure to capture and analyze complete decision traces, which is nontrivial cost and engineering for a small team. Its diagnostics can fail to transfer: findings are tied to a single financial domain, a 30-day window, and specific frontier models, so capability bottlenecks observed there may not reflect the reader's production workloads.

observed signal
2impl.
133stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.10444
First page of RunningTab: Direct Workspace Interaction with Environment-Side Tabs
memory and contexttest

RunningTab: Direct Workspace Interaction with Environment-Side Tabs

It replaces in-context (model-side) bookkeeping of task requirements, read files, and unopened candidates with an environment-maintained tab that pairs each requirement with best-matching excerpts, tracks unopened files, and blocks premature finishing via a finish check. The cost is extra orchestration infrastructure in the agent harness: excerpt and provenance logging, requirement-excerpt matching (which adds latency and likely additional model calls), and a finish-check gate, rather than any training or added GPU memory. It can fail if the matching logic pairs requirements with the wrong excerpts, if the agent sets requirements aside with weak reasons, or on tasks where requirements are implicit and never explicitly added to the tab.

observed signal
1impl.
121stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.10507
First page of RECAST: Learning to Compute the Right Context through Adaptive Evidence Routing
retrieval and RAGwatch

RECAST: Learning to Compute the Right Context through Adaptive Evidence Routing

RECAST replaces fixed similarity-based RAG retrieval with a trained RouterLM that sequentially selects retrieval and computation primitives, which a frozen CompilerLM turns into executable code before a frozen AnswerLM answers. Adoption costs a full SFT-plus-GRPO training pipeline for the router, maintenance of three coordinated model components, and added per-query latency from iterative routing and code execution. It can fail when RouterLM judges insufficient evidence as sufficient, when generated computation code errors or misaggregates, and on domains whose operation distributions differ from the training tasks, where the claimed zero-shot generalization may not transfer.

observed signal
1impl.
122stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09841
First page of ORCA: Hunting Compositional Failures in Text-to-Image Diffusion
efficient trainingwatch

ORCA: Hunting Compositional Failures in Text-to-Image Diffusion

ORCA replaces vanilla or REPA-style diffusion training objectives with an added auxiliary loss that aligns the diffusion transformer's latent to a low-rank subspace of a frozen visual encoder, conditioned on a residual between T5 and CLIP embeddings. It costs extra training-time compute and integration complexity (a frozen visual encoder, a predictor module, and a modified loss), though it claims zero inference-time overhead and faster convergence. It can fail if the frozen visual encoder's low-rank subspace does not capture the compositional information needed for a given domain, and the reported gains are validated only on class-conditional and small-scale backbones, not on production-scale text-to-image systems.

observed signal
1impl.
125stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.10058
First page of Cache the Encoder Within:Compact, Reusable Memory across LLM Queries
memory and contexttest

Cache the Encoder Within:Compact, Reusable Memory across LLM Queries

EncBank replaces re-encoding or text replay of repeatedly queried documents by caching a pretrained LLM's lower-layer outputs once and feeding them to an adapted upper-layer reader, with 4-bit storage shared across precisions. It costs an offline self-distillation and adapter preparation step per backbone, a persistent store that shrinks but does not disappear, and a measured 3.12-point RULER accuracy drop relative to replay in the reported configuration. It can fail when reuse frequency is low enough that preparation and storage outweigh re-encoding, and its end-to-end gains are workload-dependent rather than guaranteed.

observed signal
1impl.
125stars
—citations
3.56xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09858
First page of Training Advisors for LLM Agents from Task Outcomes
failure recoverytest

Training Advisors for LLM Agents from Task Outcomes

Caddie replaces hand-written step-level critique labels, reference critiques, and prompting-only self-reflection with a small critic model trained by RL purely from final task success, keeping the base model frozen. Costs include an RL training run on multi-hop QA data, an additional 4B-parameter model to host (feasible on one 24 GB GPU), and extra inference latency and token spend whenever the agent consults the critic. It can fail when the agent calls the critic at unhelpful times, when outcome-only reward produces generic advice, or when target tasks differ enough from the training distribution that transferred guidance degrades rather than helps.

observed signal
1impl.
131stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09944
First page of AgentTime: Can Agents Estimate and Control Their Own Runtime?
agent evaluationtest

AgentTime: Can Agents Estimate and Control Their Own Runtime?

AgentTime is an evaluation benchmark, not a model technique; it replaces informal assumptions that an agent which finishes tasks can also follow requested durations, predict its own runtime, and estimate elapsed time, by providing 222 tasks measuring duration-following, forecasting, and retrospective estimation. Cost is limited to running agent harnesses (e.g., Codex-style or Claude Code-style setups) with appended duration instructions and reviewing transcripts, which fits API-based or small-GPU budgets since no model training is involved. Failure mode: matching a requested runtime does not imply continued productive work, as some runs explicitly slept after finishing, so a team could pass the metric while gaining no real reliability for long-horizon autonomous operation.

observed signal
1impl.
131stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09973
First page of From Expected Harmfulness to Likelihood: A Probabilistic Reformulation of Jailbreaking LLM Agents
safety and guardrailswatch

From Expected Harmfulness to Likelihood: A Probabilistic Reformulation of Jailbreaking LLM Agents

OPUR replaces direct expected-harmfulness maximization with target-output likelihood optimization guided by a harmfulness-reweighted sampling distribution, unifying the two gradient objectives. It costs attacker-side sampling of harmful target outputs plus gradient-based input optimization against the model, which presumes log-likelihood access and therefore applies mainly to open-weight agents; it adds no production benefit to a deployed system. It can fail against defended or API-only models where likelihoods and gradients are unavailable, and jailbreak success rates do not transfer across model versions or safety filters.

observed signal
1impl.
131stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.10062
First page of Loud Failures, Quiet Failures: Fault Detection and Recovery in Tool-Using Language Model Agents
failure recoveryadopt

Loud Failures, Quiet Failures: Fault Detection and Recovery in Tool-Using Language Model Agents

The paper is a diagnostic benchmark, not a method; the production practice it argues for is replacing trust in well-formed tool outputs with explicit result validation and error-channel-independent checks in tool-using agents. The cost is added validation logic and extra verification calls per trajectory, since the paper shows a simple prompt line asking the agent to check results does not improve detection, so validation must be implemented in the harness rather than delegated to the model. What can fail is that silent faults (plausible wrong values, schema drift, corruption) still pass through undetected at high rates (detection only 58.8% versus 91.3% for explicit errors), reasoning-model variants do not help recovery, and stochastic run-to-run variation (only 63.3% identical end states on fault-free runs) limits how much any single-run safeguard can guarantee.

observed signal
1impl.
131stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09703
First page of Understanding and Mitigating Token-Pruning-Induced Vulnerabilities in VLMs
safety and guardrailstest

Understanding and Mitigating Token-Pruning-Induced Vulnerabilities in VLMs

SAP replaces standard inference-time visual token pruning by adding malicious-anchor identification, restoration of pruned benign tokens, and attention reallocation from malicious to benign tokens. It costs additional inference-time computation and integration complexity inside the pruning pipeline, though the paper claims no measurable efficiency or utility degradation on three safety and four utility benchmarks. It can fail if the malicious-anchor detector misses obfuscated jailbreak anchors, if the utility/safety gains do not transfer beyond the tested VLM architectures and benchmarks, or if attention reallocation disrupts task-relevant tokens in real workloads.

observed signal
0impl.
0stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09757
First page of EntroPrefill: Renyi-Guided Context Pruning with Conditional Stability Guarantees for Retrieval-Augmented Generation
retrieval and RAGwatch

EntroPrefill: Renyi-Guided Context Pruning with Conditional Stability Guarantees for Retrieval-Augmented Generation

EntroPrefill replaces heuristic attention-concentration-based pruning of retrieved context with a Renyi-entropy proposal mechanism constrained by explicit discarded-attention-mass bounds and a computable deletion envelope, executed mid-prefill so deeper layers process a shorter sequence. It costs additional scoring and pooling computation per head group, introduces hyperparameters for the regularized head pooling and deletion constraints, and requires implementing custom mid-prefill pruning logic that most serving stacks and third-party APIs do not expose. The authors themselves show a counterexample that shallow-layer observations cannot guarantee future-output stability, so pruning decisions can silently degrade generated answers, and the paper provides no measured speedup or accuracy preservation to size that risk.

observed signal
0impl.
0stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09782
First page of AdaPS-LiNGAM: Adaptive Predecessor Selection for Linear Non-Gaussian Acyclic Models under Small-Sample Settings
othernot applicable

AdaPS-LiNGAM: Adaptive Predecessor Selection for Linear Non-Gaussian Acyclic Models under Small-Sample Settings

AdaPS-LiNGAM replaces DirectLiNGAM's sequential residualization, which degenerates when variables exceed sample size, by reconstructing each residual from a sparse 'active boundary' subset of already-ordered variables and applying the same subset selection to edge pruning. It costs only classical CPU-based statistics (sparse regression, no GPU), but adds subset-selection complexity and hyperparameter sensitivity. It can fail under non-linear or non-Gaussian-violating data, latent confounding, and its gains are demonstrated only on synthetic benchmarks.

observed signal
0impl.
0stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09802
First page of DisParQ: Self-Supervised Part Concepts for Interpretable Vision Foundation Models
otherwatch

DisParQ: Self-Supervised Part Concepts for Interpretable Vision Foundation Models

DisParQ replaces opaque patch embeddings or language-dependent concept bottlenecks with a learned discrete prototype dictionary plus quantized attribute residuals trained to reconstruct a frozen self-supervised backbone's features, without class labels or text supervision. The cost is an additional training stage (prototype dictionary, sparse assignment, spatial reconstruction decoder) on top of the frozen backbone, plus inference overhead from patch-to-concept assignment and the constraint that the concept layer may discard information the backbone carried. It can fail if the learned concepts do not align with parts humans care about on a new domain, if the sparsity constraint under-represents atypical images, or if reconstruction fidelity does not translate into faithful explanations of downstream predictions.

observed signal
0impl.
121stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09827
First page of Dual-QK: Sharp Queries and Flat Keys for Prunable 2-bit KV Caches
KV cachetest

Dual-QK: Sharp Queries and Flat Keys for Prunable 2-bit KV Caches

Dual-QK replaces standard rotation-based INT2 KV-cache quantization (e.g., OSCAR-style orthogonal rotations) with paired non-orthogonal query and key transforms that whiten keys for 2-bit storage while concentrating query energy so channels can be pruned dynamically. It costs a calibration pass over query and key statistics, a modified attention implementation (the paper uses SGLang), and the integration complexity of channel-0 protection and bucket-relative RoPE, with accuracy losses possible on tasks sensitive to 40% query-channel pruning. It can fail if the workload's context lengths or query statistics diverge from calibration data, if the serving stack cannot accommodate the custom kernel, or if INT2 plus pruning degrades accuracy on the reader's specific models and benchmarks, which the paper covers only partially.

observed signal
0impl.
0stars
—citations
6.8xclaimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09901
First page of A Chat Assistant for Software Exploration in a 3D Software Visualization
tool usetest

A Chat Assistant for Software Exploration in a 3D Software Visualization

The method replaces manual GUI interaction in a 3D software visualization tool with natural-language chat that triggers deterministic tool calls (highlighting, color themes, restructuring) via CopilotKit-style LLM-plus-tools integration. It costs third-party LLM API usage, frontend integration effort, and added nondeterminism layered over previously deterministic UI actions, with no training or cluster required. It can fail on open-ended restructuring commands, where the small study (eleven participants) showed mixed results and the authors identify a need for stronger guardrails and user-feedback incorporation.

observed signal
0impl.
4stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09906
First page of Constrained-Action AI Remediation for SIEM/XDR via a NeMo-Guardrails Proxy
safety and guardrailstest

Constrained-Action AI Remediation for SIEM/XDR via a NeMo-Guardrails Proxy

The method replaces free-form LLM-generated remediation commands with a closed intent vocabulary whose templated commands run through thin endpoint agents, plus a NeMo-Guardrails proxy enforcing input and output rails on the analyst-facing LLM. Costs include an extra proxy layer whose measured rail latency rules out fully inline autonomous control, the engineering effort of defining the intent vocabulary, validators, and endpoint agents, and a residual false-positive rate of 0.1%. Failure modes after adoption include the roughly 5.5% of injections that still evade the rails, coverage gaps if a required remediation is absent from the closed vocabulary, and the fact that operational-technology suitability is argued architecturally rather than measured in deployment.

observed signal
0impl.
0stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09935
First page of AgentTracer: Tracing Indirect Prompt Injection Attack through Fine-Grained Intention-Execution Alignment
safety and guardrailswatch

AgentTracer: Tracing Indirect Prompt Injection Attack through Fine-Grained Intention-Execution Alignment

AgentTracer replaces explicit control-flow and data-flow dependency tracing for post-incident IPI forensics with an intent-driven execution graph that links tool calls by inferred task intent and prunes them against a user intent authorization space. Adoption costs include building and maintaining an operation knowledge base, capturing complete structured tool-call logs, running LLM-based intent inference over those logs, and having a pre-identified anomalous tool call as the audit starting point. It can fail when malicious calls closely mimic authorized intent, when logs are incomplete or the anomaly detector never flags a seed call, and its accuracy figures come from two specific attack benchmarks that may not transfer to a given production agent stack.

observed signal
0impl.
1stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09969
First page of TR-PTQ: High-Accuracy Integer-Only Transformer Post Training Quantization via Taylor Region Reformulation
quantizationtest

TR-PTQ: High-Accuracy Integer-Only Transformer Post Training Quantization via Taylor Region Reformulation

TR-PTQ replaces floating-point evaluation of nonlinear transformer operations (LayerNorm scale, GELU, SoftMax, division, square roots) with integer-only computation built on shared Taylor-region exponential and logarithm primitives, moving expensive operations into the log domain, plus a calibration-free outlier-aware optimization of LayerNorm parameters. It costs implementation complexity: adopting it requires a custom integer kernel path for the log-domain primitives rather than using standard INT8 quantization toolchains, and the paper reports up to 1.5% absolute accuracy loss. It can fail on models or datasets outside the tested benchmarks, since the claimed robustness of SoftMax and the error-source diagnosis may not transfer, and integer-only kernels may underperform optimized float16 inference on a 24 GB GPU that already supports FP16/BF16 natively.

observed signal
0impl.
0stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.09985
First page of Marrying Pricing and Advertising with LLMs
efficient trainingtest

Marrying Pricing and Advertising with LLMs

The method replaces decoupled pipelines in which ad text and price are optimized separately, substituting a single online actor-critic loop where a LoRA-tuned LLM generates advertisements and a demand-model critic selects prices from binary purchase feedback. Costs include maintaining online LoRA updates with policy-gradient training, fitting and updating a demand model continuously, and the engineering complexity of a live feedback loop, plus the exploration cost of suboptimal prices and ads during learning. It can fail when demand shifts non-stationarily, when purchase feedback is too sparse to identify price and text effects separately, and when simulator-validated gains do not transfer to real marketplace demand.

observed signal
0impl.
0stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.10042
First page of Learning to Accumulate Knowledge with Mutual Information
memory and contexttest

Learning to Accumulate Knowledge with Mutual Information

It replaces hand-written or prompt-curated knowledge banks for experience reuse in LLM agents with a curator model trained via GRPO on mutual-information-inspired and marginal-success rewards. The cost is an offline RL training run on collected agent trajectories, plus curator inference at curation time; the executor and retrieval step remain unchanged. It can fail if training trajectories poorly represent deployment tasks, if MI-based feedback rewards novelty that does not transfer, or if the tuned curator does not generalize to new domains.

observed signal
0impl.
121stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.10226
First page of Why Software Engineering Is Indispensable in the Age of Coding Agents
coding agentsadopt

Why Software Engineering Is Indispensable in the Age of Coding Agents

This is a position paper arguing that LLM coding agents require methodological knowledge, domain knowledge, design choices, and process choices to be reified as persistent artifacts (specifications, design records, tests, process definitions) maintained by engineers, replacing ad-hoc prompt-and-accept workflows. It costs documentation effort, artifact maintenance, and review overhead, with no measured latency or memory impact. If adopted superficially, artifacts can drift out of sync with the code, giving a false sense of verifiability while agent output remains unvalidated.

observed signal
0impl.
0stars
—citations
—claimed gain
abstract onlyReview decisionDownload skill ↓Original paper ↗
arXiv 2610.10239
First page of ProtocolMatch: Protocol-Dependent Model Selection for Scientific Dynamics Forecasting
agent evaluationtest

ProtocolMatch: Protocol-Dependent Model Selection for Scientific Dynamics Forecasting

It replaces fixed-architecture benchmarking and winner-take-all leaderboards with a compute-matched, validation-selected evaluation that reports accuracy, physical validity, and shifted-distribution reliability separately. The cost is additional evaluation engineering: multiple protocols (refreshed history vs. closed loop), failure-preserving logging, and matched-compute baselines, rather than any extra model capacity or training budget. It can fail if adopted conclusions are over-generalized, since rankings reverse with dataset size, history length, system, and distribution shift, and closed-loop rollouts can still produce finite explosive errors that accuracy-only reporting hides.

observed signal
0impl.
0stars
—citations
—claimed 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.Harness the Memory: A Holistic Evaluation of Memory Substrates in Memory Agents: 2 GitHub stars; 2 independent implementationsContext as an Environment: Programmatic Context Management for Long-Horizon Agents: 6 GitHub stars; 6 independent implementationsZero-Shot Self-Orchestration with Ledger-Based Control for Improved LLM Coding Performance: 2 GitHub stars; 4 independent implementationsCost-Efficient Theorem Proving via Agent Orchestration in Program Verification: 14 GitHub stars; 1 independent implementationUnderstanding and Mitigating Token-Pruning-Induced Vulnerabilities in VLMs: 0 GitHub stars; 0 independent implementationsSpikingVLA: Asynchronous Spiking Vision-Language-Action Models: 121 GitHub stars; 2 independent implementationsEntroPrefill: Renyi-Guided Context Pruning with Conditional Stability Guarantees for Retrieval-Augmented Generation: 0 GitHub stars; 0 independent implementationsAdaPS-LiNGAM: Adaptive Predecessor Selection for Linear Non-Gaussian Acyclic Models under Small-Sample Settings: 0 GitHub stars; 0 independent implementationsDisParQ: Self-Supervised Part Concepts for Interpretable Vision Foundation Models: 121 GitHub stars; 0 independent implementationsDual-QK: Sharp Queries and Flat Keys for Prunable 2-bit KV Caches: 0 GitHub stars; 0 independent implementationsSkillForge: Co-Evolving Skills and Agents via Dynamic Skill Lifecycles: 132 GitHub stars; 3 independent implementationsORCA: Hunting Compositional Failures in Text-to-Image Diffusion: 125 GitHub stars; 1 independent implementationTraining Advisors for LLM Agents from Task Outcomes: 131 GitHub stars; 1 independent implementationLiveMACE: Process-Aware Evaluation of LLM Agent Capabilities in Evolving Markets: 133 GitHub stars; 2 independent implementationsLayerwise Error Attribution for Fast and Robust Mixed-Precision Post-Training Quantization: 4 GitHub stars; 1 independent implementationA Chat Assistant for Software Exploration in a 3D Software Visualization: 4 GitHub stars; 0 independent implementationsConstrained-Action AI Remediation for SIEM/XDR via a NeMo-Guardrails Proxy: 0 GitHub stars; 0 independent implementationsAgentTracer: Tracing Indirect Prompt Injection Attack through Fine-Grained Intention-Execution Alignment: 1 GitHub star; 0 independent implementationsAgentTime: Can Agents Estimate and Control Their Own Runtime?: 131 GitHub stars; 1 independent implementationTR-PTQ: High-Accuracy Integer-Only Transformer Post Training Quantization via Taylor Region Reformulation: 0 GitHub stars; 0 independent implementationsFrom Expected Harmfulness to Likelihood: A Probabilistic Reformulation of Jailbreaking LLM Agents: 131 GitHub stars; 1 independent implementationMarrying Pricing and Advertising with LLMs: 0 GitHub stars; 0 independent implementationsLearning to Accumulate Knowledge with Mutual Information: 121 GitHub stars; 0 independent implementationsCache the Encoder Within:Compact, Reusable Memory across LLM Queries: 125 GitHub stars; 1 independent implementationLoud Failures, Quiet Failures: Fault Detection and Recovery in Tool-Using Language Model Agents: 131 GitHub stars; 1 independent implementationWhy Software Engineering Is Indispensable in the Age of Coding Agents: 0 GitHub stars; 0 independent implementationsProtocolMatch: Protocol-Dependent Model Selection for Scientific Dynamics Forecasting: 0 GitHub stars; 0 independent implementationsWhen Sub-Agents Work in Parallel: The Promises and Pitfalls of Dynamic Concurrency in Long-Horizon Coding Tasks: 0 GitHub stars; 0 independent implementationsStale, Misattributed, or Late: Where Personal Memory Fails Before Generation: 121 GitHub stars; 0 independent implementationsSparse Planning in Visual World Models via Cost Gradients: 215 GitHub stars; 0 independent implementationsDataset Pruning from First Principles: A Label-Free Linear Programming Approach: 0 GitHub stars; 0 independent implementationsAutoAdapt: Automatic Domain Discovery Enables Low-Cost Extensibility: 0 GitHub stars; 0 independent implementationsResidualQuant: KV Cache Quantization for Looped Transformers with 2-Bit Residuals: 1 GitHub star; 0 independent implementationsOrBIT: Structure-Guided Embedding Compression: 0 GitHub stars; 0 independent implementationsSUSpMV: A High Frequency Sparse Matrix Vector Multiplier on HBM Enabled FPGA written in SUS: 0 GitHub stars; 0 independent implementationsTraining Parallel Speculative Draft Models by Directly Minimizing Expected Decoding Rounds: 0 GitHub stars; 0 independent implementationsSteerspeech: Activation Steering For Emotion Control In Generated Speech: 1 GitHub star; 0 independent implementationsRunningTab: Direct Workspace Interaction with Environment-Side Tabs: 121 GitHub stars; 1 independent implementationA Good Self-Teacher Meets the Student Where They Are: Joint On-Policy Learning and Teaching: 0 GitHub stars; 0 independent implementationsFoldBack: Self-Correcting Masked Generative Policy for Long-Horizon Garment Folding: 215 GitHub stars; 0 independent implementationsBefore They Can Solve: Predicting Post-Training Coding-Agent Performance from Base Models: 10 GitHub stars; 0 independent implementationsEmbodiedRSI: Active Continual Robot Learning Through Hypothesis-Guided Co-Evolution: 132 GitHub stars; 3 independent implementationsRECAST: Learning to Compute the Right Context through Adaptive Evidence Routing: 122 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 5Aug 26: 0 papersOct 26: 1 paperAug 26Oct 26efficient architecturesmax 5Aug 26: 0 papersOct 26: 2 papersAug 26Oct 26agent evaluationmax 5Aug 26: 0 papersOct 26: 4 papersAug 26Oct 26KV cachemax 5Aug 26: 0 papersOct 26: 2 papersAug 26Oct 26speculative decodingmax 5Aug 26: 0 papersOct 26: 1 paperAug 26Oct 26distillationmax 5Aug 26: 0 papersOct 26: 1 paperAug 26Oct 26sparsity and pruningmax 5Aug 26: 0 papersOct 26: 1 paperAug 26Oct 26memory and contextmax 5Aug 26: 2 papersOct 26: 5 papersAug 26Oct 26multi-agent orchestrationmax 5Aug 26: 1 paperOct 26: 2 papersAug 26Oct 26othermax 5Aug 26: 0 papersOct 26: 4 papersAug 26Oct 26quantizationmax 5Aug 26: 0 papersOct 26: 3 papersAug 26Oct 26failure recoverymax 5Aug 26: 0 papersOct 26: 3 papersAug 26Oct 26retrieval and RAGmax 5Aug 26: 0 papersOct 26: 2 papersAug 26Oct 26safety and guardrailsmax 5Aug 26: 0 papersOct 26: 4 papersAug 26Oct 26efficient trainingmax 5Aug 26: 0 papersOct 26: 4 papersAug 26Oct 26tool usemax 5Aug 26: 0 papersOct 26: 1 paperAug 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.

Zero-Shot Self-Orchestration with Ledger-Based Control for Improved LLM Coding Performance

multi-agent orchestration · test · 4 of 4 implementations are independent · 5.2x gain in cost (reported by the authors; not independently verified)

The method replaces single-pass LLM code generation with a manager-worker scaffold in which short worker calls share state through a filesystem ledger, requiring no training or per-benchmark tuning. It roughly triples the token bill per problem, though it can buy accuracy more cheaply than upgrading to a larger model and is self-hostable on a 24 GB GPU only via small open-weight workers such as Qwen-27B-class models. It can fail because gains are strongly model-conditional: some models show null or negative deltas (e.g., Qwen3.6-35B, -1 to -9 points with reasoning off), and large reasoning-enabled models gain little, so the extra token cost may buy nothing on a given workload.

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.