Research, read for engineers

Models & training Paper

Progress-aligned recurrence reaches 95.5% accuracy at 16 times training length

PAR aligns each recurrent iteration with the state after the same number of operations and normalizes recurrent states; a Qwen2.5-0.5B model reaches 95.5% accuracy at 512 moves after training on at most 32. The ablations identify which training choices enable length extrapolation.

• WhatProgress-Aligned Recurrence trains each iteration to predict the state after the corresponding number of operations and anchors recurrent-state norms to the first iteration.
• MethodOn swap-S_5, a model trained through 32 moves reaches 95.5% full-state accuracy at 512 moves; removing norm anchoring cuts extrapolation below 2.2×.
• Why it mattersPer-iteration supervision and norm control offer a way to extend recurrent models to sequential problems deeper than those seen in training.

Original · huggingface.co by Pan Wang et al.36 upvotes

Inference Paper

SolarRenderer generates structured video in four steps, 12.3 times faster than 50-step sampling

Two lightweight LoRAs adapt a frozen video backbone to structural inputs, enabling four-step rendering; a block-causal variant renders 768p video in real time. The design shows how to add controllable generation while reducing sampling steps.

• WhatSolarRenderer adapts a frozen MiniMax-H3 33B video backbone with two lightweight LoRAs to render videos from structural controls.
• MethodStructural videos enter the backbone’s native reference pathway; structure-guided distribution matching enables four-step rendering, 12.3× faster than 50-step sampling.
• Why it mattersA block-causal variant renders 768p video in real time, supporting streaming systems that need structured video generation.

Original · huggingface.co by Guian Fang et al.33 upvotes Code · 153 stars

Models & training Paper

SWIFT uses a frozen weak denoiser to improve diffusion training without inference overhead

SWIFT extrapolates training targets away from a frozen weak denoiser’s predictions, then discards the guide; experiments report improvements across model scales and resolutions. The method targets training quality without adding inference cost or changing the sampler.

• WhatSwift trains a stronger diffusion model using a frozen weak denoiser, improving clean-target regression without inference-time guidance.
• MethodFor each noisy input, Swift extrapolates the clean target away from the weak denoiser’s prediction; the guide needs no backpropagation and is discarded afterward.
• Why it mattersThe method retains the original sampler without inference overhead, improving training without adding generation-time sampling cost.

Original · huggingface.co by Yanjin He et al.23 upvotes

Agents Paper

MMEnterprise-Bench tests agents on conflicting, evolving workplace records

The benchmark contains 1,613 questions testing evidence reasoning, conflict resolution, and unanswerability; evaluated models struggle with cross-source and temporal conflicts. Larger retrieval budgets improve recall but not consistently answer accuracy, a useful warning for enterprise-agent design.

• WhatMMEnterprise-Bench evaluates enterprise agents on 1,613 questions grounded in evolving multimodal collaboration records.
• MethodIt tests evidence reasoning, conflict resolution, and unanswerability; greater retrieval improved evidence recall but did not consistently improve answer accuracy.
• Why it mattersEnterprise agents must handle temporal and cross-source conflicts rather than assume that retrieving more evidence guarantees correct answers.

Original · huggingface.co by Seohyun Lee et al.15 upvotes Code · 1 stars

Agents Paper

S-Agent 2.0 improves spatial reasoning with a coding-agent perception toolkit

A command-line toolkit gives a coding agent persistent scene memory and plain-language interpretations of geometric readings; it improves Qwen3.8-27B by 13.9 and 20.5 points on two benchmarks. The results show how tool interfaces can turn perception outputs into usable agent evidence.

• WhatS-Agent 2.0 equips a general coding agent with a command-line 3D perception toolkit and persistent scene memory.
• MethodIts evidence loop acquires scene evidence, stores it, and interprets readings in plain spatial language, keeping readings grounded in tool geometry.
• Why it mattersThe toolkit improves results for both open- and closed-source models over the same agents without tools, supporting tool-assisted spatial reasoning.

Original · huggingface.co by Rui Gong et al.7 upvotes Code

Inference Paper

VLA-Rolling reuses discarded action tails to reduce denoising cost

The framework carries unexecuted action tails into the next planning round and allocates refinement steps using per-action confidence; it lowers inference cost across all 16 tested model–benchmark pairs. Adaptive reuse could reduce the latency and compute cost of iterative action generation.

• WhatVLA-Rolling reuses unexecuted action tails from flow-matching vision-language-action chunks instead of restarting each plan from noise.
• MethodIt inherits tails, estimates per-action confidence, then renoises and allocates denoising steps while keeping the VLA frozen.
• Why it mattersIt reduces inference cost in every tested model-benchmark pair and improves success in most, offering a more efficient approach to robot control.

Original · huggingface.co by Sicheng He et al.25 upvotes Code · 6 stars

Agents Paper

Harness² improves agent harnesses recursively without ground-truth feedback

Harness² uses task-level Propose–Probe–Compose refinement and a persistent harness that carries lessons forward; one step improved results by up to 11.8 percentage points across the reported benchmarks. The method offers evidence on improving agent behavior while keeping model weights fixed.

• WhatHarness² is a plug-and-play framework that recursively improves agent harnesses while keeping model weights fixed.
• MethodTask-level recursion proposes, probes, and composes harness edits without ground-truth feedback; harnessing-level recursion carries adopted harnesses and lessons forward.
• Why it mattersThe reported benchmark gains show how agent behavior can be improved by iterating on prompts, tools, memory, and other harness components rather than retraining weights.

Original · github.com 4 min read HN 74 pts · 18 comments

Models & training Paper

Robot fleets learn from shared successful trajectories without new demonstrations

FERT retrieves successful fleet trajectories relevant to execution failures and uses them to update a shared policy; an asynchronous fault-tolerant system coordinates collection, training and distribution. Across five manipulation tasks, policies reach 93.3–99.2% success over 120 trials per task on robots excluded from training data.

• WhatCollective experience learning lets deployed robots share execution experience to improve a common policy without new expert demonstrations or corrections.
• MethodFERT retrieves successful trajectory segments relevant to failure contexts and uses their actions to supervise policy updates; FATS coordinates collection, optimization, and distribution.
• Why it mattersAcross five manipulation tasks, policies reached 93.3–99.2% success, and larger fleets generally achieved higher success rates with fixed collection time per robot.

Original · huggingface.co by Chao Yu et al.76 upvotes

Agents Paper

CoworkEnv synthesizes executable environments for coworker-agent training

CoworkEnv generates and validates workflow environments for SFT and RL; on Claw-Eval, SFT raises Qwen3-VL-8B-Instruct's mean score from 46.6 to 64.1, with a 31.9-point gain on multi-turn tasks. It offers a measurable approach to building training data for tool-using agents.

• WhatCoworkEnv synthesizes executable training environments for AI coworkers that must use tools, communicate across turns, and respond to changing workspace state.
• MethodTeacher executions produce demonstrations for supervised fine-tuning, while student interactions supply rollouts and rewards for reinforcement learning.
• Why it mattersThe framework offers a way to generate and validate training experience for long-horizon agents; the excerpt reports improved Qwen3-VL-8B-Instruct scores after SFT.

Original · huggingface.co by Zhongwei Xie et al.26 upvotes Code · 3 stars

Agents Paper

AdaExploreBench finds LLM agents struggle to detect rule drift

Across eight leading LLMs, GPT-6 Sol reaches 61.9% calibrated accuracy, and sufficient evidence or removing rule drift improves average performance by nearly 10%. The benchmark tests whether agents can explore hidden rules and recognize when those rules change.

• WhatAdaExploreBench tests whether LLM agents proactively explore unfamiliar environments and adapt when hidden rules change.
• MethodUnder implicit rule drift, agents must infer rules from evidence and notice degraded performance as a signal to re-explore.
• Why it mattersExperiments found proactive evidence gathering and recognizing stale knowledge remain bottlenecks, even when agents can reason from informative evidence.

Original · huggingface.co by Rui Wang et al.10 upvotes Code · 1 stars

Agents Paper

Self-HPO jointly optimizes coding-agent policies and harnesses

Self-HPO alternates harness updates proposed from policy failure analysis with RL policy updates under the selected harness; it reports improvements over harness-only and policy-only baselines across three coding benchmarks. Joint optimization addresses the mismatch that can arise when a harness and policy evolve separately.

• WhatSelf-HPO is a recursive framework that jointly optimizes coding-agent harnesses and policy models.
• MethodThe current policy analyzes failures to propose harnesses; reinforcement learning updates the policy under a selected harness, and hard tasks guide the next search.
• Why it mattersJointly tuning both components improved benchmark results over harness-only and policy-only baselines, with gains generalizing to out-of-distribution settings.

Original · huggingface.co by Zhepei Wei et al.29 upvotes Code · 5 stars

Models & training Paper

Fréchet Forcing trains streaming world models beyond their clip horizon

Fréchet Forcing fine-tunes a world model with its deployed multi-step sampler, using self-generated histories and constraints on realism, scene fidelity, and action following. It targets compounding rollout drift without relying on a teacher that may share the same failure mode.

• WhatFréchet Forcing fine-tunes streaming video world models together with their deployed multi-step sampler to address drift beyond the training clip horizon.
• MethodIt applies flow-matching loss after self-generated histories, measures scene fidelity with Fréchet distance on latent statistics, and matches rollouts to real frames.
• Why it mattersThe method targets action-conditioned world models without relying on a teacher that may be action-agnostic or drift like the student.

Original · huggingface.co by Yian Zhao et al.9 upvotes Code · 5 stars

Models & training Paper

Stateful Harness separates world rules from video rendering

The framework updates a rule-governed world state before using a frozen video model to render each event, and evaluates rule compliance on 50 counterfactual pairs. The best of 11 video backends produces both required endings in only 32% of pairs under rule-only prompting.

• What- Stateful Harness separates rule-based world evolution from video rendering for interactive world models.
• Method- It resolves user actions under persistent rules, renders resulting events with a frozen video model, then uses each clip to update state; the full harness reached 92% on the benchmark.
• Why it matters- Separating state execution from rendering can make interactive AI systems follow hidden state and rules without changing the video model.

Original · huggingface.co by Chan Yan Ki et al.6 upvotes Code · 3 stars

Agents Paper

Interactive exploration raises a VLM’s 3D benchmark accuracy by 22 points

ACT3D lets a vision-language model navigate by taking actions and observing rendered images, with reinforcement learning driven mainly by answer correctness; it reports 53.2% average accuracy across six benchmarks, 22 points above its base Qwen model. The approach offers a concrete training recipe for agents that must gather information through interaction.

• WhatACT3D lets a vision-language model explore a 3D environment through actions and rendered images before answering a visual question.
• MethodAfter trajectory-supervised fine-tuning, reinforcement learning rewards final-answer correctness without directly supervising exploration choices.
• Why it mattersAcross six 3D benchmarks, ACT3D improves its base Qwen model's average accuracy by 22 points while using 50–70% fewer input frames.

Original · huggingface.co by Yijiang Li et al.29 upvotes

Inference Paper

DLite removes historical KV-cache dependence from speculative decoding

DLite uses target-model hidden states for local speculative prediction instead of maintaining historical context; existing draft models lose up to 80% of acceptance length on agentic workloads. The approach targets both acceptance degradation and KV-cache overhead in multi-turn serving.

• WhatDLite is a history-free speculative decoding framework designed for agentic workloads with long, evolving contexts and frequent multi-turn interactions.
• MethodIt reuses target-model contextual hidden states for local speculative prediction, avoiding explicit historical-context maintenance; a sequential head restores intra-block causal dependencies.
• Why it mattersExperiments report 2–6 acceptance length and up to 70% improvement over DSpark, while avoiding the overhead of maintaining historical KV cache.

Original · huggingface.co by Jiaming Xu et al.13 upvotes Code · 13 stars

Models & training Paper

M3-Agent more than triples video-world-model reveal scores by targeting execution

MIST separates setting a scene from carrying out a requested change, identifying execution—not memory—as the bottleneck in its tests; M3-Agent revises instructions and more than triples the MIST reveal score. Separating these failure modes can prevent teams from misdiagnosing model capabilities.

• WhatMIST separates whether a video world model sets a scene, carries out an instructed change, and shows the result in its final frame.
• MethodThe evaluation found that models often set the scene but fail to execute the requested change; M3-Agent recursively revises instruction details to address this.
• Why it mattersM3-Agent more than triples MIST's reveal score, underscoring the need to distinguish execution failures from memory failures in model evaluations.

Original · huggingface.co by Weiyang Jin et al.12 upvotes Code · 3 stars

Agents Paper

SciΠvot finds four of five frontier models below chance on research judgments

SciΠvot tests 248 decisions drawn from six months of agent-assisted research and finds four of five frontier models perform below chance on selected cases. It highlights how agent evaluations can expose failures in context-dependent judgment, not just task execution.

• WhatSciΠvot is a 248-case benchmark of scientific judgment built from human corrections to LLM agents’ research decisions.
• MethodModels choose between an original LLM plan and a human-corrected alternative using the project record; four of five frontier models scored below chance on selected cases.
• Why it mattersThe results show that autonomous research agents can struggle with pivotal decisions, even when given project context.

Original · huggingface.co by Youran Sun et al.9 upvotes

Models & training Paper

MOSS-Image reports 96.3% text coverage on a long-form rendering benchmark

MOSS-Image pairs a 5B diffusion transformer with an agentic prompt-enhancement module and reports 96.3% average text coverage on LongLongTextBench. Its results and layout benchmark provide concrete targets for open-weight text-rich image generation.

• WhatMOSS-Image is an open-weight text-to-image system designed for high-fidelity visuals, long-form text rendering and layout control.
• MethodIt combines a 5B diffusion transformer with a prompt-enhancement module; it reports 96.3% average text coverage on LongLongTextBench.
• Why it mattersIts prompt-to-image design and evaluation benchmarks offer engineers a system for generating and assessing text-rich, layout-coherent images.

Original · huggingface.co by MOSI. AI8 upvotes Code · 741 stars

Agents Paper

Hybrid agents switch between latent reasoning and text-based tool use

HybridAgents use a HybridLink to move between latent and text modes, with continuous working memory intended to preserve hybrid context across turns. The design targets a trade-off between efficient internal reasoning and inspectable, tool-integrated agent behavior.

• WhatHybrid Reasoning Agents combine latent-space reasoning with text-based interaction for tool use.
• MethodHybridLink enables transitions between modes, while continuous working memory preserves context; HybridSFT and HybridRL train the model to coordinate and switch modes.
• Why it mattersThe paper reports lower token use, faster inference and lower cost, offering engineers a way to trade internal reasoning efficiency against inspectable tool interaction.

Original · arxiv.org 3 min read HN 332 pts · 163 comments

Inference Paper

Speculative sampling uses large video windows without waiting for chunk boundaries

The method pads larger bidirectional windows with noise latents, caches predictions while conditions stay unchanged and delivers results incrementally with replaceable future frames. It reframes the latency–quality trade-off for interactive video generation, but the excerpt reports no measured gains.

• WhatSpeculative Sampling is a strategy for interactive video generation that combines large bidirectional windows with low-latency interaction.
• MethodIt pads windows with noise latents, caches predictions for unchanged conditions and delivers predictions incrementally while future output remains replaceable.
• Why it mattersThe approach removes chunk-boundary waiting as a latency floor, letting engineers trade off window size, visual quality and sampling time.

Original · huggingface.co by Yubo Huang et al.11 upvotes Code · 6 stars

Research Paper

RoTA-Bench finds a large human-model gap in interactive 3D alignment

On RoTA-Bench's 100-task test set, GPT-5.6-Sol succeeds on 17% of tasks while 20 participants collectively complete the set four times with 100% success; model image-space progress also diverges from pose alignment more often than humans. The benchmark exposes concrete limits in interactive spatial reasoning and control.

• WhatRoTA-Bench evaluates whether vision-language models can align a 3D object's projection with a target silhouette through interactive rotations.
• MethodGPT-5.6-Sol succeeded on 17% of tasks versus 100% for undergraduate participants; removing interaction history sharply reduced model success.
• Why it mattersThe results highlight challenges in translating visual input into precise 3D control, a key capability for interactive AI systems.

Original · huggingface.co by Qingchuan Ma et al.201 upvotes Code · 4 stars

Models & training Paper

SAE features show measurable pairwise interactions in model behavior

The paper defines SAE Additivity Residuals and finds lower first-order residuals for learned coordinates across 18 model-behavior settings, while pairwise terms improve held-out coalition ordering. Its measured results caution against assuming sparse features have additive effects when interpreting or steering models.

• WhatThe paper introduces SAE Additivity Residuals to measure behavioral variation unexplained by interactions up to a chosen order.
• MethodLearned SAE coordinates had lower first-order residuals than rotated coordinates, but pairwise terms improved held-out coalition ordering in every setting.
• Why it mattersEngineers interpreting or steering models may need to account for interactions between features, not just individual feature effects.

Original · huggingface.co by Haotian Ma et al.106 upvotes Code · 5 stars

Agents Paper

Claude found substantially smaller designs for several quantum circuits

Given plain-language specifications and an automated evaluator, Claude produced designs that beat published circuits, with some improvements of an order of magnitude or more. The work is a notable example of model-driven design guided by automated evaluation, though its application is specialized to quantum computing.

• WhatClaude designed circuits from plain-language specifications for eight quantum problems, with an automated evaluator checking and scoring each design.
• MethodWorking largely on its own, Claude found designs that improved on the best published circuits, sometimes by an order of magnitude or more.
• Why it mattersSmaller circuits can reduce scarce quantum resources and computation time, easing constraints on useful applications.

Original · anthropic.com 16 min read HN 172 pts · 36 comments

Models & training Paper

Waypoint-OPD gates policy-shift distillation using an intermediate checkpoint

Waypoint-OPD compares early and late teacher policy shifts at student-visited prefixes and suppresses endpoint supervision when those shifts conflict, adding one frozen-teacher scoring pass. It offers a targeted way to transfer RL-induced changes into student models.

• WhatWaypoint-OPD uses an intermediate teacher checkpoint to guide transfer of reinforcement-learning-induced policy shifts to a student.
• MethodIt compares early and late shifts in relative action preferences at student-visited prefixes, suppressing endpoint shifts when the directions oppose.
• Why it mattersIn the reported evaluations, it achieved the highest domain-average score among compared distillation methods in all six domain–student settings.

Original · huggingface.co by Bingxi Hou et al.666 upvotes Code · 3 stars

Agents Paper

Cowork-Gym synthesizes 64.9K interactive work environments for agent training

Cowork-Gym uses a build-execute-revise loop and stateful user simulation to generate 64.9K environments; its post-trained models improve by 8.7, 6.4 and 4.1 points across six benchmarks. The scale and measured gains make it a useful example of building realistic training environments for tool-using agents.

• WhatCowork-Gym synthesizes interactive work environments through a build-execute-revise loop that uses execution evidence and review feedback to validate and repair them.
• MethodA stateful user simulator responds to agent actions through dialogue and direct edits to the shared workspace.
• Why it mattersThe framework produced 64.9K environments across 14 application scenarios for training and evaluating agents in changing, tool-rich workspaces.

Original · huggingface.co by Anni Zou et al.7 upvotes

Models & training Paper

LeanPRM uses Lean-checked proofs to train step-level verifiers

LeanPRM creates 152K step labels across 10,634 proofs, and its Qwen3-4B verifier reaches 74.7% held-out step-label accuracy versus 48.2% for the base model. The results show how formal tools can supply training data for checking long natural-language proofs.

• WhatLeanPRM generates step-level labels for natural-language proofs by pairing them with formal proofs checked by Lean.
• MethodA second model removes failures caused only by formal syntax, so negative labels identify mathematical errors; the resulting dataset has 152K labeled steps.
• Why it mattersA Qwen3-4B verifier trained on LeanPRM reached 74.7 exact step-label accuracy on a held-out set, versus 60.3 for the same base model trained on PRM800K.

Original · huggingface.co by Rodney Lafuente-Mercado et al.5 upvotes

Databases Paper

CLP searches compressed logs while scaling to petabytes

CLP combines lossless, domain-specific compression with search on compressed text, reporting over 13× faster ingestion than Elasticsearch and Splunk and petabyte-scale operation. The approach offers a substantial storage and observability trade-off for large log archives.

• WhatCLP losslessly compresses unstructured text logs while allowing searches directly on the compressed data.
• MethodIts domain-specific algorithm exploits repetition in logs; the paper reports search comparable to or faster than Elasticsearch and Splunk.
• Why it mattersCombining archival compression with fast search and over 13x faster ingestion can reduce costs in large-scale log systems.

Original · usenix.org by usenix.org via typesanitizer

Research Paper

WorldCast benchmarks multi-step visual prediction of future world states

WorldCast evaluates 12 models on 320 manually designed cases spanning eight categories of multi-step world-state prediction. The benchmark probes whether multimodal systems can combine world understanding and visual generation to forecast successive states.

• WhatWorldCast is a benchmark for multi-step visual prediction of future world states from multimodal observations and references.
• MethodIt contains 320 manually designed cases across eight categories and evaluates 12 models; the excerpt reports substantial gaps remain.
• Why it mattersThe benchmark targets higher-level world modeling, a task the authors say remains relatively underexplored despite model progress.

Original · huggingface.co by Wenhao Yan et al.30 upvotes Code · 12 stars

Agents Paper

OpenGCUA moves computer-use observations and task decisions into the model

OpenGCUA’s first release uses code execution for computer interaction and transfers selected observation and task-state decisions from fixed harness rules to the model; its full configuration improves scores across all eight evaluated models. The open stack offers concrete harness design choices for computer-use agents.

• WhatOpenGCUA is an open-stack project for generalist computer-use agents that work through visual and programmatic interfaces.
• MethodIts design uses code execution for intermediate results and transfers some observation and task-state decisions from fixed harness rules to the model.
• Why it mattersOn OSWorld-v2, the full configuration raised mean partial score by 19.6 points and reduced reported steps per task by 53% versus batched GUI-only execution.

Original · huggingface.co by Hanzhang Zhou et al.295 upvotes Code · 26 stars

Agents Paper

FDE-Gym benchmarks agents on ambiguous, end-to-end customer delivery

FDE-Gym contains 95 delivery tasks across 20 customer scenarios and 18 sectors, scoring outcomes against customer success metrics while penalizing interaction costs. Its tasks test requirement discovery and live-system work missing from issue-based agent benchmarks.

• WhatFDE-Gym benchmarks agents on 95 end-to-end delivery tasks adapted from real-world projects across 18 sectors.
• MethodAgents work in simulated customer environments, clarifying requirements with scripted stakeholders and operating modifiable customer systems.
• Why it mattersThe benchmark highlights a delivery gap: in the realistic setting, the best configuration scored 0.56 on average and resolved 14 tasks without incident.

Original · huggingface.co by Dongxu Yang et al.282 upvotes Code · 97 stars

Agents Paper

Data World synthesizes environments and tasks for training data agents

Data World builds worlds, files, tasks, and rubrics from explicit mechanisms, producing a benchmark of 100 tasks and 2,135 training tasks; RL-zero training improves its 35B-A3B model by 7.06 points on DataWorld-Bench. The pipeline addresses costly curation and evaluation for data agents.

• WhatData World is a multi-agent engine that synthesizes environments, tasks, and rubrics for training data agents.
• MethodIt specifies the world behind files before generating them; audits check whether targets can be recovered, and rubrics support evaluation and RL rewards.
• Why it mattersSynthesized tasks offer an option for agent training and evaluation where real-world curation is costly or restricted by privacy and intellectual-property concerns.

Original · huggingface.co by Zhanli Li et al.26 upvotes Code · 18 stars

Agents Paper

CoDA co-evolves simulation data and policies to address robot failures

CoDA turns diagnosed policy failures into regenerated training environments and staged learning signals; on four manipulation task families, it raises out-of-distribution success from 5.3% to 27.6%. The results show how targeted environment generation can improve embodied-agent robustness.

• WhatCoDA co-evolves a simulation data engine and an action policy to address robot policy failures.
• MethodA shared heterogeneous memory turns diagnoses from a vision-language critic into generation and training programs; Text2potential makes staged potentials for action-chunk value learning.
• Why it mattersMeasured learning progress guides further generation and program refinement, linking simulation data production to a robot policy's observed needs.

Original · huggingface.co by Tianjiao Yu et al.9 upvotes

Agents Paper

MAI-Gym scales GUI agent evaluation and RL training to 20,000 environments

MAI-Gym unifies GUI evaluation, data collection, and online RL across mobile, computer, and web environments, supporting 20,000 parallel instances. Its 9B agent scores 78.4% on MobileWorld and 76.2% on OSWorld-Verified, making the platform and results useful for teams building GUI agents.

• WhatMAI-Gym is an open platform for GUI agent evaluation, data collection, and online RL training across mobile, computer, and web environments.
• MethodA shared rollout pipeline supports consistent agent behavior across evaluation and training; the platform scales to 20,000 parallel environment instances.
• Why it mattersThe platform supports reproducible GUI-agent development with synthesized applications and tasks; its mocked train-ticketing app training also transferred to a real phone.

Original · huggingface.co by Panrong Tong et al.96 upvotes Code · 23 stars

Inference Paper

MJev-Spatial replaces spatial answer generation with one-pass classification

MJev-Spatial scores candidate answers using pretrained query and key projections, handling choices, numeric values, and points without generating answer tokens. A single forward pass for each decision could reduce latency in spatial tasks that require frequent interaction.

• WhatMJev-Spatial is a multimodal decision model for spatial relation, distance, and point-prediction tasks.
• MethodIt scores candidate answers with pretrained query and key projections, using coarse-to-fine classification for numerical and point predictions.
• Why it mattersSingle-pass classification avoids answer-token generation and parsing, which can matter for agents making spatial judgments at interaction rates.

Original · huggingface.co by Luozheng Qin et al.175 upvotes Code · 7 stars

Inference Paper

Speculative Forcing stops denoising tokens once their outputs are stable

Speculative Forcing accepts tokens early when a verifier judges their intermediate estimates sufficiently close to final outputs, while retaining their cached keys and values. It reports matching the four-step LongLive generator with about 1.7 denoising steps, a promising route to cheaper video generation.

• WhatSpeculative Forcing reduces denoising work in few-step autoregressive video generation by accepting stable tokens early.
• MethodA verifier predicts which token estimates are ready; accepted tokens are frozen, and their cached keys and values remain context for later tokens.
• Why it mattersPer-token early stopping offers a way to reduce generation compute while preserving full-step sampling quality, according to the reported evaluations.

Original · huggingface.co by Hyunwook Choi et al.56 upvotes Code · 2 stars

Models & training Paper

SCOPE assigns text-to-image RL updates to semantic prompt spans

SCOPE pools policy-log-probability shifts within semantic spans and reports 9.48% average relative gain on GeneVal and 7.62% on T2I-CompBench over vanilla GRPO. It shows how structured credit assignment can improve prompt optimization without extra image renders.

• WhatSCOPE is an RL objective for text-to-image prompt rewriting that assigns update weights to semantic spans rather than isolated subword tokens.
• MethodThe rewriter generates an enhanced prompt and semantic partition; log-probability shifts within each span produce a shared coefficient for token losses.
• Why it mattersThe method aligns training signals with prompt meaning and reports gains over vanilla GRPO without extra span rewards or image renders.

Original · huggingface.co by Yufei Jiao et al.33 upvotes Code · 1 stars

Agents Paper

Terminal-RSI alternates verified trajectory rewriting with policy refinement

Terminal-RSI combines recursive rewriting of verified trajectories with critic-inheriting policy refinement, reaching 19.84% on Terminal-Bench 4.0 and 86.52% on Terminal-Bench 2.1. Its staged update recipe is relevant to training agents on long terminal tasks.

• WhatTerminal-RSI improves terminal agents by alternating recursive rewriting of verified trajectories with policy refinement.
• MethodIts five-stage process runs from a Qwen3.8-27B base model through two RSR and two RPR stages, using critic handoff and calibrated rewards.
• Why it mattersThe approach is designed to turn verified behavior and partial progress into successive policy updates for terminal tasks.

Original · huggingface.co by Junyao Yang et al.16 upvotes

Agents Paper

Intern-Decision returns structured choices in one multimodal model pass

Intern-Decision evaluates all fields in a JSON decision skeleton in one causal pass; its 4B model reaches 90.02% average accuracy, with 44.16 ms mean latency for a 289-token request on an RTX 4090. Direct decision outputs could cut latency in agent control loops.

• WhatIntern-Decision is a family of multimodal models that returns structured choices and candidate probabilities from text and optional images.
• MethodA complete JSON skeleton places decision placeholders in each field; one causal forward pass evaluates the fields with the model’s native language-model head.
• Why it mattersStructured outputs can simplify agent interfaces and avoid latency from generating free-form responses for finite-choice decisions.

Original · huggingface.co by Tong Zhu et al.15 upvotes Code · 786 stars

Agents Paper

JevAgentHarness delegates tool choices using fitted confidence thresholds

The benchmark finds that isolated decision accuracy did not predict agent success and that untuned delegation reduced success by 19 points; the harness fits thresholds on the agent’s own trajectories. This is a useful warning and design pattern for replacing expensive LLM calls.

• WhatJevAgentHarness delegates some agent tool choices to a decision model instead of calling a large LLM at every step.
• MethodIt fits a confidence threshold on the agent’s own trajectories and lets the LLM decide when confidence falls below that threshold.
• Why it mattersThis thresholded delegation targets lower latency and cost while limiting the success loss that uncalibrated delegation can cause.

Original · huggingface.co by Kunlun Zhu et al.14 upvotes Code · 3 stars

Inference Paper

Velox routes video-world attention by spatial memory and speeds chunk 48 denoising 2.43×

Velox uses camera-frustum overlap to select historical context, reporting 4.36× faster attention and 2.43× faster denoising at chunk 48. The approach targets growing KV-cache costs in long interactive video rollouts.

• What- Velox is a training-free attention router that selects region-level context for chunked video diffusion world models.
• Method- It represents history as camera frustum slabs and uses recency-priority multiwarp for current-block depth; overlap modulates importance for covered regions.
• Why it matters- By reducing attention growth with rollout length, it reports 2.43× faster denoising at chunk 48 while staying within 0.15 average points of dense LingBot-Fast-Cam on WBench navigation.

Original · huggingface.co by Qiuhong Shen et al.13 upvotes

Agents Paper

ATAS uses scene and event memories to keep generated video shots consistent

ATAS retrieves spatial and time-indexed evidence before generating shots, then updates memory only after review and state checks; it improves reported consistency across four video generators. Its memory-admission design is relevant to agents that must maintain state across nonconsecutive tasks.

• WhatATAS turns a screenplay into video shot requests with explicit location, camera, and event-time references.
• MethodIt retrieves evidence from scene and event memories before generation, then reconstructs clips and updates memory after review and state checks.
• Why it mattersAcross four generators, it improves all reported cross-shot consistency measures, helping engineers build video systems that revisit scenes and events consistently.

Original · huggingface.co by Weijie Wang et al.105 upvotes Code · 65 stars

Models & training Paper

LatentLoop reallocates compute across visits in looped MoE models

LatentLoop compresses the first loop visit, keeps full resolution for the second, and reallocates saved compute to hidden size; it lowers validation NLL across 15 configurations from 1.3B to 7B parameters. The results offer a concrete architecture trade-off for compute-constrained model training.

• WhatLatentLoop is a looped Mixture-of-Experts model that allocates computation asymmetrically across two visits to a shared block.
• MethodIt compresses the sequence on the first visit, keeps full resolution on the second, and reallocates saved computation to increase hidden size.
• Why it mattersThe approach lowers validation NLL across 15 configurations, offering engineers a way to use compute more effectively in looped MoE models.

Original · huggingface.co by Zefeng He et al.42 upvotes Code · 1 stars

Agents Paper

τ-Emotion-Bench tests tool agents with emotionally varied users

The ten-domain benchmark varies user emotions while keeping task objectives fixed, and its Tracer pipeline generates grounded tasks and filters inefficient interactions. It tests whether agent evaluations capture interaction failures that ordinary task-success scores miss.

• Whatτ-Emotion-Bench evaluates tool-calling agents in ten domains using controlled, emotion-conditioned user interactions.
• MethodTracer generates grounded, policy-valid tasks and collects trajectories through an agent-user-environment harness; dissatisfied users can end inefficient interactions.
• Why it mattersThe benchmark finds frontier agents unreliable across task completion, while Tracer-generated supervision improves Qwen3 models and transfers to other benchmarks.

Original · huggingface.co by Rishitosh Kumar Singh et al.7 upvotes Code · 4 stars

Agents Paper

A 132-run comparison finds limited, unstable gains from agent self-distillation

Across 132 runs and 12,124.4 H800 GPU-hours, ten self-distillation methods produced no consistent gains over GRPO, and strong final scores could hide unstable training. The controlled comparison provides unusually concrete evidence for choosing agent-training methods and budgeting experiments.

• WhatThe study compares ten self-distillation methods with GRPO across four tasks and three model sizes.
• MethodAcross 132 training runs, it finds gains over GRPO are limited, strong final results can hide unstable training, and extra cost does not consistently improve performance.
• Why it mattersIts repeated evaluations and cost measurements give engineers a shared basis for judging agent-training methods and their reliability.

Original · huggingface.co by Linhao Zhong et al.7 upvotes Code · 1 stars

Agents Paper

GroundGUI pairs 586K screenshots with a distillation-to-RL training method

ScreenRef contains 586K screenshots and over 633K referring-expression instances across desktop, web, and mobile; GroundGUI-8B combines supervised fine-tuning with D2RL. The dataset and training recipe target a key grounding bottleneck for GUI agents.

• WhatGroundGUI introduces ScreenRef, a GUI grounding dataset with screenshots paired with referring expressions and box or point annotations.
• MethodScreenRef covers desktop, web, and mobile; GroundGUI-8B is trained with sequential supervised fine-tuning and D2RL.
• Why it mattersThe dataset and training method target grounding and generalization challenges engineers face when building GUI agents.

Original · huggingface.co by Qingsong Xie et al.7 upvotes Code · 3 stars

Inference Paper

KV4-RL protects selected KV positions to speed INT4 rollouts

KV4-RL keeps attention sinks and recent context in INT8 while quantizing the rest to INT4, achieving 1.80× cumulative rollout speedup and 1.27× full-iteration speedup with final accuracy within 0.5 percentage points of BF16. The results show how selective KV-cache protection can improve RL training throughput while limiting quality loss.

• What- KV4-RL combines calibration-free INT4 KV-cache quantization with selective INT8 protection for attention sinks and recent context.
• Method- Protecting a bounded number of positions reduces sampler mismatch while retaining most INT4 speedup; INT4 alone can degrade learning even with TIS.
• Why it matters- In GRPO training, KV4-RL achieved 1.80× cumulative rollout and 1.27× full-iteration speedups over BF16, with final accuracy within 0.5 points on two models.

Original · huggingface.co by Sihwan Park et al.19 upvotes

Inference Paper

DoSA skips unnecessary sparse-attention scores with exact selection guarantees

DoSA uses score bounds to avoid fully scoring candidates that cannot enter Top-K, reporting up to 2.74× Indexer speedup and up to 1.94× time-to-first-token speedup. Its exact-selection approach offers a concrete path to faster sparse-attention serving.

• What- DoSA is a lossless method that makes sparse-attention scoring conditional while preserving exact token selection.
• Method- A seed-set threshold and bounds certify which candidates can be rejected; only still-eligible candidates receive full scoring, followed by exact-score filtering.
• Why it matters- The GPU implementation accelerates the complete Indexer by up to 2.74× over SGLang, reducing attention-indexing work without approximate selection.

Original · huggingface.co by Fanxu Meng, Taosong Fang47 upvotes Code · 5 stars

Agents Paper

VideoJev reuses video computation for faster agent queries

VideoJev reuses visual computation across incoming queries or batches them together, with reported inference speedups of 2.8–3.1× and higher temporal-grounding mIoU than its backbones. The combination of faster repeated video queries and measured task gains matters for interactive visual agents.

• What- VideoJev is a family of models for video understanding and interaction that frames tasks as structured decisions.
• Method- A shared head scores temporal intervals and textual options against video evidence; cached or joint inference reuses visual computation for later queries.
• Why it matters- It reports 2.8–3.1× inference speedups on temporal-grounding benchmarks and speedups exceeding 100× on video question answering, supporting faster agent decisions.

Original · huggingface.co by Yuhan Zhu et al.19 upvotes Code · 4 stars

Models & training Paper

TPPO tracks token-level value changes for language-model reasoning

TPPO builds value estimates from additive position-wise outputs and reports aggregate reasoning-score gains of 7.0 and 8.4 points over PPO on two Qwen3 base models, with results extending to other models and tasks. Its released implementation makes the alternative value parameterization available for testing in RL training.

• What- Tracking-Value PPO (TPPO) is a cumulative value parameterization for language-model reasoning.
• Method- It uses a Bayesian decomposition of successive prefix values, adds position-wise scalar outputs in log-odds space, and trains reconstructed values with terminal-outcome supervision.
• Why it matters- TPPO improves aggregate mathematical reasoning scores over PPO by 7.0 and 8.4 points on Qwen3-4B-Base and Qwen3-8B-Base, respectively, and yields more reliable advantage estimates.

Original · huggingface.co by Futing Wang et al.17 upvotes Code · 2 stars

Agents Paper

DeltaTTG uses token-to-go estimates to shape multi-turn agent training

DeltaTTG trains a reusable progress meter from recorded trajectories and uses changes in its estimates to redistribute outcome-derived advantages across steps; it improves average scores over GRPO by 5.7 and 7.2 points on two model families. The method provides a progress signal without task-specific rules or external step evaluators.

• What- DeltaTTG trains a reusable progress meter for multi-turn agents using Token-to-Go, the tokens remaining until task completion, as its supervision target.
• Method- During actor training, changes in the frozen meter’s estimates redistribute outcome-derived advantages across steps without changing rewards or trajectory advantage signs.
• Why it matters- It improves average scores over GRPO by 5.7 points with Qwen3-4B and 7.2 points with Llama-3.1-8B-Instruct, while keeping actor-training GPU-hours close to GRPO.

Original · huggingface.co by Xuyan Ye et al.13 upvotes Code · 1 stars

Agents Paper

ReTerm trains terminal agents to recover from their own failures

ReTerm-GRPO forks from failed task states to train independent recovery attempts; ReTerm-9B reaches 34.8% Pass@1 on Terminal-Bench 2.0, 14.6 points above its base model. The released code, data, and model make this recovery-training recipe directly testable.

• WhatReTerm is a terminal agent trained to recover from failures in long-running coding tasks.
• MethodReTerm-10K supplies recovery demonstrations for supervised fine-tuning; ReTerm-GRPO generates independent attempts from the agent’s failure states.
• Why it mattersLearning whether recovery attempts complete tasks aims to help engineers build agents that can self-correct during long-running terminal work.

Original · huggingface.co by Wei Xie et al.9 upvotes Code · 7 stars

Architecture Paper

Minions aggregates idle Apple Silicon GPUs into a distributed inference cloud

Minions proposes pooling idle GPUs across macOS devices for inference, with dynamic task execution and fault tolerance. The design offers a way to use existing hardware when centralized GPU capacity is costly or constrained.

• WhatMinions aggregates idle GPUs across Apple Silicon macOS devices into a distributed virtual GPU cloud for inference.
• MethodThe system executes large-scale inference workloads with fault tolerance and flexible task execution using existing hardware.
• Why it mattersReusing idle device GPUs offers an alternative when centralized GPU capacity is costly, inelastic or constrained.

Original · machinelearning.apple.com HN 244 pts · 96 comments

Research Paper

LeWAM trains a world model and action policy end to end

LeWAM jointly trains latent-state prediction and action flow matching, improving success from 28.6% to 89.7% on contact-rich tasks and planning 32.3× faster. The results make an integrated latent-world-model approach worth examining for embodied control.

• WhatLeWAM is an end-to-end JEPA for control that jointly trains latent-state prediction and action flow matching.
• MethodAn isotropic Gaussian latent constraint lets one model execute policies directly or plan by evaluating sampled actions with learned latent dynamics.
• Why it mattersIn reported tests, it improved success rates on contact-rich and long-horizon tasks and planned 32.3 times faster than prior JEPAs in visual planning.

Original · huggingface.co by Minghao Fu et al.32 upvotes Code · 228 stars

Models & training Paper

Researchers hide encrypted neural networks inside host model weights

The authors describe backdoors that decrypt and run hidden neural networks only after a secret trigger, and report testing elicitation methods including fine-tuning and gradient-based trigger search. The result challenges the assumption that capability evaluations can reliably expose hidden model behaviors.

• WhatThe paper constructs backdoor attacks that embed encrypted neural networks in host model weights and run them only on a secret trigger.
• MethodDigital lockers keep hidden circuits provably hard to elicit and interpret under cryptographic assumptions; tests found resistance to several elicitation methods.
• Why it mattersThe results expose a limit of elicitation-based capability audits, even when evaluators have full access to model weights.

Original · arxiv.org 3 min read HN 185 pts · 100 comments

Agents Paper

MASS optimizes multi-agent workflows through self-supervision

MASS repeatedly optimizes multi-agent workflows and distills their collective output into a self-supervision signal; the authors report improved score per output token over a base model on research benchmarks and provide code. The method and evidence make it relevant to teams building agent systems and evaluating their efficiency.

• WhatMASS repeatedly optimizes multi-agent workflows and distills collective intelligence into self-supervision for recursive self-improvement.
• MethodIt frames the model being improved as its own optimizer and evaluator when stronger teachers or reliable human feedback may be unavailable.
• Why it mattersMASS improves score per output token over the base model on research benchmarks.

Original · pub.sakana.ai 18 min read HN 135 pts · 79 comments

Models & training Paper

SynthSelf uses a same-family aligner to continually post-train small models

SynthSelf outsources synthetic self-distillation to a minimally larger, same-family aligner and combines it with off-policy supervision and rejection sampling; evaluations cover four acquisition datasets and 14 retention benchmarks. The method addresses continual learning for low-latency, smaller models.

• WhatSynthSelf is a continual post-training method that uses synthetic self-distillation to help small models learn new capabilities.
• MethodIt uses a minimally larger, same-family aligner for in-distribution rewrites, with off-policy supervision and rejection sampling.
• Why it mattersAcross 4 acquisition datasets and 14 retention benchmarks, SynthSelf outperformed 6 methods across 3 small-model scales.

Original · huggingface.co by Woosung Koh et al.41 upvotes

Agents Paper

AgentSWE tests whether coding agents build agents that meet requirements

AgentSWE evaluates agent creation, production-code editing, and optimization across 25 tasks, using held-out cases and requirement-derived acceptance rubrics. It offers a more realistic way to test whether coding agents deliver behavior users asked for.

• WhatAgentSWE benchmarks coding agents that create, edit, and optimize agents against user requirements.
• MethodIts 25 tasks let builders iterate on illustrative cases, then test frozen submissions on held-out cases using requirement-based rubrics or benchmark objectives.
• Why it mattersEvaluated coding agents fell short of requirements; the gap between demonstrated and delivered behavior was the norm.

Original · huggingface.co by Jiahao Wang et al.32 upvotes

Agents Benchmark

AAArena tests agents that revise executable policies across 12 adversarial games

AAArena evaluates agents refining game policies under fixed budgets; Opus5.5 with Claude Code earns six gold medals but no tested configuration tops the other six human ladders. It probes how agent harnesses learn from feedback and where that approach breaks down.

• WhatAAArena is a benchmark for heuristic learning in 12 adversarial games, with 1,920 archived human programs.
• HowAgents interpret rules, choose opponents, analyze replays and revise game agents; the evaluated configurations earned six gold medals but topped only six of the human ladders combined.
• Why it mattersThe benchmark tests whether systems can improve executable policies from match experience under fixed evaluation budgets.

Original · huggingface.co by Kaisen Yang et al.43 upvotes Code · 39 stars

Inference Paper

DCOCO restores context across parallel speculative drafts

DCOCO keeps multiple draft-token candidates and checks their compatibility across positions in parallel, restoring context among draft tokens at low additional cost. Its throughput results across four verifier backbones and ten benchmarks make it relevant to speculative-decoding design.

• WhatDCOCO is a lightweight correction mechanism for parallel speculative drafts in large language model inference.
• MethodIt retains multiple token candidates and selects contextually compatible tokens across adjacent draft positions before target-model verification.
• Why it mattersRestoring draft context while preserving parallelism improves throughput; DCOCO led evaluated configurations and reached up to 6.6× speedup over vanilla decoding.

Original · huggingface.co by Roy Eisenstadt et al.26 upvotes Code · 22 stars

Models & training Paper

Offline student rollouts outperform on-policy distillation in 14 of 17 model pairs

Semi-OPD beats on-policy distillation in 14 of 17 teacher-student pairs, with up to 13.6% higher accuracy and 11.4× faster training. The results challenge the assumption that on-policy sampling is always preferable and identify teacher-student alignment as a factor in choosing a recipe.

• WhatSemi-OPD distills teacher capabilities using offline rollouts generated by the initial student, as an alternative to on-policy distillation.
• MethodAcross 17 teacher-student pairs, Semi-OPD outperformed OPD in 14; the choice depends on the pair’s output-token overlap.
• Why it mattersFor model builders, student rollouts can offer more stable and efficient distillation when teacher and student are misaligned.

Original · huggingface.co by Siyan Zhao et al.17 upvotes

Agents Paper

MetaKernelBench measures whether GPU-kernel skills transfer across DSLs

Across six models, transferred skills changed paired performance from -19% to +29%, with regressions on 16% to 45% of attempts. The benchmark tests whether agent memory helps kernel optimization across languages instead of merely scoring isolated attempts.

• WhatMetaKernelBench evaluates whether GPU-kernel optimization experience transfers between CuTe DSL and TIRx.
• MethodAgents distill a source attempt into a natural-language skill, then use it on the same problem in the other DSL; paired lift ranged from -19% to +29%.
• Why it mattersIt measures whether retained skills help beyond correctness and speed on one attempt, while exposing transfer regressions across models and problems.

Original · huggingface.co by Xueyi Chen et al.16 upvotes Code · 4 stars

Databases Paper

The data cube generalizes SQL aggregation across multiple dimensions

The paper defines the cube operator as a relational generalization of grouping, cross-tabs, roll-ups, and subtotals, and discusses efficient computation. Its model remains useful context for engineers working on analytical query systems.

• WhatData cube is an N-dimensional relational aggregation operator that generalizes SQL GROUP BY and reporting constructs.
• MethodEach set of attribute values maps to a point in N-dimensional space; aggregating to lower-dimensional spaces produces super-aggregates.
• Why it mattersBecause cubes are relations, they can be embedded in more complex non-procedural data analysis programs.

Original · arxiv.org by arxiv.org via typesanitizer

Agents Paper

SoftwareGym generates GUI environments that improve agent training

SoftwareGym synthesizes 182 applications with a 91.5% mean GUI task pass rate; training on its trajectories raises OSWorld Pass@3 from 41.39% to 56.97%. The pipeline provides a scalable route to training environments and reports transfer to an out-of-domain benchmark.

• WhatSoftwareGym is an automated pipeline that synthesizes runnable GUI software environments for computer-use agent training.
• MethodIt generates diverse designs, realizes them as applications, then uses GUI evaluation and iterative repair to verify functionality.
• Why it mattersSynthesized environments provide scalable, transferable training supervision for computer-use agents.

Original · huggingface.co by Tian Jin et al.40 upvotes Code · 3 stars

Agents Paper

RSI-Anything improves code repair and GUI tasks through world-model-guided learning

With the coder fixed, predictive selection and world-model adaptation raise code-repair success from 26.3% to 31.2%; GUI task completion also rises while average actions fall 39.4%. The framework combines feedback-driven updates with checks before retaining policy-model pairs.

• WhatRSI-Anything is a framework that uses predictive world models to guide action and learning-data selection as policies improve.
• MethodObserved feedback drives policy or workflow improvement and world-model adaptation; component and compatibility checks govern retention of updated pairs.
• Why it mattersIn GUI evaluations, task completion rose while average actions fell 39.4%, pointing to more efficient interactive agents.

Original · huggingface.co by Taoyong Cui et al.22 upvotes Code · 2 stars

Inference Paper

LatentGRM cuts reward-judge inference time by up to 7x

LatentGRM compresses evaluation trajectories by 8.9–9.2x and reduces judge inference time by 6.1–7.0x at vote@5, with competitive preference accuracy against explicit SFT judges. It shows how rubric-guided latent reasoning can lower the cost of model evaluation.

• WhatLatentGRM compresses rubric-guided evaluations into continuous trajectories for reward-judge pairwise judgments, with an interpreter reconstructing evaluation text.
• MethodAt 8B scale, it compresses evaluation trajectories by 8.9–9.2x and cuts total judge inference time by 6.1–7.0x at vote@5, with competitive preference accuracy.
• Why it mattersLower inference cost while preserving competitive judgment quality can benefit systems that need to run repeated reward evaluations.

Original · huggingface.co by Mingqing Yuan et al.10 upvotes Code · 1 stars

Inference Paper

PreSTO batches speculative proposals without changing PowerMH sampling

PreSTO batches prefetched Metropolis–Hastings proposals while preserving PowerMH's transition kernel, reporting median speedups of 1.71×, 1.91× and 2.33× across seven datasets and five base LLMs. The approach targets sequential sampling overhead without changing the sampler's behavior.

• WhatPreSTO accelerates PowerMH sampling by batching speculative proposals while leaving its Metropolis–Hastings transition kernel unchanged.
• MethodEach model call generates proposals for a prefetched subtree in one batch, then follows the realized path using the original acceptance rule.
• Why it mattersPreSTO reports median speedups of 1.71x on PowerMH, 1.91x on EntropyCut, and 2.33x on MultiTryMH across seven datasets and five base LLMs.

Original · huggingface.co by Nan Jiang et al.9 upvotes Code

Agents Paper

Mara Chain improves AI-system optimization by refining rejected candidates

Mara Chain retains and refines rejected prompts, skills, harnesses, or code instead of discarding them; across three optimization tasks it reports up to 20.5% relative improvement over named alternatives. Preserving failure information can reduce repeated mistakes in system-level agent tuning.

• WhatMara Chain refines rejected candidates during optimization of prompts, skills, harnesses, and code instead of discarding them.
• MethodIt uses evidence from prior attempts, limits each refinement chain to a fixed depth, and applies Pareto-filtered Top-N selection to bound the candidate pool.
• Why it mattersAcross three optimization tasks it delivered greater performance gains with fewer rollouts; on AppWorld it reached the target score with 65.5% fewer rollouts than GEPA.

Original · huggingface.co by Yubin Lyu et al.9 upvotes Code · 963 stars

Models & training Paper

LLM decompilers can hide behavioral changes behind passing tests

The paper reports that recompiled decompiler output can pass shipped tests yet diverge on other legitimate inputs, and can even remove a disclosed vulnerability without showing the crash. Engineers evaluating LLM-generated code need stronger checks than build success and narrow test suites.

• WhatLLM decompilers turn compiled machine code into clean C, but recompilability and shipped tests can miss changed behavior.
• MethodDecompile-Diverge synthesizes a driver, builds a fuzzing corpus from the reference, and reruns decompiled code on the same inputs.
• Why it mattersEngineers assessing decompiled code need behavioral checks: passing tests can hide changed behavior or erase a vulnerability's crash.

Original · arxiv.org 3 min read Lobsters 3 pts

Inference Paper

SoloQ enables calibration-free quantization for diffusion language models

SoloQ rotates weights and activations into a predictable distribution for data-independent low-bit quantization, and applies commit-time KV-cache quantization to block-diffusion models. Calibration-free deployment could simplify quantization where activations shift across denoising steps.

• WhatSoloQ is a calibration-free quantization framework for diffusion language models.
• MethodIt rotates and rescales weights and activations into a predictable distribution for low-bit quantization; block-diffusion models also get commit-time KV-cache quantization.
• Why it mattersThe approach targets lower inference and cache costs without requiring calibration data, addressing deployment challenges for dLLMs.

Original · huggingface.co by Donghyun Lee et al.30 upvotes

Agents Paper

Agent-skill copy networks reveal where security fixes fail to propagate

A dated network covering 2,193,119 skill adoptions finds that copied skills rarely change with their source; auditing the top 100 ranked repositories prevents 14.9% of later high-risk adoptions, versus 0.5% for the 100 most-starred. The findings offer concrete ways to prioritize agent-skill supply-chain reviews.

• WhatAgent skills are SKILL.md instructions and scripts run by coding agents with their users’ permissions, shared by copying across GitHub repositories.
• MethodGit history yields a dated copy network; copies rarely change with their source, so source fixes seldom propagate.
• Why it mattersA model-ranked audit of 100 repositories prevents 14.9% of later high-risk skill adoptions, versus 0.5% for the 100 most-starred repositories.

Original · huggingface.co by Fahd Seddik5 upvotes Code

Models & training Paper

Byte language models beat subword models at matched parameter counts

The paper reports lower optimal loss for raw-byte Transformers using token-superposition training and hash embeddings, and says they develop local text abstractions. The result challenges tokenizer assumptions with potential implications for model design and compute allocation.

• WhatByte language models process text directly as bytes, avoiding fixed external tokenizers but handling longer sequences.
• MethodWith token-superposition training and hash embeddings, flat byte Transformers outperform subword models as model size scales and learn local text abstractions.
• Why it mattersLearned boundary structure concentrates uncertainty, enabling speculative decoding to accept 3.4× more tokens than in subword Transformers.

Original · arxiv.org 71 min read Lobsters 6 pts

Agents Paper

AgenticBBO-Bench compares LLM optimizers across five domains

The unified finite-budget benchmark covers synthetic functions, hyperparameter tuning, database tuning, chip design, and molecular design; agents beat the best numerical optimizers in four domains. Its controlled comparisons help isolate which agent design choices matter for optimization.

• WhatAgenticBBO-Bench is a cross-domain benchmark for LLM agents doing black-box optimization under a unified finite-budget protocol.
• MethodIt covers synthetic functions, hyperparameter optimization, database tuning, chip design, and molecular design; agentic BBO beats direct LLM methods on family-averaged scores in all five.
• Why it mattersIts comparisons help engineers assess agent optimizers across tasks and examine choices such as tools, task information, and the LLM’s role.

Original · huggingface.co by Ming Chen et al.8 upvotes Code · 1 stars

Models & training Paper

Geometry-privileged distillation improves RGB-only spatial reasoning

GPD routes rendered depth, semantic, and bird’s-eye-view cues to a teacher during training, while the deployed model remains RGB-only; its 4B model scores 57.1 on VSI-Bench. This offers a concrete training approach for improving spatial reasoning without adding 3D inference inputs.

• WhatGeometry-Privileged Distillation (GPD) trains vision-language models for spatial reasoning while keeping the deployed model RGB-only.
• MethodIt routes rendered depth, semantic, and BEV cues to a teacher; privileged KL on incorrect trajectories augments GRPO.
• Why it mattersTraining with scanned-scene geometry without 3D inference inputs offers engineers a way to improve spatial reasoning without deployment-time 3D costs.

Original · huggingface.co by Hongxing Li et al.8 upvotes Code · 7 stars

Models & training Paper

Recurrent ViT matches full-depth accuracy with 70% fewer stored parameters

reViT programs a shared bank of FFN experts by recurrent depth; its from-scratch model matches DeiT III accuracy with about 70% fewer stored parameters. The distilled model also retains nearly all teacher linear-probe accuracy across several tasks.

• WhatreViT applies one Transformer block recurrently, matching a full-depth vision encoder’s accuracy at comparable inference FLOPs.
• MethodAt each recurrent depth, a normalized-depth coordinate programs a convex mixture of shared experts for the FFN transformation.
• Why it mattersIt achieves DeiT III accuracy with about 70% fewer stored parameters, and elastic-depth training supports multiple tested depths from one checkpoint.

Original · huggingface.co by Adrian Bulat et al.7 upvotes

Research Paper

Frontier models struggle to reproduce human ML innovation

InnovationEval tests whether models can independently devise ML techniques comparable to human work; the excerpt says recent models made little progress despite thousands of dollars in GPU experiments. The evaluation targets a key gap in claims about automating AI research.

• WhatInnovationEval tests whether AI can independently discover an ML technique matching a recent human-developed innovation.
• MethodThe tested frontier models made little progress, despite running experiments using thousands of dollars’ worth of GPU time.
• Why it mattersFor AI teams, the evaluation targets the full research loop—ideas, implementation, experiments and analysis—rather than isolated coding tasks.

Original · epoch.ai 62 min read HN 87 pts · 76 comments

Inference Paper

A corruption-lattice cost predicts the minimum steps for generative decoding

The paper models decoding schedules as paths on a corruption lattice and defines their cost by discarded dependence; for Markov data on a graph, zero-cost schedules require steps equal to the graph's treedepth. This offers a way to assess decoding schedules before running them.

• WhatThe paper represents diffusion, autoregression and hybrid generative models as paths on a corruption lattice, with schedule cost measuring dependence discarded by parallel steps.
• MethodFor zero-cost schedules, the minimum steps follow data geometry; for Markov data on a graph, the minimum equals the graph's treedepth.
• Why it mattersThe cost can rank decoding schedules before generation, helping engineers reason about step budgets for text, image and video models.

Original · huggingface.co by T. Y. Tsui et al.5 upvotes Code

Inference Paper

SpecFold reuses shared computation across diffusion-model draft branches

SpecFold uses token-level residual gating to reuse parent attention and FFN computation across speculative branches, with a Triton kernel for sparse execution and reported throughput gains. The algorithm-system co-design targets a distinct source of inference cost in diffusion language models.

• WhatSpecFold reduces multi-branch speculative verification cost in diffusion language models by reusing computation shared across draft branches.
• MethodIt gates residuals at token level, reuses parent computation through folded attention and FFN, and uses a Triton kernel for sparse multi-branch execution.
• Why it mattersThe approach targets branch-level redundancy and is described as compatible with existing speculation strategies and orthogonal to temporal caching.

Original · huggingface.co by Chung-En Ho et al.7 upvotes Code · 3 stars

Databases Paper

JSON tiles accelerate analytics on flexible JSON data

JSON tiles detect important keys, extract them for relational queries, and collect statistics for the optimizer while supporting changing schemas. The paper reports scan performance similar to columnar storage, a useful approach for semi-structured data systems.

• WhatJSON tiles let relational systems analyze flexible JSON data without losing its schema flexibility.
• MethodThey detect and extract important keys, handle heterogeneous or changing data, and collect statistics that help the query optimizer choose execution plans.
• Why it mattersThe method aims to bring JSON analytics closer to native relational speed without requiring a fixed schema upfront.

Original · db.cit.tum.de Lobsters 1 pts

Models & training Paper

OpenAI shares mathematical results and Lean proof formalizations

OpenAI reports results on open mathematics problems from an internal frontier model and shares Lean proof formalizations and research details on GitHub. The formalizations provide material for engineers interested in model-assisted reasoning and verification.

Original · openai.com

Models & training Paper

MiMo-V2.6 scales agentic reinforcement learning to 1M-token contexts

MiMo-V2.6 reports asynchronous RL steps consuming 1,568 samples and 2.7–3.7B tokens at contexts up to 1M, with diverse agent environments, groupwise grading and a frozen MoE router. Its training and stability choices offer concrete material for teams scaling model RL.

• WhatMiMo-V2.6 is an omni-modal model family that scales reinforcement learning compute toward model self-improvement.
• MethodTraining combines contexts up to 1M tokens, diverse agent environments, groupwise grading, and defenses including a frozen MoE router.
• Why it mattersUnified trajectories, high-concurrency rollouts, and decoupled control and data planes support mixed-task agentic RL at scale.

Original · huggingface.co by Core Team et al.60 upvotes

Agents Paper

Opera tracks whether coding-agent feedback actually resolves problems

Opera audits critic feedback against visible evidence, then follows the agent's actions to distinguish compliance from resolution; it raises resolve rates by up to 12.4, 15.0 and 8.9 percentage points on three benchmarks. This offers a concrete way to improve long-horizon agent critique.

• WhatOpera is a verbal critic that keeps corrections as persistent notes until it determines whether the diagnosed issue is resolved.
• MethodPeriodic or event-driven reviews diagnose with typed operators, audit feedback against visible evidence, and track later actions.
• Why it mattersOpera-guided rollouts improved Qwen3.5-9B's held-out SWE-Bench Pro resolve rate by 10.2 points without a critic at inference.

Original · huggingface.co by Kai Mei et al.8 upvotes Code · 1 stars

Agents Paper

REMORY adds learned memory tokens to compacted agent histories

REMORY appends bounded soft memory tokens to a summary; on SummHay it approaches the full-context joint score using 5.2% of input positions, and it reduces repeated tool outputs and errors on agent benchmarks. This offers a measured approach to context limits in long-running agents.

• WhatREMORY supplements a textual history summary with a bounded sequence of learned soft memory tokens for long-horizon agents.
• MethodConditioned on the summary, its network generates tokens appended after it to help a frozen LLM approximate full-history continuation.
• Why it mattersOn SummHay, it approached the full-context joint score using 5.2% of input positions; agent benchmarks also showed fewer repeated tool outputs and errors.

Original · huggingface.co by Hanchen Xia et al.5 upvotes Code · 2 stars

Inference Paper

MC-Sparse reuses attention metadata to speed diffusion transformers without visible quality loss

MC-Sparse groups similar queries for GPU execution and caches selected KV tokens and dense-to-sparse residuals across denoising steps; experiments report better dense-attention fidelity and larger speedups than sparse baselines. Its training-free approach targets the latency and quality trade-off in long-sequence generation.

• WhatMC-Sparse is a training-free framework for sparse attention in diffusion transformers, designed to retain fidelity at high sparsity.
• MethodIt groups similar queries, selects individual KV tokens, and reuses cached query groups, KV indices and residuals across denoising steps.
• Why it mattersThe paper reports faster denoising with negligible quality loss, including 1.80× speedup on Minimax-H3-Base and 2.32× for 3D asset generation.

Original · huggingface.co by Jiarui Chen et al.31 upvotes Code · 31 stars

Research Paper

A trial finds AI-assisted work improves judgment for senior patent attorneys, not juniors

In a three-month randomized trial, senior attorneys who routinely used AI showed stronger judgment, while junior attorneys had no average skill gain and a wider spread of scores. The results raise practical questions about AI’s effects on learning and expertise at work.

• WhatA three-month randomized trial of patent attorneys found AI assistance improved work quality across the board, but learning effects varied by seniority.
• MethodAfter 90 days, senior lawyers using AI showed stronger judgment than controls; junior lawyers had no average skill gain, with scores splitting higher and lower.
• Why it mattersAI builders should distinguish improved output from durable learning and evaluate effects across users’ experience levels.

Original · research.google 8 min read

Security Paper

ESauron detects hidden cameras through memory-generated electromagnetic signals

ESauron stimulates scene changes and detects the resulting electromagnetic patterns from camera memory activity to locate wired, wireless and offline spy cameras. The approach is a technically interesting example of sensing device behavior through side-channel emissions.

• WhatESauron is a proof-of-concept system for detecting and locating wireless, wired, and offline spy cameras.
• MethodScene changes increase video-processing workloads in camera memory, creating electromagnetic signals that ESauron senses to detect cameras.
• Why it mattersIt detected all tested cameras after four stimuli and can find cameras even when they are offline or blocked from view.

Original · usenix.org HN 110 pts · 26 comments

Research Paper

OuroWorld animates static 3D Gaussian splats into looping scenes

OuroWorld combines generated reference video with a periodic deformation field and grounded drift field to create looping motion in 3D scenes; it reports winning 70.8%–99.0% of user-study comparisons across 39 scenes. The method may interest engineers working on 3D generation pipelines.

• WhatOuroWorld turns static 3D Gaussian Splatting scenes into dynamic 3D cinemagraphs that loop from any viewpoint.
• MethodA vision-language model guides a video model to make a reference video, which is lifted and completed into multi-view videos.
• Why it mattersOn 39 scenes, OuroWorld outperformed all baselines and won 70.8%-99.0% of user-study comparisons.

Original · huggingface.co by You-Zhe Xie et al.34 upvotes Code · 36 stars

Research Paper

Longer context does not make LLMs reliably recover sequential rules

Controlled Rock–Paper–Scissors and n-gram experiments find that longer context does not improve strategy identification, recognition does not guarantee faithful simulation, and higher-order dependencies impair rule recovery. These results caution against treating behavioral imitation as evidence that a model learned the underlying process.

• What- A controlled study tests whether LLMs recover sequential rules in Rock–Paper–Scissors and stochastic n-gram tasks.
• Method- Longer context did not improve identification; correct recognition did not ensure faithful simulation, and higher-order dependencies worsened rule recovery.
• Why it matters- Behavioral simulations can look faithful while using incorrect generative mechanisms, a risk when building LLM agents or simulators.

Original · huggingface.co by Jerry Wang et al.11 upvotes

Inference Paper

LittleBit-2 uses latent geometry alignment for sub-1-bit LLM compression

LittleBit factorizes weight matrices into binary latent factors with learned scales; LittleBit-2 adds latent rotation and iterative quantization before quantization-aware training. The released implementation gives inference engineers a concrete extreme-compression approach to evaluate.

• What- LittleBit compresses LLMs below 1 bit per weight using factorized, binarized weight matrices and learned scales.
• Method- LittleBit-2 aligns SVD-derived latent factors to the binary hypercube with Joint-ITQ before quantization-aware training.
• Why it matters- Initialization-only changes let engineers target extreme compression without adding inference overhead or changing the deployed factorized layer.

Original · github.com 3 min read HN 83 pts · 23 comments

Agents Benchmark

TestPrism exposes a gap in coding-agent test quality

Across 300 tasks and 3,000 implementations, coding agents score 28.00% on a metric requiring tests to accept all valid solutions and reject invalid ones, versus 59.67% on single-reference success. TestHelix improves the stricter metric by 8.67–9.00 points, making this useful for agent evaluation.

Original · huggingface.co by Han Li et al.17 upvotes

Agents Paper

OneSearch-VL grounds multimodal research agents in an evidence graph

OneSearch-VL uses a visually grounded evidence graph to connect image and video anchors, retrieved facts and answer operations, with dedicated training data and benchmarks. This offers a concrete design for traceable tool use in multimodal research agents.

• What- OneSearch-VL is a multimodal research agent organized around a Visually Grounded Evidence Graph (VGEG).
• Method- VGEG supports data construction, process supervision, and operation-level evaluation; EVGR uses its annotations to supervise evidence traceability and visual grounding during RL.
• Why it matters- The paper reports OneSearch-VL-8B outperforming Qwen3-VL-8B with tool access on two new benchmarks, highlighting the value of grounding research operations in evidence.

Original · huggingface.co by Hongyu Li et al.10 upvotes Code · 2 stars

Agents Paper

ViSkill lets visual agents reuse and improve interaction skills

ViSkill stores successful interactions as visual skill cards, uses them for inference and reward shaping, then adds new successful trajectories back to the library. It reports 0.89 overall success, or 0.91 with cold-start initialization, offering a concrete skill-learning loop for agents.

• What- ViSkill encodes successful interactions as composite visual skill cards that VLM agents can retrieve and use.
• Method- Retrieved skills guide inference and reward shaping, while successful trajectories are distilled back into the library; an optional cold start accelerates early learning.
• Why it matters- The feedback loop lets engineers combine reusable visual interaction strategies with ongoing policy improvement.

Original · huggingface.co by Hongxing Li et al.8 upvotes Code · 2 stars

Architecture Paper

SparseEngine reports over 10× throughput with KV eviction

SparseEngine gives sparse attention methods a shared lifecycle contract and adds cross-request cache management; it reports over 10× throughput with KV eviction and over 2× end-to-end speedup on agent benchmarks. Its serving architecture and results are directly relevant to long-context inference systems.

• What- SparseEngine is a sparse-first inference engine with a shared lifecycle contract for methods using different KV representations and computations.
• Method- Chain Cache resumes KV-eviction methods from retained history, while Prefix-Cache Pruning removes KV from selected history regions and preserves logical-prefix matching.
• Why it matters- Shared serving infrastructure and cross-request state management help integrate varied sparse methods; the paper reports over 10x throughput with KV eviction.

Original · huggingface.co by Jitai Hao et al.7 upvotes Code · 79 stars

Agents Paper

Trace2Env reconstructs interactive agent environments from historical traces

The learning-free framework turns interaction traces into a worldbook and uses persistent episodic state to simulate observations and lasting effects; across nine environments it improves fidelity and long-horizon consistency. Replaying agent actions against real systems makes this relevant to agent training and evaluation.

• What- Trace2Env is a learning-free framework that turns historical interaction traces into a reusable environment worldbook.
• Method- At runtime, a world model agent consults the worldbook and persistent episodic state to infer observations and lasting effects of task-agent actions.
• Why it matters- The approach improves next-observation fidelity and long-horizon consistency, offering a way to simulate environments whose original systems are unavailable.

Original · huggingface.co by Quanyu Long et al.162 upvotes Code · 17 stars

Agents Paper

Self-Retrospection Distillation turns agent hindsight into foresight training targets

SRD distills lessons from completed trajectories into pre-interaction predictions, without requiring foresight generation at inference; across 10 tool-integrated and long-horizon tasks it reports gains of up to 24.2 percentage points. It offers a training signal when outcome rewards alone provide little contrast between rollouts.

• What- Self-Retrospection Distillation (SRD) uses post-hoc experience to train foresight predictions from the agent's pre-interaction view.
• Method- SRD distills useful knowledge and pitfalls from completed trajectories into trajectory-blind foresight targets that need not be generated at inference.
• Why it matters- The method can provide learning signal when rollout rewards are uniform; across 10 tasks, the paper reports gains of up to 24.2 percentage points.

Original · huggingface.co by Haoxiang Zhang et al.98 upvotes

Research Paper

Lean verifies an optimal packing of 11 squares with no admissions

The verification run accepted 7,920 Lean modules and reports zero admissions; selected exact numerical checks use native_decide, so the claim is not kernel-only. The proof and explicit trust boundary make this a concrete reference for formal verification workflows.

• WhatLean verifies the optimal packing of 11 squares with arbitrary orientations, legal boundary contact, and disjoint open interiors.
• MethodAll 7,920 local Lean modules passed; the audit found zero admissions, with selected exact numerical checks using native_decide.
• Why it mattersEngineers can inspect a formal optimality result while accounting for its stated trust in Lean's kernel and native compiler.

Original · github.com HN 115 pts · 53 comments

Agents Paper

RobotWorld tests multimodal agents across 84 tasks and five robot domains

RobotWorld evaluates agents across 84 tasks in manipulation, locomotion, driving, and other domains, finding that sophisticated perception and control workflows often fail to compose into task success. Its execution traces expose concrete gaps in agent reliability and recovery.

• WhatRobotWorld is a simulation testbed with 84 tasks across manipulation, mobile manipulation, locomotion, driving, and aerial control.
• MethodAgents build perception and control workflows, but traces show lost object states, ineffective actions, late recovery, and false completion.
• Why it mattersExecution traces and executable success checks can expose failures in composing agent capabilities, not just model reasoning.

Original · huggingface.co by Zhiqin Yang et al.23 upvotes Code

Agents Paper

SWE-Game benchmarks coding agents on 247 executable game tasks

SWE-Game evaluates agents on 247 tasks across 41 Godot games, using execution checks, replay, and feature demonstrations; the best construction-task scores remain below 60/100. Its task design and failure analysis provide a concrete way to assess coding-agent capabilities.

• WhatSWE-Game benchmarks coding agents on 247 tasks from 41 executable Godot games across 13 2D and 3D categories.
• MethodEvaluation combines engine-state checks, reference-input replay, agent demos, and visual rubrics; reviewed failures often omit requirements or contain logic errors.
• Why it mattersExecutable checks reached 92.59% balanced accuracy on human-labeled behaviors, versus 78.41% for a video-based VLM judge.

Original · huggingface.co by Xiaoyu Chen et al.22 upvotes

Agents Paper

WebFovea hardens the browser harness behind vision-based web agents

WebFovea reports a 57.0 challenge score and traces failures to harness issues including clicks shifted to three-quarters of intended coordinates and template-token contamination in 4.9% of episodes. These failure modes show where agent reliability work can matter beyond model reasoning.

• WhatWebFovea is a vision-based web agent built for live-site tasks requiring operation of the site's interface and a verifiable answer.
• MethodFailures can occur in parsing, page actions, result reporting, or information shown to the model; issues included coordinate mismatch and silent control failures.
• Why it mattersHardening the browser harness matters because capable model reasoning alone cannot ensure reliable end-to-end web actions.

Original · huggingface.co by Jiangang Han15 upvotes Code

Agents Paper

PhysEvo improves robot skills by revising tools and harnesses around a frozen model

PhysEvo uses task trajectories to let a meta-agent revise tools and skills around a frozen model; it reports 62% success across 42 RoboDojo tasks versus 47.17% for the cited one-shot agent. The approach explores iterative agent improvement without model-weight updates.

• WhatPhysEvo uses a task agent and meta-agent to improve robot manipulation around a single frozen model.
• MethodTrajectories guide the meta-agent to diagnose failures, revise tools and skills, and test corrections, including improvements to its diagnostic tools.
• Why it mattersPersistent, testable harness and skill revisions improve behavior without model-weight updates or a separately trained action policy.

Original · huggingface.co by Wenqing Tian et al.8 upvotes

Inference Paper

STEPQuant preserves recurrent-state accuracy at a nominal six-bit budget

STEPQuant assigns precision by error magnitude and memory lifetime, and fits scales to key-row and value-column effects; tests on Qwen3.8-27B and Kimi-Linear-48B-A3B-Instruct report accuracy close to FP32 at a nominal 6-bit budget. This targets recurrent-state memory costs in concurrent serving.

• What- STEPQuant is a post-training quantization framework for Delta-rule recurrent states in linear-attention models.
• Method- It allocates precision by error magnitude and memory lifetime, fitting key-row and value-column scales to state distributions and output impact.
• Why it matters- At nominal 6-bit, it closely matches FP32-state accuracy and compresses recurrent state over 5x, reducing serving memory by up to 68.7% in SGLang.

Original · huggingface.co by Bingchen Yao et al.81 upvotes Code · 83 stars

Inference Paper

GRACE compresses video latents while preserving compatibility with pretrained DiTs

GRACE retains a frozen base latent and learns a residual for information lost under stronger compression, while aligning compressed latents to the pretrained distribution. This targets faster video diffusion without requiring a DiT retrain.

• What- GRACE is a two-stage framework for compressing a pretrained video autoencoder while keeping it compatible with a pretrained DiT.
• Method- It retains a frozen base latent, learns a residual for information lost under compression, and aligns latents in the frozen DiT’s feature space.
• Why it matters- Preserving DiT compatibility can avoid retraining from scratch; GRACE then adapts the DiT with lightweight fine-tuning and asymmetric denoising.

Original · huggingface.co by Jiyoung Kim et al.54 upvotes Code · 12 stars

Research Paper

Lean verification cannot guarantee an AI-generated natural-language proof is sound

The paper argues that mechanically checking a Lean formalization does not establish that it faithfully represents the original natural-language proof. Engineers building AI verification workflows should treat translation fidelity as a separate problem from checking the formal result.

• WhatA paper argues that verifying an AI-generated Lean formalization does not establish that the original natural-language proof is correct.
• MethodIt describes semantic ambiguity as a barrier to faithful autoformalization and gives examples of mistranslations, including one involving a Navier–Stokes proof.
• Why it mattersEngineers should treat formal verification as checking the translated statement, not the source text, unless their semantic correspondence is established.

Original · arxiv.org 3 min read HN 296 pts · 181 comments

Models & training Paper

LoGRA cuts LLM RL training memory by up to 45.7%

LoGRA stores learning signals as low-rank gradient sketches and uses predicted-KL step control; it reports 45.7% lower average memory and stable 27B-model training for over 1,100 steps on one eight-GPU node. This could make RL post-training feasible where dense Adam runs out of memory.

• WhatLoGRA reduces RL post-training memory by retaining useful learning signals in low-rank gradient sketches.
• MethodThe sketches support model updates and policy synchronization; predicted-KL step control estimates policy changes and adjusts update magnitude.
• Why it mattersLoGRA cut average training memory by up to 45.7% and enabled stable training of a 27B-parameter model for over 1,100 steps on one eight-GPU node.

Original · huggingface.co by Shaokun Zhang et al.11 upvotes

Cloud & infra Paper

Perseus found 304 fail-slow cases across 248,000 drives and cut tail latency by 48%

Perseus uses a regression-based detector to identify drive-level fail-slow behavior; isolating detected drives reduced node-level 99.99th-percentile tail latency by 48%. The authors also released a production-derived dataset for studying storage degradation.

• WhatPERSEUS detects fail-slow failures in storage drives with a light regression-based model.
• MethodOver 10 months monitoring 248K drives, it found 304 fail-slow cases; isolating them reduced node-level 99.99th tail latency by 48%.
• Why it mattersDrive-level detection and isolation can protect storage tail latency from devices that still function but perform poorly.

Original · usenix.org by usenix.org via typesanitizer

Models & training Paper

Top-16 shared-token supervision matches full cross-tokenizer distillation

Across three teacher–student pairs, strict token alignment covers most student tokens, and reverse-KL supervision on a student-selected top-16 shared-vocabulary subset matches full shared-vocabulary OPD accuracy. The result suggests a simpler, more reliable supervision path for distillation across tokenizers.

• WhatOn-Policy Distillation trains a student on its own generations using teacher feedback, requiring alignment across different tokenizers.
• MethodStrict 1:1 positions with a student-selected top-16 shared-vocabulary subset achieved accuracy comparable to full shared-vocabulary OPD.
• Why it mattersFor tokenizer-mismatched distillation, broader alignment coverage is not necessarily better; selective supervision may be more reliable.

Original · huggingface.co by Bingxi Hou et al.40 upvotes

Agents Paper

SafeActBench finds evidence gaps before tool-using agents execute actions

Across ten model-harness configurations, agents often act before establishing required evidence, and multi-action workflows also miss prerequisites or steps; SafeActBench includes 656 cases across six operational domains. Its evidence ledger and trajectory evaluator provide concrete tools for testing agent action safety.

• WhatSafeActBench studies how tool-using agents establish evidence before changing external state.
• MethodA provenance-bound Evidence Ledger and deterministic trajectory evaluator track established information, action timing, and downstream dependencies.
• Why it mattersAgents can fail before execution by acting without required evidence, or later through unresolved prerequisites and incomplete workflows.

Original · huggingface.co by Hongzhan Lin et al.21 upvotes Code · 3 stars

Agents Paper

PrisMem evolves agent memory by optimizing individual capabilities

PrisMem selects memory revisions by capability, then integrates complementary changes using paired differential cases; it reports gains of 10.54 and 7.83 percentage points on BEAM-1M and LongMemEval-M. The approach addresses how to improve agent memory without hiding regressions behind aggregate scores.

• WhatPrisMem evolves executable agent memory programs by optimizing individual capability dimensions rather than overall performance alone.
• MethodDependency-aware selection, history-guided diagnosis, and trace-guided integration target capabilities and combine complementary gains.
• Why it mattersPrisMem exceeded the strongest baselines by 10.54 and 7.83 percentage points on BEAM-1M and LongMemEval-M, respectively.

Original · huggingface.co by Yaoqi Chen et al.11 upvotes

Agents Paper

Agentic retrieval gains 8.7 nDCG points but takes 107.4 seconds per query

A ReAct retrieval pipeline improves nDCG@10 by 8.7 points over standard retrieval with the same embedding model, but averages 107.4 seconds and 764.1K input tokens per query. The measured quality-cost tradeoff is useful when deciding whether agentic search fits a production retrieval path.

• WhatAgentic retrieval combines LLM reasoning with retrievers in a ReAct loop to handle complex search tasks.
• MethodIt improved nDCG@10 by 8.7 points and performed competitively on ViDoRe v3 and BRIGHT, but took 107.4 seconds per query versus 0.67 seconds for standard retrieval.
• Why it mattersIts quality and generalization gains come with substantial latency and token costs, a key tradeoff for large-scale deployment.

Original · huggingface.co by Reza Esfandiarpoor et al.8 upvotes

Agents Paper

LLMs can make typed decisions directly from next-token probabilities

LLM-as-Jev reads calibrated choices from probabilities over numeric identifiers and adds a listwise fine-tuning objective; the untrained Qwen3.5-4B matches community models on the same backbone and supports multimodal decisions. This provides a direct decision interface for agent workflows without free-form generation.

• What- LLM-as-Jev investigates LLMs as decision models that return categorical probability distributions over predefined options.
• Method- Its framework extracts decisions from next-token probabilities over bracketed numeric IDs; fine-tuning uses listwise loss and KL penalties.
• Why it matters- The authors find strong models can decide without training, while targeted fine-tuning helps weaker models and tasks without degrading conversational behavior.

Original · huggingface.co by Yinheng Li, Justin Wagle8 upvotes

Research Paper

Bidirectional type slicing finds minimal code explanations for type information

The paper formalizes slices that explain synthesized or expected types, proves every query has a minimal slice, and shows that refining a query monotonically shrinks it. The exact and approximate methods could inform better explanations in programming tools.

• WhatBidirectional type slicing produces a well-formed partial program that explains a queried part of an expression's type information.
• MethodSynthesis slices explain a term's inferred type; analysis slices explain the type expected by its context. Every query has a minimal slice.
• Why it mattersMinimal slices give development tools a compact explanation of why an expression has its type.

Original · arxiv.org Lobsters 20 pts · 3 comments

Research Paper

New algorithms give polynomial speedups for 3SUM and APSP

The paper reports deterministic runtimes of O(n^1.9992) for 3SUM and O(n^2.9995) for APSP, refuting their standard complexity hypotheses. It is a notable theoretical result, though the excerpt does not establish practical gains on real workloads.

• WhatA paper presents deterministic algorithms for 3SUM in O(n^1.9992) time and APSP in O(n^2.9995) time for specified integer inputs.
• MethodBoth results derive from a new thin-matrix-product algorithm that computes selected entries, then reductions connect it to sparse triangle problems.
• Why it mattersThe work shows how matrix and graph algorithm advances can improve theoretical bounds for core computational problems.

Original · arxiv.org 3 min read HN 102 pts · 45 comments

Models & training Paper

Fixed-point training improves looped models and speeds prefill and RL updates

The work uses learned depth priors and orthogonal input injection to improve perplexity across 100M–1.6B models, and reports 1.79× faster student prefill and 2× faster RL updates. Its fixed-point analysis connects model architecture choices to training and inference costs.

• WhatFixed-point training tunes looped language models to reduce recurrence costs across training, decoding, prefill, and reinforcement learning.
• MethodA learned depth prior and orthogonal input injection lower perplexity across tested scales; fixed points enable truncated backpropagation and terminal KV sharing.
• Why it mattersFor model builders, the approach enables KV sharing with almost no accuracy loss, prefill up to 1.79× faster, and RL gradient updates 2× faster.

Original · huggingface.co by Benhao Huang et al.7 upvotes Code · 29 stars

Models & training Paper

Dust uses token-level activation perturbations to train transformers without backpropagation

Dust perturbs activations independently at each token; the authors report competitive results against backprop and estimate 1,000–10,000× greater efficiency than EGGROLL from one million tokens onward. The method and scaling results make it worth watching for teams exploring alternatives to standard training.

• WhatDust is a zeroth-order method for pretraining transformer language models without backpropagation.
• MethodIt independently perturbs activations at every token, treating each token as a virtual population member evaluated in parallel in one forward pass.
• Why it mattersFor AI training systems, Dust offers a backprop alternative that is orders of magnitude more efficient than weight-space ES in the reported comparison.

Original · qlabs.sh 27 min read HN 162 pts · 40 comments

Agents Paper

OSWorld-Pro evaluates computer-use agents across subgoals and action failures

OSWorld-Pro provides over 300 tasks, 2,800 subgoals, and 67,000 human annotations; its top model scores 75.7% versus 83.4% on OSWorld. Process-level evaluation can expose whether agents fail on inputs, clicks, or other steps rather than only judging final deliverables.

• WhatOSWorld-Pro evaluates computer-use agents through over 2,800 subgoals across more than 300 tasks.
• MethodHuman annotations ground LLM judges that score subgoal fulfillment, exposing progress and process-level failures such as irrelevant actions and click mistakes.
• Why it mattersEngineers can use its subgoal-level failure signals to target improvements instead of relying only on final task outcomes.

Original · huggingface.co by Zhilin Wang et al.7 upvotes

Models & training Paper

A PI controller steers diffusion language models toward targeted answers

The attack adjusts activation-steering strength during denoising; on ambiguous BBQ questions, it raises preference for a targeted group from 1.8 to 16.7 percentage points. Engineers working with diffusion LMs should account for their repeated exposure to intermediate predictions.

• WhatA targeted-bias attack steers a frozen masked diffusion language model toward an answer selected by an adversary.
• MethodDuring denoising, a PI controller tracks target-answer probability and adjusts steering-vector strength; on BBQ, target preference rose from 1.8 to 16.7 percentage points.
• Why it mattersBecause answers remain revisable across denoising steps, model builders must consider attacks that adapt activation interventions before token commitment.

Original · huggingface.co by Sarim Hashmi et al.6 upvotes Code

Inference Paper

LoHi improves long-video VLM accuracy by balancing frame resolution and coverage

LoHi combines dense low-resolution video with sparse high-resolution frames, improving average accuracy by 10.6 percentage points across three benchmarks; the study also finds front-end decoding dominates hour-long video wall time. This offers concrete guidance for trading visual detail against temporal coverage and latency.

• WhatLoHi is a training-free, single-pass framework for long-video VLMs that combines dense low-resolution video with sparse high-resolution frames.
• MethodDense low-resolution sampling beats sparse native-resolution sampling at matched token budgets, while front-end decoding dominates hour-long video wall time.
• Why it mattersLoHi improves average accuracy by 10.6 percentage points over the native-resolution baseline at a matched token budget and cuts decoding latency by up to 7× on hour-long videos.

Original · huggingface.co by Sixun Dong et al.8 upvotes

Inference Paper

RealtimeWAM overlaps video and action inference and generates actions in one step

RealtimeWAM combines one-step action generation, teacher-anchored consistency distillation, and asynchronous cross-expert pipelining with shared video KV cache. These techniques target iteration and waiting overheads in action-model inference.

• WhatRealtimeWAM is a World Action Model that generates actions in one step and runs video and action inference asynchronously.
• MethodTeacher-Anchored Consistency Distillation supervises one-step actions; Cross-Expert Wavefront Pipelining shares video KV-cache blocks between experts.
• Why it mattersReducing action iterations and expert waiting targets the inference-efficiency bottlenecks of WAMs.

Original · huggingface.co by Chengtao Lv et al.6 upvotes Code · 2.9K stars

Models & training Paper

Khanmigo trial finds modest math gains comparable to Khan Academy practice

A two-year randomized trial across 18 Tennessee middle schools found small achievement gains, similar to Khan Academy practice without AI; students used the tutor infrequently. The usage data cautions against assuming access to an AI tutor leads to sustained engagement.

• WhatA two-year cluster-randomized trial in 18 Tennessee middle schools tested Khanmigo as a coach in daily remedial math sessions.
• MethodAssignment raised math achievement by 1.3 percentile ranks per term, with gains comparable to Khan Academy practice without AI.
• Why it mattersStudents tried Khanmigo but used it infrequently, suggesting that engagement—not just access—is a key constraint for AI tutoring.

Original · edworkingpapers.com HN 61 pts · 55 comments

Research Paper

Tail-Influence Sampling allocates rollouts to improve CVaR estimates

Tail-Influence Sampling estimates which conditional components most affect policy CVaR, then reallocates evaluation queries; on CliffWalking it reduces MSE by 41% versus learned occupancy and 76% versus a comparison method. The method offers a principled way to spend limited rollout budgets on rare failures.

• WhatTail-Influence Sampling (TIS) allocates a fixed evaluation budget to estimate a policy’s lower-tail CVaR.
• MethodTIS estimates tail-influence scales from a pilot model and directs fresh queries to the kernels that matter most to the tail.
• Why it mattersIt helps engineers evaluate rare-failure risk with costly rollouts instead of relying on mean returns alone.

Original · huggingface.co by Pauline Bourigault et al.21 upvotes Code · 1 stars

Agents Paper

LLM agents favor certain sources even when their items fit worse

Across 12 models and three domains, agents sometimes choose an item that meets one fewer requirement about two-thirds of the time when it comes from a preferred source; hiding or relabeling the source changes selection. The results expose a measurable bias in end-to-end search decisions that agent evaluations should account for.

• WhatA study measures source preference in end-to-end search across 12 agent models and three domains.
• MethodAgents often selected an item satisfying one fewer requirement when it came from a preferred source; hiding or relabeling source identity changed choices.
• Why it mattersAI search and recommendation systems can favor a source over a better-fitting item, so source identity is a relevant factor to test.

Original · huggingface.co by Jonghyun Song et al.14 upvotes

Agents Paper

Recursive self-rewrite turns harness-specific solutions into training trajectories

RSR uses a planner, critic and executor to convert successful solutions from diverse harnesses into trajectories for a general harness; fine-tuning raises pass@3 on Terminal-Bench 2 from 57.0% to 74.2%. The results show how harness-generated experience can improve a base model across terminal tasks.

• WhatRecursive Self-Rewrite reconstructs successful solutions found under specialized harnesses as training trajectories for a general harness.
• MethodA planner extracts runbooks, a critic screens and revises them, and an executor follows qualified runbooks in fresh sandboxes.
• Why it mattersThe approach turns harness-assisted task solutions into reusable supervised training data for models.

Original · huggingface.co by Zongxia Li et al.13 upvotes

Agents Benchmark

EditHero tests agents on long sequences of part-level 3D edits

EditHero evaluates long edit sequences against deterministic targets; compared with top-down methods, LLM/VLM agents follow instructions more closely and preserve untouched parts, but each edit takes minutes. The benchmark and planned release of its engine and sequences target reliability in iterative agent workflows.

• WhatEditHero is a benchmark for long-horizon, part-level 3D editing with natural-language instructions and target images.
• HowA deterministic assembly engine produces the exact target after each edit; tested LLMs preserved unedited parts better, but each edit took minutes.
• Why it mattersIt tests whether editing agents can make requested changes across revisions without disturbing parts that should remain unchanged.

Original · huggingface.co by Ruihan Yu et al.6 upvotes Code · 1 stars

Agents Benchmark

SimuVerity tests whether generated Simulink models meet engineering requirements

The benchmark evaluates 101 tasks across ten domains with native simulation scenarios and a hierarchical evaluator; the best of six agent systems scores 42.86 overall. It tests engineering qualification and behavior rather than treating compilation or structural similarity as proof of correctness.

• WhatSimuVerity benchmarks agents generating executable Simulink models against engineering requirements across 101 tasks in ten domains.
• HowA hierarchical evaluator checks artifact delivery, native executability, and engineering qualification before scoring qualified models across six dimensions.
• Why it mattersIt exposes gaps that compile checks and structural similarity miss, helping engineers assess whether generated models meet multidimensional requirements.

Original · huggingface.co by Ruiqi Zhang et al.5 upvotes Code · 2 stars

Models & training Paper

Distillation study finds KL direction and learning rate outweigh rollout policy

In controlled distillation experiments across Llama 3 and Qwen2.5, KL direction more clearly affects performance and output coverage, while learning rate governs forgetting and update sparsity. These results challenge assumptions about when on-policy training is necessary.

Original · huggingface.co by Julianna Piskorz et al.176 upvotes

Agents Paper

X-Tree trains agents on reusable hierarchies mined from action traces

X-Tree merges reusable action spans into a skill hierarchy and applies it to offline RL, online RLVR, and self-distillation; the excerpt reports gains across three benchmarks. The method aims to make agents generalize from trajectories rather than rely on retrieved, in-context skills.

• WhatX-Tree mines reusable hierarchies from action data and uses them to train multi-step agents, without LLM calls to write skills.
• MethodIt scores action spans for reusability, merges canonicalized actions into a tree, and integrates that structure into offline RL, online RLVR, and on-policy self-distillation.
• Why it mattersTraining on reusable sub-procedures can make better use of scarce trajectories and improve agent generalization across tasks.

Original · huggingface.co by Sitao Cheng et al.65 upvotes Code · 2 stars

Performance & OS Paper

SELF compiler customization doubled performance for a dynamic language

The compiler specializes procedures by receiver type, predicts likely types with runtime checks, and combines the approach with inlining and other optimizations; the abstract reports doubled performance. The techniques offer a concrete reference for optimizing dynamic-language runtimes.

• WhatThe SELF compiler customizes procedures for dynamically typed object-oriented programs to improve their performance.
• MethodIt predicts likely types, checks them at runtime, and compiles specialized procedure copies for different receiver types and control paths.
• Why it mattersThe techniques show how runtime checks and specialization can recover performance when programs lack static type information.

Original · dl.acm.org Lobsters 5 pts

Models & training Paper

DARA weights LLM rewards by how often each reward is active

DARA applies an inverse-square-root correction based on each reward’s active-group density; experiments report faster learning on tool calling and mathematical reasoning. The batch-adaptive method addresses imbalanced signals in multi-objective model training.

• WhatDensity-Aware Reward Aggregation (DARA) adjusts reward contributions in multi-reward reinforcement learning for language models.
• MethodIt relates advantage energy to active-group density and applies an inverse-square-root density correction, with weights computed from each rollout batch.
• Why it mattersIn experiments, DARA reached high format and length compliance in fewer training steps than GDPO, helping balance uneven reward learning progress.

Original · huggingface.co by Tong Zheng et al.50 upvotes Code · 2 stars

Agents Paper

Strict tool-call checks expose false positives in small-model benchmarks

Two models score similarly on lenient tool-use metrics, but verbatim checks find valid generalized calls in 6/6 examples for one and 0/6 for the other; targeted SFT raises the latter’s valid emissions from 0.100 to 0.959 on corpus rows. The diagnostic ladder and repair recipe are directly useful for evaluating tool-using models.

• WhatThe study finds that keyword-matching benchmarks can falsely credit small language models for tool use they do not perform.
• MethodVerbatim reproduction checks and a first-token probe expose a tool-call failure; targeted supervised fine-tuning repairs it, with gains on corpus rows and unseen prompts.
• Why it mattersStrict, cheap diagnostics can help engineers distinguish genuine tool-use capability from benchmark false positives in small models.

Original · huggingface.co by Juan S. Santillana5 upvotes

Inference Paper

HeteroFold transfers KV caches across model families without prefill

HeteroFold maps and calibrates a frozen sender's KV cache for a frozen receiver, handling differences in tokenization and model structure. At 32K context, one reported transfer is 10.7 times faster than native prefill and 1.18–1.47 times faster than prior prefill-free baselines.

• What- HeteroFold transfers KV caches across model families without requiring receiver prefill, while keeping sender and receiver models frozen.
• Method- It aligns model structures, maps the sender cache into the receiver space, and calibrates it to preserve receiver behavior.
• Why it matters- At 32K context, one reported transfer was 10.7 times faster than Native Prefill, reducing redundant work in multi-agent systems.

Original · huggingface.co by Vincent-Daniel Yun et al.7 upvotes

Inference Paper

Jev cuts edge-orchestration decision latency 22.7–64.5% versus LLMs

Across 8,280 requests and a live admission path, Jev reduces median decision latency versus the fastest LLM, with lower fees on four-field contracts but some exact-match loss. The comparison gives engineers concrete trade-offs when choosing models for latency-sensitive orchestration.

• What- Jev’s decision API replaces LLM decisions in edge service orchestration to reduce request-time overhead while retaining service completion.
• Method- It extracts four to eight bounded intent fields, then applies a shared validator, admission policy, and scheduler.
• Why it matters- Across 33 test conditions, it cut median decision latency 22.7–64.5% versus the fastest LLM, helping preserve latency budget at the edge.

Original · huggingface.co by Delong Li et al.5 upvotes Code

Inference Paper

Parallel Power Tempering balances exploration and exploitation in LLM sampling

PPT runs interacting sampling replicas at different sharpening levels, letting lower-power chains explore while higher-power chains exploit likely responses. The work also addresses truncation bias and studies swap strategies under finite compute and memory budgets.

• WhatParallel Power Tempering applies power-sharpened sampling at inference time using parallel tempering, without parameter updates or external rewards.
• MethodInteracting replicas at different sharpening levels let lower-power replicas explore trajectories and higher-power chains exploit likely responses.
• Why it mattersExperiments report improvements over single-chain power-sharpened sampling and RL-post-trained models, offering an alternative to costly RL optimization.

Original · huggingface.co by Panagiotis Theodoropoulos et al.7 upvotes

Research Benchmark

ScholarCatalyst finds agentic search trails embedding retrieval on expert judgments

The benchmark uses judgments from 184 lead authors across 207 papers; agentic search reaches 0.42 Recall@20 versus 0.48 for embedding retrieval, while a stronger agent reaches 0.51. It gives engineers a grounded test of whether research agents add value over retrieval tools.

• What- ScholarCatalyst is a benchmark for retrieving papers that could have advanced a research project, based on author-provided judgments.
• How- It uses labels from 184 lead authors across 207 papers; agentic search scored 0.42 Recall@20 versus 0.48 for embedding retrieval.
• Why it matters- The results point to a need for training that gives scientific agents expert intuition for searching broad research corpora.

Original · huggingface.co by Sohyeon Kim et al.9 upvotes

Inference Paper

LoopCD improves looped-transformer scores while cutting recurrent compute

Training-free LoopCD raises Ouro-2.6B-Thinking AIME 2024 pass@1 from 61.88% to 73.33% and cuts forward FLOPs by 22.5–48.2% when fewer loops suffice. It turns intermediate recurrent predictions into a decoding signal that can improve quality and reduce inference compute.

• WhatLoopCD is a training-free contrastive decoding framework for looped Transformers.
• MethodIt contrasts the final prediction with an earlier recurrent pass, using logits or hidden states to guide token selection.
• Why it mattersIt can halve recurrent loops while matching or exceeding full-depth unguided baselines, cutting forward FLOPs by 22.5%–48.2%.

Original · huggingface.co by Weihao Liu et al.19 upvotes

Models & training Paper

A rank-8 LoRA raises Qwen3-8B accuracy from 15.5% to 99% on 24-line chains

A task-trained rank-8 LoRA at one early layer raises Qwen3-8B exact accuracy from 15.5% to 99% on 24-line chains, with model weights frozen; code and a demo are available. The result shows how a small targeted edit can unlock computation that pretrained models fail to use by default.

• WhatA task-trained rank-8 LoRA at one early layer extends pretrained transformers' ability to follow references across long chains.
• MethodWith model weights frozen, Qwen3-8B exact accuracy on 24-line chains rises from 15.5% to 99%; the LoRA relays chain identity through middle layers.
• Why it mattersDefault answers can understate the computation accessible through a small task-specific edit.

Original · huggingface.co by Zehao Jin et al.54 upvotes Code · 2 stars

Agents Paper

PyRUA-Lean raises robot-agent success while using fewer tokens

PyRUA-Lean lets agents compose robot primitives and VLA policies into Python cells with local retries and selective observations; it raises success from 63.1% to 71.7% while using 65% fewer input tokens. The design shows how execution between model calls can improve agent efficiency.

• WhatPyRUA-Lean is a code-execution framework for robot agents that reduces repeated model calls and redundant observations.
• MethodIt composes robot primitives and VLA policies into Python cells with checks and retries, returning requested images and state for replanning.
• Why it mattersAt equal LLM-call budgets, it raises overall success from 63.1% to 71.7%; on jointly solved tasks it uses 65% fewer input tokens.

Original · huggingface.co by Ruiyang Si et al.26 upvotes Code · 17 stars

Agents Paper

Argo-Bench tests data agents on a 7.5-billion-row enterprise warehouse

Argo-Bench defines 210 analytics tasks in a simulated 235-table, 7.5-billion-row warehouse, with ground truth withheld and tasks requiring agents to act on findings. It targets a gap between text-to-SQL tests and end-to-end enterprise workflows.

• WhatArgo-Bench evaluates data agents on 210 enterprise-style analytics and data-science tasks.
• MethodIt simulates a NYC food-delivery business in a 235-table, 7.5-billion-row ERP warehouse, then grades agent actions by simulator consequences.
• Why it mattersIts warehouse-scale, action-based evaluation tests more than SQL generation, exposing agents to cross-table reasoning and operational decisions.

Original · huggingface.co by Gabriel Tomitsuka et al.18 upvotes Code · 3 stars

Models & training Paper

Omni-Embed-Mini adds modalities without changing text embedding weights

The 0.9B-parameter model aligns text, speech, audio, images, video and documents while keeping text weights bit-identical; it reports 49.57 nDCG@10 on MTEB-v2 BEIR-8. The distillation recipe offers a practical route to multimodal retrieval without regressing the text encoder through training.

• WhatOmni-Embed-Mini maps text, speech, audio, images, video, and visually rich documents into one shared cosine space.
• MethodIt freezes text-side weights and aligns modality encoders with lightweight projectors and phased LoRA adapters, using frozen-backbone caption embeddings as teacher targets.
• Why it mattersBit-identical text weights prevent training from regressing text retrieval while extending the model to five additional modalities.

Original · huggingface.co by Mohammed Irfan Kurpath et al.15 upvotes Code · 3 stars

Inference Paper

AgSpec adapts retrieval-based speculative decoding to coding agents

AgSpec retrieves drafts from session, workspace and global corpora, then adapts draft length using verification feedback; it reports up to 4.37× throughput at batch size 1 and 4.76× at batch size 16. The results show how agent-specific context and acceptance behavior can improve inference speed.

• WhatAgSpec adapts retrieval-based speculative decoding to coding-agent pipelines with agent-specific corpora and draft-length policies.
• MethodIt retrieves from session, workspace, and global corpora; offline caps and verification feedback set draft lengths and adapt them online.
• Why it mattersOn two repository-level multi-agent coding benchmarks, it raises throughput over autoregressive decoding up to 4.37× at batch size 1 and 4.76× at batch size 16.

Original · huggingface.co by Sumin Lee et al.7 upvotes

Models & training Paper

Google shifts federated-learning computation to servers for verifiable privacy

Google describes a federated-learning system with externally verifiable privacy guarantees that shifts computation to servers to improve training speed, accuracy, and device coverage. The design trade-off matters to teams building private training systems, though the excerpt gives no quantitative results.

• What- Google’s new federated-learning system uses trusted execution environments to provide externally verifiable privacy guarantees while shifting computation to servers.
• Method- Clients encrypt and upload examples under pre-authorized access policies; a TEE-based KMS releases keys only to matching workloads.
• Why it matters- The system aims to improve training speed, accuracy, and device coverage; Gboard has adopted it and reports faster compute times.

Original · research.google 7 min read

Agents Paper

Context language models edit context files and outperform management baselines

The method treats context as an editable file; zero-shot CLMs report 11.4% higher accuracy with 21.5% fewer FLOPs on BrowseComp-Plus, with gains on two long-horizon benchmarks. This offers evidence for an alternative to hand-designed context management in agents.

• WhatContext Language Models (CLMs) manage their own context by treating it as a file the model can update.
• MethodThe paper reports CLMs outperforming context-management baselines and describes natural-language steering and online reinforcement learning.
• Why it mattersMoving context management into model behavior can reduce reliance on external harness control and let models learn context-management strategies.

Original · arxiv.org 3 min read HN 139 pts · 29 comments

Agents Paper

PoS maintains explicit belief states and detects stalled agent progress

The inference-time framework tracks world state and unresolved requirements, validates belief consistency, and triggers recovery when it detects Belief Trapping. It reports the highest overall performance across four benchmarks and three LLM backbones, offering a concrete approach to long-horizon agent control.

• WhatPoS is an inference-time framework that maintains explicit belief states combining an estimated world state with unresolved task requirements.
• MethodIt validates belief consistency, monitors progress for Belief Trapping, and tailors recovery to the trapping pattern and unresolved requirement.
• Why it mattersPoS reports top overall performance on four benchmarks across three LLM backbones and resilience as context grows.

Original · huggingface.co by Yu Luo et al.31 upvotes Code · 7 stars

Agents Paper

Post-training can reduce an agent’s solution coverage despite improving pass@1

Across 14 base and post-trained model pairs, the study finds that post-training can improve sampling efficiency while narrowing solution coverage under larger test-time budgets. Its Sharpening Tax measures that trade-off for agentic tasks, informing model and inference-budget choices.

• WhatThe study finds that post-training can improve an agent’s pass@1 while reducing solution coverage under test-time sampling.
• MethodPost-training pushes tasks toward two extremes—always solved or never solved—improving sampling efficiency and consistency at the cost of coverage.
• Why it mattersSharpening Tax measures lost test-time scalability and, the paper reports, can be estimated from a few rollouts.

Original · huggingface.co by Changdae Oh et al.29 upvotes Code · 1 stars

Agents Paper

GraphForge grounds agent tasks and verifiers in real workspace files

GraphForge builds evidence graphs from real files to generate verifiable tasks, then uses a rollout and revision agent to check them; fine-tuning Qwen3.6-27B on 2,169 trajectories raises GDPVal by 65.7 under OpenHands. This offers a concrete data-generation approach for training work agents.

• WhatGraphForge synthesizes working-agent tasks and verifiers grounded in real workspace files through an evidence graph.
• MethodIt assembles files, derives task statements and rubrics from the graph, tests executability in an initial rollout, and uses a revision agent to repair them.
• Why it mattersThe pipeline provides a way to train agents on diverse file-based tasks with requirements and verification criteria anchored to source files.

Original · huggingface.co by Qisheng Su et al.18 upvotes

Models & training Paper

HC-DLM couples token readouts to a persistent continuous diffusion state

HC-DLM reads tokens from a shared latent at each denoising step and feeds them back as a scaffold, with training derived from a variational bound on token likelihood. The design targets the dependency loss of parallel discrete diffusion, though the excerpt gives no results.

• WhatHC-DLM couples discrete token generation with a continuous latent trajectory in one denoising process.
• MethodTokens are read from the latent at each step and feed back as a scaffold for its next update; the latent is the only persistent generative state.
• Why it mattersAt matched model size, it improves over discrete and continuous diffusion baselines on Sudoku, Countdown, and LM1B.

Original · huggingface.co by Hui Ren et al.47 upvotes Code · 1 stars

Models & training Paper

Distilled T5Gemma-2 embeddings create a more connected diffusion space

The work distills teacher token probabilities into an encoder that pulls plausible alternative-word embeddings closer together, aiming to reduce invalid outputs from imperfect sampling. Embedding geometry is a practical design choice for teams building continuous diffusion language models.

• WhatScaling embeddings from T5 to T5Gemma-1 to T5Gemma-2 improves continuous diffusion language model generation, but raw T5Gemma-2 embeddings remain too discriminative.
• MethodA student encoder learns the teacher's decoded probabilities as soft labels, pulling plausible alternative-word embeddings closer together.
• Why it mattersThe distilled space improves diffusibility; a medium-sized DLM reaches Gen. PPL 17.8 at real-text entropy on OpenWebText, outperforming GPT-2-M.

Original · huggingface.co by Zekai Zhang et al.16 upvotes Code · 2 stars

Research Paper

BeyondSCe uses event history and active views to grasp occluded targets

The zero-shot robot system combines interaction history with scene geometry to identify grasp targets and choose camera views; reported success reaches 77% for initially occluded targets versus a 55% baseline. Its results show how memory and active sensing can work together in embodied systems.

• WhatBeyondSCe is a zero-shot robotic grasping system for requests that refer to objects by their role in past events.
• MethodIt combines event history with the current scene; for occluded targets, it selects camera viewpoints using event priors and scene geometry.
• Why it mattersThe approach lets robots localize and grasp occluded targets without task-specific training.

Original · huggingface.co by Hyunjoon Lee et al.17 upvotes Code · 4 stars

Models & training Paper

UniEvo-VL uses self-critique distillation to improve image generation

A single multimodal model serves as teacher and student, distilling critiques across its own sampling trajectories; on Qwen-image-2512, GenEval rises from 0.747 to 0.808 and GenEval2 Soft-TIFA from 32.97 to 35.53. The recipe offers measured evidence for self-distillation without a separate teacher.

• WhatUniEvo-VL uses one multimodal model as both teacher and student, with different contexts for each role.
• MethodThe student sees the vanilla question; the teacher conditions on a privileged critique, and training minimizes divergence over the student's sampling trajectories.
• Why it mattersThe recipe improves image generation while preserving sensitivity to reflection information, offering a way to train without a separate teacher.

Original · huggingface.co by Fang Wu et al.76 upvotes

Agents Paper

EvoDuet co-evolves search queries and solutions for optimization tasks

The method alternates between refining web searches and generating solution candidates, improving discovery gain on two model-and-scaffold combinations and surpassing prior best scores on eight tasks. Its results offer a concrete way to make retrieval adapt as an agent’s solution changes.

• WhatEvoDuet co-evolves search queries and candidate solutions for optimization tasks while keeping model parameters fixed.
• MethodA retrieval gate chooses whether to fetch or reuse documents; an inner loop refines queries and ranks documents, while an outer loop generates candidates and records outcomes.
• Why it mattersThe method improves discovery gain on many evaluated settings, but Qwen3.5-9B does not benefit, showing results depend on the model.

Original · huggingface.co by Young-Jun Lee et al.55 upvotes Code

Agents Paper

Verified action sampling raises terminal-agent Pass@1 from 50.00% to 68.03%

Mid-Harness samples candidate commands and verifies them before execution; with a GPT-5.6 Sol verifier, eight samples raise TerminalBench-Lite Pass@1 from 50.00% to 68.03%. The result shows that stronger verification can make test-time compute useful without changing the model or harness.

• WhatMid-Harness samples and verifies candidate actions at the model-harness boundary before forwarding one for execution.
• MethodA capable verifier can select useful alternatives from the same generator; with GPT-5.6 Sol verification, 8 sampled actions raise Pass@1 from 50.00% to 68.03%.
• Why it mattersThe approach improves terminal-agent action reliability without changing the generator or harness.

Original · huggingface.co by Minki Kang et al.31 upvotes

Agents Paper

Agent Error Dataset contains 50,228 diagnosis pairs across 33 environments

The dataset preserves traces and execution metadata, and matched replays show proposed corrections raising verifier pass rates from 18.4% to 51.1%. The evidence-backed error pipeline offers a concrete way to turn agent failures into diagnosis and recovery training data.

• WhatThe Agent Error Dataset contains 50,228 error-diagnosis pairs from 9,961 tasks across 33 environments, 19 harness families, and 23 policy models.
• MethodIts AET pipeline collects failures, generates diagnoses and proposed corrections, and checks them against recorded evidence; replay compares corrections with retries.
• Why it mattersAcross 3,062 matched replay pairs, first-proposal corrections raise verifier pass rates from 18.4% to 51.1%, supporting evidence-checked agent recovery.

Original · huggingface.co by Kunlun Zhu et al.17 upvotes

Inference Paper

WUSH-KV uses data-adaptive transforms for low-bit KV-cache quantization

Integrated into SGLang, the method reports that at 2-bit it matches or outperforms the OSCAR transform across evaluated models and downstream tasks. Lower KV-cache cost can extend the context or batch sizes available to inference services.

• WhatWUSH-KV uses data-adaptive transforms to quantize key and value caches at low bit widths.
• MethodCalibration data builds separate key and value transforms; the value transform folds into model weights, while the key transform is applied after RoPE.
• Why it mattersLower cache reconstruction error supports more efficient long-context inference, where KV-cache memory and bandwidth costs grow with context length and batch size.

Original · huggingface.co by Jiale Chen et al.12 upvotes

Agents Paper

AIM manages automated research ideas and allocates experiment budgets

AIM uses agentic idea selection, solution auditing, and adaptive resource planning; across ten AutoLab tasks it beats the strongest baseline by up to 4.9 points and reaches baseline performance up to 3.1× faster. It offers tested mechanisms for steering long-running research agents and their compute budgets.

• WhatAIM is an autonomous framework for managing research directions in idea-driven automated research.
• MethodIts Agentic Surrogate organizes ideas, Agentic Acquisition guides selection, and a Resource Planner allocates experiment budget across parallel branches.
• Why it mattersExplicit idea-level allocation makes semantic coverage controllable, helping engineers manage exploration across automated research experiments.

Original · huggingface.co by Hyeong Kyu Choi et al.8 upvotes

Security Paper

Stale branch predictions enable Spectre-v2 attacks in JIT engines

Branch Target Reuse exploits stale indirect branch predictions that can survive code-cache repopulation, creating a speculative execute-after-free primitive; the researchers built two Linux kernel exploits. JIT and runtime engineers should consider how generated-code reuse interacts with CPU speculation.

• WhatBranch Target Reuse (BTR) is a Spectre-v2 attack that targets JIT engines across browsers, language runtimes, and the kernel.
• MethodA stale branch-prediction entry can survive code deallocation and be reused when a new code chunk occupies the old address.
• Why it mattersJIT code-cache reuse can enable speculative control-flow hijacking, so code-generation and memory-reuse defenses must account for stale CPU prediction state.

Original · vusec.net 7 min read Lobsters 7 pts

Models & training Paper

Grounded Entity Biographies link the same objects across long videos

GEB groups visually grounded observations of individual objects into retrievable biographies and supplements episodic evidence during question answering; it reports 72.0% on EgoLifeQA, 4.4 points above the best published result. Identity-linked memory offers a concrete way to retrieve long-range visual context.

• WhatGrounded Entity Biographies (GEB) groups visually grounded observations of the same physical entity across clips into retrievable long-video memory.
• MethodDuring question answering, the system retrieves an entity biography alongside episodic evidence, using identity links formed during memory construction.
• Why it mattersLinking object identity across events helps models answer questions about long videos when descriptions alone cannot distinguish or connect physical instances.

Original · huggingface.co by Hui Ren et al.41 upvotes Code · 20 stars

Models & training Paper

SAKI routes teacher supervision through coupled on-policy rollouts

SAKI uses maximal coupling to direct token-level supervision and an engine-resident verifier that raises matched-workload rollout throughput 4.22×; it also improves Mean@8 and Pass@8 for two student sizes across seven math benchmarks. The method links post-training supervision choices to a concrete rollout-throughput gain.

• WhatSAKI routes token-level teacher supervision using accept/correction events from a KL-constrained teacher-guided rollout with maximal coupling.
• MethodAccepted positions retain sampled-token reverse-KL supervision; correction positions receive direct supervision on the teacher’s highest-probability token.
• Why it mattersIts engine-resident speculative verifier preserves exact-q trajectory distribution and coupling semantics while improving matched-workload rollout throughput by 4.22x.

Original · huggingface.co by Miteto Wei et al.37 upvotes Code · 1 stars

Agents Paper

EngiWorld finds frontier agents struggle with professional engineering tasks

EngiWorld evaluates 1,301 tasks across six engineering domains and 26 software platforms; the strongest model scores 44.3, and only 3.6% of multi-software attempts succeed. Its artifact-based verification offers a concrete way to measure agent reliability in consequential workflows.

• WhatEngiWorld benchmarks agents on 1,301 expert-curated tasks across six engineering domains and 26 professional software platforms.
• MethodIts artifact-centric evaluation checks geometric validity, physical feasibility, and rule compliance; the strongest tested model scores 44.3, with 3.6% of multi-software attempts succeeding.
• Why it mattersThe benchmark exposes the gap between general-purpose computer use and reliable automation of end-to-end professional engineering work.

Original · huggingface.co by Hongcheng Gao et al.16 upvotes Code · 17 stars

Agents Paper

LEGO-Anything uses a coding agent to build editable 3D scenes

A coding agent writes and revises Blender programs, while LEGO-Bench measures artifact validity, geometry, and appearance across 208 images; the strongest reported scores are 53.4% indoors and 39.6% outdoors. The benchmark’s separate metrics expose where iterative coding agents still fail at visual reconstruction.

• WhatLEGO-Anything reconstructs 3D scenes from images as editable scene programs, using a coding agent that iteratively writes and executes Blender code.
• MethodThe agent inspects scenes and renderings, then revises the program; LEGO-Bench evaluates artifact validity, visible-surface geometry, and rendered appearance.
• Why it mattersEditable outputs support inspection and revision, while evaluations expose weak initialization, regressive edits, and unreliable self-evaluation in scene-building agents.

Original · huggingface.co by Xirui Li et al.16 upvotes

Models & training Paper

ROSS selectively reuses useful behavior from historical model rollouts

ROSS keeps historical trajectories as context but applies training loss only to selected continuations; on Qwen3.6-35B-A3B, it raises the reported MOPD average from 58.40% to 62.20% and SWE-bench Verified from 64.20% to 68.40%. It offers an evidence-backed way to reuse on-policy experience without imitating its mistakes.

Original · huggingface.co by Zhiwei Zhang et al.12 upvotes

Agents Paper

Context Language Models manage context as an editable file

CLMs let models update a context file directly, reporting 11.4% higher accuracy with 21.5% fewer FLOPs on BrowseComp-Plus and gains on long-horizon benchmarks. The results make model-managed context a practical alternative to external harness strategies worth evaluating.

• WhatContext Language Models (CLMs) treat context as a file that the model can update without restriction.
• MethodCLMs learn what to retain and outperform existing context-management strategies on several tasks, with higher scores and fewer FLOPs.
• Why it mattersMoving context management into model behavior supports in-context and parametric learning of context-management strategies.

Original · huggingface.co by Rulin Shao et al.6 upvotes Code · 1 stars

Models & training Paper

Diffusion Controller steers image generation while preserving baseline stability

Google introduces a lightweight steering network that attaches to closed-source image models to improve prompt alignment without disrupting baseline stability. The approach could help engineers add control to models they cannot modify.

• WhatDiffusion Controller is a lightweight network that steers image generation toward prompts or other user-defined goals.
• MethodIt adjusts the generation trajectory during denoising while leaving the base model frozen; an unrestricted fine-tuned version reportedly won 90% against the baseline.
• Why it mattersThe add-on offers engineers a way to steer a model without changing its core weights, while connecting inference-time guidance and fine-tuning approaches.

Original · research.google 7 min read

Models & training Paper

Domain-normalized distillation improves multi-teacher results across model sizes

DN-MOPD rescales each specialist's feedback by its measured spread; it improves average scores over standard MOPD at three model sizes, across six benchmarks, three seeds and two answer-length limits. The method addresses how imbalanced teacher feedback can blunt multi-skill model training.

• WhatDomain-Normalized MOPD rescales feedback from specialist teachers by each domain’s measured spread during multi-teacher on-policy distillation.
• MethodAcross three Qwen3.5 sizes, it improves average scores over MOPD on six benchmarks and recovers most of the lost mathematics gain.
• Why it mattersBalancing domain feedback can help engineers distill several specialist capabilities into one shared model.

Original · huggingface.co by Xin Li et al.31 upvotes Code · 5 stars

Agents Benchmark

WideSWE coding-agent success ranges from 10.83% to 42.50% on cross-repo tasks

WideSWE evaluates 120 real-world tasks across 103 software ecosystems; seven agent configurations achieve 10.83%–42.50% full success. The benchmark exposes coordination and completion failures that single-repository coding-agent evaluations miss.

• WhatWideSWE evaluates coding agents on real-world tasks that require coordinated changes across multiple repositories.
• HowAcross seven agent configurations, full task success ranged from 10.83% to 42.50%; failures included omitted or unfinished changes.
• Why it mattersThe benchmark exposes cross-repository coordination as a distinct challenge for engineers evaluating coding agents.

Original · huggingface.co by Baoyi Wang et al.7 upvotes Code

Models & training Paper

TT-VidT leads four motion benchmarks in a matched video-pretraining study

In a 24-way matched architecture-objective study, TT-VidT leads four benchmarks, improving 54%–121% over the strongest non-TT row. The controlled comparison helps separate motion-learning gains from differences in training recipes.

• WhatTT-VidT is a motion-centric video-pretraining method evaluated in a matched 24-way architecture-objective study.
• MethodIt pairs a DINOv3-initialized ViT-B/16 spatial path with a Temporal Transfer Layer; Diff Compression reconstructs target frames from appearance and motion tokens.
• Why it mattersTT-VidT led Jester, Something-Something V2, ARID, and Diving48 while using fewer encoder FLOPs than the cited alternatives.

Original · huggingface.co by Shih-Ying Yeh et al.5 upvotes Code · 3 stars

Models & training Paper

Voice embedding geometry tracks human similarity better than verification accuracy

The study reports a −0.95 rank correlation between embedding effective dimensionality and human perceptual alignment; a dimensionality bottleneck raises alignment from 0.08 to 0.74. It shows why speaker-verification accuracy alone can mislead when evaluating voice similarity in generated speech.

• WhatA study tests whether speaker-verification models can serve as proxies for human voice similarity.
• MethodPerceptual alignment depended more on training objective than EER; effective embedding dimensionality tracked alignment, and a bottleneck raised it from 0.08 to 0.74.
• Why it mattersVoice-similarity systems should evaluate embedding geometry and human alignment, rather than treating verification accuracy as a reliable proxy.

Original · huggingface.co by Szu-Chi Chen et al.5 upvotes

Models & training Paper

TaH2 directs extra transformer loops to tokens that benefit from more computation

TaH2 post-trains an iteration decider with lookahead depth supervision, allocating extra loops selectively; the paper reports improved test-time scaling on challenging AIME benchmarks. Selective computation could help engineers trade inference cost against reasoning accuracy.

• WhatTaH2 is an adaptive looped-transformer method that directs extra computation to tokens that benefit from more iterations.
• MethodIt jointly post-trains the backbone and an iteration decider using lookahead depth supervision to identify when further iteration helps.
• Why it mattersOn AIME, TaH2 improved the accuracy-compute slope over the non-looped baseline and exceeded its peak accuracy at matched test-time compute.

Original · huggingface.co by Yichen You et al.29 upvotes Code · 85 stars

Agents Paper

FlyBy teaches small reasoning models to query when they lack knowledge

The analysis distinguishes execution bottlenecks from knowledge bottlenecks, and FlyBy trains 4B and 8B models to decide whether, what and how much to query from stronger models. This offers a cost-aware alternative to spending more inference-time reasoning when external information is needed.

• WhatFlyBy is a selective-query framework for small reasoning models that encounter knowledge bottlenecks.
• MethodModels reason, diagnose what remains unresolved, and query stronger models when external knowledge is needed; cost-aware reinforcement learning calibrates query decisions.
• Why it mattersFlyBy-4B achieved 45.96% pass@8 on 1,158 problems across six benchmarks, surpassing Qwen3-14B at 2.7 times lower serving cost.

Original · huggingface.co by Chanuk Lee et al.23 upvotes Code

Models & training Paper

Chat templates shift LLMs between disclaimer and experiential voices

Across eight open-source models up to 9B parameters, the study finds that chat templates increase disclaimer-style self-reports, while removing them shifts responses toward experiential language. This suggests deployment formatting can confound conclusions drawn from model self-reports.

• WhatChat templates shift LLM self-reports between disclaimer and experiential voices.
• MethodAcross 8 open-source instruct models up to 9B parameters, templates raised disclaimer voice; activation steering reproduced the shift in 3 models.
• Why it mattersTemplate-dependent self-descriptions can confound safety or introspection studies, so engineers should control prompt formatting.

Original · arxiv.org 3 min read HN 101 pts · 101 comments

Models & training Paper

FuseReg improves image generation by training across encoder-layer subsets

FuseReg trains a decoder on random subsets of encoder layers; on ImageNet-256 it reportedly improves reconstruction flexibility and cuts unguided gFID by 27% through decoder replacement alone. The result suggests a practical way to separate representation choices from generator retraining.

• WhatFuseReg trains decoders on random subsets of pretrained encoder layers rather than fixed layer fusions.
• MethodOn ImageNet-256 with DINOv3-L, one decoder handles full, sparse, and single-layer fusions without retraining and achieves higher PSNR than fixed-fusion decoders.
• Why it mattersDecoder replacement alone reduced unguided gFID by 27% with the RAEv2 DiT-XL generator unchanged.

Original · huggingface.co by Hongyang Du et al.67 upvotes Code · 2 stars

Agents Paper

AI agent use can weaken the human oversight it is meant to support

This position paper argues that current agent designs impede oversight and that extended automation can degrade overseers’ cognitive skills; it proposes design affordances and organizational protocols. It frames human capability as a design requirement for deployed agents.

• What- A position paper argues that current AI-agent designs and deployments can undermine effective human oversight.
• Method- It says oversight approaches can impede human judgment, while extended use of AI systems can degrade the cognitive capacities oversight requires.
• Why it matters- Agent builders and deployers are urged to support overseers' critical judgment and counter skill atrophy through design affordances and organizational protocols.

Original · arxiv.org 3 min read Lobsters 27 pts · 3 comments

Agents Paper

Agent-Editing World Model revises noisy reasoning and action histories

AEWM classifies decisions as critical, exploratory, or noisy, then edits noisy continuations against the same observed history; its Action Judge reaches 70.5% macro-F1. The approach targets persistent stale assumptions in long-horizon agent tasks.

• What- Agent-Editing World Model (AEWM) models how agent reasoning and actions shape task progress rather than simulating tool responses.
• Method- Action Judge classifies decisions as Critical, Exploratory, or Noisy; State Revision edits noisy continuations, and EditAct integrates both with real execution.
• Why it matters- Editing the state behind later decisions targets task-state contamination from unsupported assumptions and outdated plans in long-horizon agents.

Original · huggingface.co by Shuang Sun et al.20 upvotes Code · 6 stars

Agents Paper

Self-organizing agent teams learn transferable collaboration strategies

Teams learn roles, conversational phases, and information flow from 40 problems, then transfer those strategies unchanged to unseen benchmarks; they average 66.7% accuracy against 48.8% for their strongest member. The results offer evidence for learned coordination beyond fixed agent protocols.

• What- Self-Organizing Agent Teams (SAT) lets fixed teams learn reusable strategies for organizing roles, conversational phases, participation, and information flow.
• Method- Learned strategies transferred unchanged to unseen benchmarks using 15 mathematics and 25 graduate-level knowledge problems; teams averaged 66.7% across five math and physics benchmarks.
• Why it matters- The results suggest agent-team performance can benefit from learned collaboration strategies, not only fixed protocols, task decomposition, or routing.

Original · huggingface.co by Aneesh Pappu et al.6 upvotes

Inference Paper

FLEET uses generation history to reduce duplicate sampling and improve coding results

FLEET adjusts logits using sparse, high-entropy generation trajectories; it reports 3× speedup at baseline accuracy and raises LiveCodeBench Pass@32 from 59.9% to 66.2% at the same budget. The method connects decoding decisions to prior samples rather than treating each draw independently.

• What- FLEET adds memory of prior generations to temperature sampling, representing generations as sparse trajectories through high-entropy states.
• Method- It uses trajectories to infer per-token utility scores that adjust logits; evaluations found the same accuracy as repeated sampling with a 3× speedup.
• Why it matters- For coding tasks, FLEET improved LiveCodeBench Pass@32 from 59.9% to 66.2% under the same budget, with minimal pipeline changes.

Original · huggingface.co by Oleksii Streltsov, Oleksandra Vitko5 upvotes Code

Inference Paper

PISA uses hierarchical Top-K selection for O(N log N) sparse attention

PISA narrows attention candidates through a coarse-to-fine hierarchy, with Triton kernels that fuse routing and scoring without materializing the query-key matrix. Its stated O(N log N) complexity targets a major bottleneck in long-context attention.

• WhatPISA is a block-sparse attention method that selects retained key blocks with a hierarchical Top-K strategy.
• MethodIt narrows candidates from coarse to fine using LogSumExp scoring over bounded sets, with O(N log N) complexity and fused Triton kernels.
• Why it mattersReducing block-selection cost can make long-context attention more efficient without materializing the query-key score matrix.

Original · huggingface.co by Bohao Tang et al.14 upvotes

Practice & careers Paper

Google study links perceived code quality to developer productivity

A study of Google developers across 39 productivity factors finds that increases in perceived code quality tend to precede increases in self-reported productivity. The findings inform engineering investment decisions, though the outcome measures are self-reported.

• WhatA Google study examined how technical and organizational factors relate to developers’ self-reported productivity.
• MethodIts lagged panel analysis found that increases in perceived code quality tend to precede increased perceived productivity, but not vice versa.
• Why it mattersFor engineering organizations, the findings make code quality a potential productivity investment, alongside tools, technical debt, communication, and priorities.

Original · dl.acm.org Lobsters 17 pts · 1 comment

Architecture Paper

RayOrch preserves data lineage while batching variable-size preparation work

RayOrch pairs ordered, variable-size expansions with matching gathers, tracking parentage and child status while FIFO queues batch work across parents. This design targets a recurring data-pipeline trade-off between parallel execution and reliable lineage.

• WhatRayOrch is a programming model and distributed execution engine for foundation-model data-preparation pipelines.
• MethodPrograms declare ordered, variable-cardinality expansions and matching gathers; the runtime tracks child membership, parentage, ordinals, and terminal states.
• Why it mattersFIFO queues batch ready children across parents, while gathers restore results by membership and ordinal, preserving lineage across variable-size work.

Original · huggingface.co by Xiaochen Ma et al.16 upvotes Code

Models & training Paper

Rufus-Air documents an eight-stage open post-training recipe for GLM-4.5-Air

The recipe details data, rewards, infrastructure, stage order, and results across SFT, several RL stages, agent training, and RLHF; it reports performance above the official post-trained release. Engineers can use its reproducible choices to inform open-model post-training.

• WhatRufus-Air is an open, reproducible post-training recipe for GLM-4.5-Air-Base, organized as eight serial stages.
• MethodThe stages move from SFT and several RL phases through agent training and RLHF; the recipe documents data, rewards, infrastructure, and stagewise results.
• Why it mattersIts findings highlight difficulty filtering and reward reliability, and treat infrastructure and engineering choices as part of the training recipe.

Original · huggingface.co by Chia-Yuan Chang et al.15 upvotes

Agents Paper

MemBodied adds fixed-size episodic memory to vision-language-action policies

MemBodied combines an interaction state with an episode anchor and reports 7.81 times the mean success rate of a stateless policy on five memory-dependent tasks, using 10 times fewer added parameters than the strongest memory-augmented baseline. The results make its compact alternative to growing context worth examining for robot policies.

• WhatMemBodied adds fixed-size episodic memory to vision-language-action policies using an associative state and an episode anchor.
• MethodAt each policy call, action generation conditions on the current input and both memory components instead of directly using past observations.
• Why it mattersCompact memory offers a way to retain task history without growing context and inference latency as observations accumulate.

Original · huggingface.co by Tej Deep Pala et al.11 upvotes Code · 9 stars

Agents Paper

Coding agents synthesize programs for generalized task and motion planning

The study evaluates 980 agent-generated programs across 98,000 held-out episodes in 28 simulated environments to test generalization to unseen planning instances. Its scale and focus on frozen programs make it useful for assessing coding agents beyond familiar software tasks.

• WhatCoding agents synthesize programs for generalized task and motion planning, aiming to reuse regularities across problem instances.
• MethodAgents use a task description and simulator access to develop programs within a fixed budget; frozen programs are evaluated on unseen instances.
• Why it mattersThe study reports all three agent configurations outperforming the tested planning baselines in mean success on 16 environments.

Original · huggingface.co by Matteo Merler et al.9 upvotes Code · 13 stars

Agents Paper

WhatWorkedBench measures whether agents can predict experiment effects

The benchmark covers 36 tasks and 1,248 configurations; fitting a Gaussian process to agent observations improves effect recovery from 0.632 to 0.698 in one cohort and from 0.621 to 0.720 in another. It tests whether research agents can learn which experimental changes actually move results.

• WhatWhatWorkedBench measures agents’ ability to predict how experiment outcomes change when components are changed.
• MethodAgents inspect code, choose measurements, and submit a response surface; exhaustive CPU execution supplies reference effects.
• Why it mattersIt provides a way to assess whether agents can predict experiment effects, a key capability for AI research workflows.

Original · huggingface.co by Jingjie Ning et al.9 upvotes Code · 2 stars

Models & training Paper

Neural Spectral Capacity ranks architectures beyond parameter and FLOP counts

NSC estimates architectural capacity from weight-matrix spectra, and its dynamic-programming solver finds a budget-constrained design without instantiating a model; tests span seven Transformer and CNN families. It offers a measurable alternative to size-only proxies when choosing architectures.

• WhatNeural Spectral Capacity (NSC) scores neural architectures using the singular-value spectra of their weight matrices.
• MethodUnder standard random initialization, NSC can be computed from an architecture specification alone; NSC-DP uses dynamic programming to maximize it under resource constraints.
• Why it mattersThe method offers engineers an architecture-ranking and optimization approach that does not require model instantiation, data, or gradients.

Original · huggingface.co by Chenyu Zhu et al.7 upvotes Code · 5 stars

Inference Paper

GeoPair compresses transformers by factorizing compatible cross-layer weights

GeoPair pairs structurally compatible projections and factorizes them with shared dictionaries, preserving layer-specific calibration geometry without training. Its reported gains over independent and heuristic decompositions make it relevant to engineers evaluating model compression.

• WhatGeoPair is a training-free framework for compressing transformers by optimizing compatible cross-layer weight pairings.
• MethodIt learns shared representations that preserve each layer's calibration geometry, and combines the decompositions with structured sparsity.
• Why it mattersThe method targets efficient weight compression across architectures and modalities while preserving functional fidelity.

Original · huggingface.co by Baher Mohammad et al.13 upvotes

Models & training Paper

WanPE improves long-form video prompts with shot-level cinematic plans

The 397B model uses plans built from 1.05M videos and improves human preference by 10.66–18.84 points at 5–15 seconds and 50.86 points at 30 seconds. It is a substantial example of how prompt planning can improve a generative model’s output.

• WhatWanPE is a 397B-parameter prompt-enhancement model trained on 1.05M real-world videos to create shot-level cinematic plans.
• MethodIt uses video-grounded reverse construction and Semantic-Consistency GRPO to preserve user requirements across shots and over time.
• Why it mattersWith Wan3.0, it raised human preference over raw prompts by 10.66–18.84 points at 5–15 seconds and 50.86 points at 30 seconds.

Original · huggingface.co 31 upvotes

Agents Paper

IterSynth separates search planning from synthesis and scores 50.7 on deep-search benchmarks

IterSynth alternates a planner with a synthesizer that maintains a summary state, and the paper reports an average score of 50.7 for IterSynth-8B across five long-horizon benchmarks. The design addresses context growth and role coupling in deep-search agents.

• WhatIterSynth separates deep-search planning and synthesis, using a Planner and Synthesizer with an evolving summary as persistent search state.
• MethodThe Planner identifies information needs; the Synthesizer integrates evidence into the summary; RDPO uses outcome rewards and turn-level rubric scores for role-specific credit assignment.
• Why it mattersSeparating roles and summarizing search history aims to reduce context noise in long-horizon agent tasks.

Original · huggingface.co 9 upvotes

Models & training Paper

WROP trains video models on object permanence with 1.5M samples

WROP provides 150 task designs, a 1.5M-sample corpus, and a 300-question exam; PWM-WROP ranks first among continuation models in a blind Elo study. The released training and evaluation resources make this a useful test of physical reasoning in video models.

• WhatWROP is an infrastructure of 150 cognitive-science-inspired tasks across six categories, designed to train object permanence in video models.
• MethodBlender generators vary nuisance factors while preserving task structure, producing 10,000+ samples per task and a 1.5M-sample training corpus.
• Why it mattersIn blind pairwise Elo evaluation, PWM-WROP ranked first among continuation models and third overall among 14 evaluated video models.

Original · huggingface.co 195 upvotes

Agents Paper

VHD-Play generates 3,300 agent environments from solved mechanisms

VHD-Play derives executable dynamics and trajectory scoring from the same solved model, generating 3,300 environments for a few cents each; Qwen3.6-35B-A3B training raises mean agentic score from 0.204 to 0.815. The approach offers a way to scale agent training while keeping task mechanics and evaluation aligned.

• WhatVHD-Play generates agentic reinforcement-learning environments by solving mathematical models before rendering their decision processes as stateful tools.
• MethodThe same solved model supplies executable dynamics and a trajectory-scoring reference, keeping environment behavior and evaluation aligned.
• Why it mattersThe pipeline produces 3,300 environments and training gains that extend to held-out mechanisms and external benchmarks, supporting scalable agent training.

Original · huggingface.co 12 upvotes

Models & training Paper

RecCAR aligns cross-modal attention to improve joint video generation

RecCAR regularizes weaker modality-to-video correspondence toward video-to-modality attention, raising Human Anatomy from 0.69 to 0.75 and reducing audio-video desynchronization from 0.804 to 0.752. The method offers a concrete training intervention for joint video, motion, and audio models.

• What- RecCAR is a KL regularizer for reciprocal cross-modal attention in joint video generation.
• Method- It uses video-to-modality correspondence as a fixed reference and aligns the weaker modality-to-video correspondence toward it.
• Why it matters- The method addresses an attention asymmetry that can limit how audio or motion constrains generated video.

Original · huggingface.co 8 upvotes

Research Paper

A proof-difficulty metric steers LLMs toward less-overlapping mathematical theorems

The work trains a 27B model to predict proof difficulty and reports reducing substantial or full overlap with Mathlib from 91.9% to 30.6%. Its metric offers a concrete approach to selecting outputs for generative research systems.

• WhatProof difficulty conditioned on premises helps rank theorem interestingness, defined as proof length divided by statement length.
• MethodA trained 27B model predicts proof difficulty; optimizing the metric reduced substantial or full Mathlib overlap from 91.9% to 30.6%.
• Why it mattersQuantifiable ranking signals can guide conjecture selection and proof search in formal mathematical libraries.

Original · huggingface.co 7 upvotes