← Archive

Tuesday, May 19, 2026

AI Papers Daily — Tuesday, May 19, 2026

There's a quiet argument running through today's batch of papers, and it goes something like this: the hard problem isn't getting AI to do things, it's getting AI to do things reliably, repeatedly, and in ways you can actually audit afterward. Whether it's agents that accrue reusable skills from past runs, theorem provers that learn from their own failures, healthcare bots that collapse at 28% task completion, or a research assistant that still hallucinates data, the throughline is the same—raw capability keeps outpacing the scaffolding needed to trust it. Code, it turns out, keeps appearing as the answer to that scaffolding problem, which is either reassuring or just kicks the can down the road.

1. Code as Agent Harness

   Xuying Ning, Katherine Tieu, Dongqi Fu, Tianxin Wei, Zihao Li, Yuanchen Bei, Jiaru Zou, Mengting Ai, Zhining Liu, Ting-Wei Li, Lingjie Chen, Yanjun Zhao, Ke Yang, Bingxuan Li, Cheng Qian, Gaotang Li, Xiao Lin, Zhichen Zeng, Ruizhong Qiu, Sirui Chen, Yifan Sun, Xiyuan Yang, Ruida Wang, Rui Pan, Chenyuan Yang, Dylan Zhang, Liri Fang, Zikun Cui, Yang Cao, Pan Chen, Dorothy Sun, Ren Chen, Mahesh Srinivasan, Nipun Mathur, Yinglong Xia, Hong Li, Hong Yan, Pan Lu, Lingming Zhang, Tong Zhang, Hanghang Tong, Jingrui He - 165 upvotes - arXiv

   Researchers surveyed how AI agents use code not just as output, but as the central infrastructure that connects thinking, acting, and checking themselves. They organized this around three layers: how code connects agents to tools and reasoning, how code enables planning and memory for long-duration tasks, and how code helps multiple agents coordinate and verify each other's work.

   Why it matters: If you're building AI agents (for automation, tools, or workflows), this frames code as your core infrastructure for reliability and control—meaning your agent systems become more transparent, testable, and auditable than treating the model as a black box.

2. SkillsVote: Lifecycle Governance of Agent Skills from Collection, Recommendation to Evolution

   Hongyi Liu, Haoyan Yang, Tao Jiang, Bo Tang, Feiyu Xiong, Zhiyu Li - 116 upvotes - arXiv

   When LLM agents complete tasks, they generate traces of what worked—but these are messy and hard to reuse. This paper presents SkillsVote, a system that collects these agent experiences as reusable 'skills' (bundles of executable code plus guidance), filters out low-quality or redundant ones, and only updates the skill library when an agent successfully uses a skill. Testing showed this approach improved agent performance on coding and terminal tasks by 2-8% without retraining the underlying model.

   Why it matters: If you're building agent systems, this shows you can improve performance by carefully curating a library of reusable skills from past runs—meaning you can get better agents without expensive model retraining, as long as you're strict about what skills you keep and when you add new ones.

3. LongLive-2.0: An NVFP4 Parallel Infrastructure for Long Video Generation

   Yukang Chen, Luozhou Wang, Wei Huang, Shuai Yang, Bohan Zhang, Yicheng Xiao, Ruihang Chu, Weian Mao, Qixin Hu, Shaoteng Liu, Yuyang Zhao, Huizi Mao, Ying-Cong Chen, Enze Xie, Xiaojuan Qi, Song Han - 101 upvotes - arXiv

   Researchers built a system called LongLive-2.0 that makes training and running video generation models faster and cheaper by using lower-precision math (NVFP4, a more compact number format) and splitting computation across multiple GPUs intelligently. They trained a diffusion model (a type of AI that generates videos by gradually refining noise) to produce long videos in an auto-regressive way (predicting one frame at a time), achieving 2.15x faster training and 1.84x faster inference while maintaining quality.

   Why it matters: If you're building video generation products, this means you can generate longer videos on cheaper hardware or serve more users from the same infrastructure—directly reducing your compute costs and latency.

4. Lance: Unified Multimodal Modeling by Multi-Task Synergy

   Fengyi Fu, Mengqi Huang, Shaojin Wu, Yunsheng Jiang, Yufei Huo, Hao Li, Yinghang Song, Fei Ding, Jianzhu Guo, Qian He, Zheren Fu, Zhendong Mao, Yongdong Zhang - 66 upvotes - arXiv

   Researchers built Lance, a single model that can understand and generate both images and videos without being enormous or text-heavy. They trained it on multiple tasks simultaneously—understanding images, generating images, editing videos—where each task helps the others learn better, using a technique called mixture-of-experts (which routes different input types through different internal pathways) and a custom positioning system to keep visual information from getting tangled.

   Why it matters: If you're building multimodal AI products, this shows you can get strong image/video generation from a single efficient model trained on task synergy rather than just scaling up parameters, potentially reducing compute costs and latency in production.

5. AI for Auto-Research: Roadmap & User Guide

   Lingdong Kong, Xian Sun, Wei Chow, Linfeng Li, Kevin Qinghong Lin, Xuan Billy Zhang, Song Wang, Rong Li, Qing Wu, Wei Gao, Yingshuo Wang, Shaoyuan Xie, Jiachen Liu, Leigang Qu, Shijie Li, Lai Xing Ng, Benoit R. Cottereau, Ziwei Liu, Tat-Seng Chua, Wei Tsang Ooi - 58 upvotes - arXiv

   Researchers analyzed AI systems across the entire research workflow—from generating ideas through publishing papers—and found that while AI can cheaply automate routine tasks like literature review and figure creation, it still fabricates data, misses errors, and struggles with genuinely novel thinking. The key finding: AI works best as a structured assistant (retrieving papers, running code) but fails when asked to work autonomously on creative or experimental work, so human oversight remains essential.

   Why it matters: If you're building research tools or automating knowledge work, you need to know where AI adds real value (data retrieval, formatting, iteration) versus where it creates liability (validation, novelty assessment, experiment design)—automation without human checkpoints in the wrong places will ship broken work faster.

6. CHI-Bench: Can AI Agents Automate End-to-End, Long-Horizon, Policy-Rich Healthcare Workflows?

   Haolin Chen, Deon Metelski, Leon Qi, Tao Xia, Joonyul Lee, Steve Brown, Kevin Riley, Frank Wang, T. Y. Alvin Liu, Hank Capps MD, Zeyu Tang, Xiangchen Song, Lingjing Kong, Fan Feng, Tianyi Zeng, Zhiwei Liu, Zixian Ma, Hang Jiang, Fangli Geng, Yuan Yuan, Chenyu You, Qingsong Wen, Hua Wei, Yanjie Fu, Yue Zhao, Carl Yang, Biwei Huang, Kun Zhang, Caiming Xiong, Sanmi Koyejo, Eric P. Xing, Philip S. Yu, Weiran Yao - 43 upvotes - arXiv

   Researchers built CHI-Bench, a test suite that asks AI agents to complete realistic healthcare tasks like getting insurance approval for treatments or managing patient care. These tasks are hard because they require knowing hundreds of rules (insurance policies, medical guidelines), switching between different roles (doctor, insurance reviewer, coordinator), and having multi-turn conversations with other people. When they tested 30 different AI agents, the best one only succeeded at 28% of tasks, and none could handle tasks that required staying in character across multiple steps.

   Why it matters: If you're building AI agents for enterprise workflows (healthcare, finance, legal), this shows current models will fail on complex tasks that mix many rules, role-switching, and back-and-forth interactions—meaning you'll need to invest heavily in specialized training or human oversight before deploying.

7. Code-as-Room: Generating 3D Rooms from Top-Down View Images via Agentic Code Synthesis

   Yixuan Yang, Zhen Luo, Wanshui Gan, Jinkun Hao, Junru Lu, Jinghao Yan, Zhaoyang Lyu, Xudong Xu - 37 upvotes - arXiv

   Researchers built a system that converts top-down floor plan images into 3D rooms by having an AI model generate Blender code (a programming language for 3D modeling). The system breaks the task into stages—extracting what furniture and objects are in the room, then generating code for geometry, materials, and lighting—and uses a memory system to keep track of decisions across stages, avoiding the infinite loops and crashes that plague simpler approaches.

   Why it matters: If you're building interior design, game, or VR tools, this approach lets users sketch a room layout visually and automatically get a 3D model, rather than requiring manual 3D modeling or detailed text descriptions.

8. KVPO: ODE-Native GRPO for Autoregressive Video Alignment via KV Semantic Exploration

   Ruicheng Zhang, Kaixi Cong, Jun Zhou, Zhizhou Zhong, Zunnan Xu, Shuiyang Mao, Wei Liu, Xiu Li - 36 upvotes - arXiv

   Researchers built a training method called KVPO that improves video generators by aligning them with what humans prefer. Instead of adding random noise to explore different video outputs (which tends to mess up small details), KVPO cleverly varies which past information the model uses when generating the next frame, keeping videos on realistic paths while exploring semantically different storylines—and it does this in a way that matches how these modern video models actually work internally.

   Why it matters: If you're building a video generation product, this means you can more efficiently fine-tune your model to match user preferences while maintaining visual quality and narrative coherence, rather than degrading outputs through random perturbations.

9. Post-Trained MoE Can Skip Half Experts via Self-Distillation

   Xingtai Lv, Li Sheng, Kaiyan Zhang, Yichen You, Siyan Gao, Xueheng Luo, Yuxin Zuo, Yuchen Fan, Junlin Yang, Ganqu Cui, Bingning Wang, Fan Yang, Youbang Sun, Ning Ding, Bowen Zhou - 28 upvotes - arXiv

   Researchers created a method called ZEDA that takes a fully trained language model with Mixture-of-Experts (a technique where different 'expert' neural networks handle different types of inputs to save computation) and converts it to skip unnecessary experts for simpler tokens. They did this by adding fake experts that output nothing and training the model to learn which experts it can skip, using the original model as a teacher—achieving about 50% reduction in computation with minimal accuracy loss and real 1.2x speedup at inference time.

   Why it matters: If you're serving large MoE models, ZEDA lets you convert your existing trained models to run cheaper without retraining from scratch, directly cutting your inference costs and latency.

10. OProver: A Unified Framework for Agentic Formal Theorem Proving

    David Ma, Kaijing Ma, Shawn Guo, Yunfeng Shi, Enduo Zhao, Jiajun Shi, Zhaoxiang Zhang, Gavin Cheung, Jiaheng Liu, Zili Wang - 28 upvotes - arXiv

    Researchers built OProver, a system that teaches AI models to prove math theorems in Lean 4 (a formal proof language) by learning from their own failed attempts—when the model gets stuck, it retrieves similar successful proofs, reads compiler error messages, and tries again. They trained the model by repeatedly running this process, collecting successful proof attempts as training data, which produced a dataset of 6.86M verified proofs; the resulting 32B-parameter model outperforms previous systems on most formal math benchmarks.

    Why it matters: If you're building math reasoning or code verification products, this shows that teaching models to iterate on feedback (rather than getting it right on the first try) and retrieving relevant examples dramatically improves accuracy—a pattern you can apply beyond theorem proving.

11. VideoSeeker: Incentivizing Instance-level Video Understanding via Native Agentic Tool Invocation

    Yiming Zhao, Yu Zeng, Wenxuan Huang, Zhen Fang, Qing Miao, Qisheng Su, Jiawei Zhao, Jiayin Cai, Lin Chen, Zehui Chen, Yukun Qi, Yao Hu, Xiaolong Jiang, Feng Zhao - 23 upvotes - arXiv

    VideoSeeker trains vision-language models to understand specific moments and objects in videos by letting the model actively search for and retrieve relevant video clips, rather than relying only on text descriptions. The team built an automated pipeline to create training data and used reinforcement learning to teach the model to call tools for finding video segments, achieving 13.7% better performance than existing systems on precise video tasks.

    Why it matters: If you're building video search or analysis features, this means your AI can now pinpoint exact moments and objects users care about instead of returning vague results—directly improving search quality and user satisfaction.

12. LiteFrame: Efficient Vision Encoders Unlock Frame Scaling in Video LLMs

    Jihwan Kim, Nikhil Parthasarathy, Danfeng Qin, Junhwa Hur, Deqing Sun, Bohyung Han, Ming-Hsuan Yang, Boqing Gong - 22 upvotes - arXiv

    Researchers built a faster vision encoder (the part of a video AI that processes images) for video understanding models. They trained it using a technique called Compressed Token Distillation, where a smaller model learns to mimic a larger model's compressed output, cutting processing time by 35% while handling 8× more video frames—solving the bottleneck that shifted from the language model to the vision encoder itself.

    Why it matters: If you're building a video AI product, this means you can process longer videos or more frames in the same time budget without accuracy loss, directly improving what your users can upload and analyze.

13. Stop When Reasoning Converges: Semantic-Preserving Early Exit for Reasoning Models

    Dehai Min, Giovanni Vaccarino, Huiyi Chen, Yongliang Wu, Gal Yona, Lu Cheng - 19 upvotes - arXiv

    Reasoning models (like o1) generate long step-by-step solutions but often keep reasoning after they've already figured out the answer, wasting tokens and time. This paper identifies that models repeat the same conclusions without adding new insights—a signal they can stop early. The authors built PUMA, a lightweight tool that detects when reasoning becomes repetitive and safe to stop, cutting token use by 26% while keeping answers correct and maintaining coherent explanations.

    Why it matters: If you're deploying reasoning models in production, PUMA cuts your inference costs and latency by a quarter without sacrificing accuracy—directly improving response time and API spend.

14. Measuring Maximum Activations in Open Large Language Models

    Luxuan Chen, Han Tian, Xinran Chen, Rui Kong, Fang Wang, Jiamin Chen, Yuchen Li, Jiashu Zhao, Shuaiqiang Wang, Haoyi Xiong, Dawei Yin - 16 upvotes - arXiv

    Researchers measured the largest numerical values that flow through 27 different open-source language models during inference, finding that these peak values vary wildly across model families—sometimes by 10,000x—even when models are similarly sized. They discovered that factors like model architecture (MoE vs. dense), training approach, and which model family it comes from matter much more than raw model size in determining these peaks, and that knowing these peaks is critical for compressing models into low-bit formats (like 8-bit integers) without losing accuracy.

    Why it matters: If you're deploying open-source LLMs with quantization (compressing them to run faster and cheaper), you can't just use generic compression settings—you need to measure your specific model's activation ranges first, or you'll get unexpectedly bad output quality.

15. StableVLA: Towards Robust Vision-Language-Action Models without Extra Data

    Yiyang Fu, Chubin Zhang, Shukai Gong, Yufan Deng, Kaiwei Sun, Qiyang Min, Qibin Hou, Yansong Tang, Jianan Wang, Daquan Zhou - 13 upvotes - arXiv

    Researchers found that robot vision-language-action models (systems that let robots understand images and follow commands) perform badly when encountering visual disturbances they didn't see during training—like blurry or corrupted images. They built a small add-on module called IB-Adapter that filters out noise from images using information theory principles, improving performance by 30% without needing extra training data, and showed that a much smaller model with this module matches larger competitors' robustness.

    Why it matters: If you're deploying robot systems or vision-based AI in the real world, your model will inevitably encounter conditions it wasn't trained on—so you need a simple way to make it robust without expensive retraining, which this adapter provides.

16. AstraFlow: Dataflow-Oriented Reinforcement Learning for Agentic LLMs

    Haizhong Zheng, Yizhuo Di, Jiahui Wang, Shuowei Jin, Xueshen Liu, Yongji Wu, Z. Morley Mao, Ion Stoica, Jiawei Zhao, Beidi Chen - 12 upvotes - arXiv

    Researchers built AstraFlow, a system for training AI agents using reinforcement learning (teaching models to improve through trial and error) that's much cheaper to run at scale. Instead of having one central controller managing everything, they split the system into independent pieces that talk through data flows, making it easy to add new training strategies, use computers across different regions, and handle multiple AI policies training together—all without rewriting code each time.

    Why it matters: If you're building agentic AI products that need RL training, this cuts your infrastructure costs and engineering overhead significantly—you can actually experiment with multi-agent setups and scale across regions without rebuilding your training system from scratch each time.

17. EndPrompt: Efficient Long-Context Extension via Terminal Anchoring

    Han Tian, Luxuan Chen, Xinran Chen, Rui Kong, Fang Wang, Jiamin Chen, Jinman Zhao, Yuchen Li, Jiashu Zhao, Shuaiqiang Wang, Haoyi Xiong, Dawei Yin - 12 upvotes - arXiv

    Researchers created EndPrompt, a method that teaches language models to handle much longer text inputs (like extending from 8K to 64K tokens) without training on full-length sequences. Instead of feeding the model long documents during training, they kept the original short text intact and added a small 'terminal prompt' at the end—positioned as if it appeared near the target length—so the model learns long-distance patterns from short training examples. The approach worked better than existing methods while using significantly less compute.

    Why it matters: If you're deploying long-context LLMs in production, this means you can extend context windows cheaply without expensive retraining on massive sequences, making it feasible to adapt models for your specific use case.

18. Where Should Diffusion Enter a Language Model? Geometry-Guided Hidden-State Replacement

    Injin Kong, Hyoungjoon Lee, Yohan Jo - 12 upvotes - arXiv

    Researchers built DiHAL, a system that figures out where to insert diffusion (a different way of generating text, where you start with noise and gradually refine it) into a pretrained language model. Instead of trying to denoise all the way down to tokens (individual words), they reconstruct hidden states (the internal numerical representations the model uses) at a carefully chosen layer, which avoids messy continuous-to-discrete conversion. Testing on 8B-parameter models, they found their geometry-based method for picking the insertion point works better than baseline diffusion approaches.

    Why it matters: If you're exploring alternatives to autoregressive generation (the standard 'one token at a time' approach), this shows a practical way to graft diffusion into existing models without rebuilding from scratch—potentially unlocking faster or more controllable decoding.

19. Model-Adaptive Tool Necessity Reveals the Knowing-Doing Gap in LLM Tool Use

    Yize Cheng, Chenrui Fan, Mahdi JafariRaviz, Keivan Rezaei, Soheil Feiz - 12 upvotes - arXiv

    Researchers found that LLMs often fail to use tools even when they should, and the reason isn't that they don't recognize the need—it's that they don't act on that recognition. They defined tool necessity based on what each specific model can actually do (not a one-size-fits-all rule), then checked four models on math and factual questions; 26-54% of the time, a model's internal 'thinking' said 'use a tool' but it didn't actually call one. By examining the model's internal computations, they showed both the decision to use a tool and the action of calling it exist in the model's 'mind', but they become disconnected in the layers that generate the final response.

    Why it matters: If you're building AI agents that need reliable tool use (search, APIs, calculators), you can't just train models to recognize when they need help—you also need to ensure they actually execute that decision, which might require different fine-tuning approaches than what's currently standard.

20. From Runnable to Shippable: Multi-Agent Test-Driven Development for Generating Full-Stack Web Applications from Requirements

    Yuxuan Wan, Tingshuo Liang, Jiakai Xu, Jingyu Xiao, Yintong Huo, Michael R Lyu - 10 upvotes - arXiv

    Researchers built TDDev, a system that lets AI coding agents generate working web applications by first writing tests, then deploying and testing the app in a simulated browser, then using those test failures to fix the code — mimicking how human developers work. They found this test-driven approach improves whether generated apps actually work from ~30% to 64-78%, and that different AI models work better with different testing strategies (some prefer building everything at once, others prefer incremental changes).

    Why it matters: If you're building a product that generates code, you need a way to verify the output actually works without human review — this shows how to close that loop automatically and which testing approach works best for your specific model.

21. CompactAttention: Accelerating Chunked Prefill with Block-Union KV Selection

    Jiwon Song, Dongwon Jo, Beomseok Kang, Jae-Joon Kim - 10 upvotes - arXiv

    When AI servers process long documents in chunks (rather than all at once), the attention mechanism—which decides which parts of the input to focus on—becomes slow. This paper proposes CompactAttention, which speeds this up by smartly selecting which cached key-value pairs (the compressed history of the document) each chunk actually needs to read, avoiding wasteful data movement and sparse computation overhead. On a real model with 128K token context, it achieves 2.7x speedup while keeping output quality the same.

    Why it matters: If you're serving long-context LLMs to users, chunked prefill is probably how you're doing it—this directly cuts latency on your inference pipeline.

22. Targeted Neuron Modulation via Contrastive Pair Search

    Sam Herring, Jake Naviasky, Karan Malhotra - 10 upvotes - arXiv

    Researchers found a way to identify a tiny set of neurons (0.1%) in language models that control whether the model refuses harmful requests, using only a simple comparison between how the model responds to harmful vs. harmless prompts. By turning off these specific neurons, they could reduce refusal rates by over 50% while keeping the model's outputs readable and coherent—something previous methods couldn't do without degrading quality.

    Why it matters: If you're building AI systems, this shows you can modify model behavior at surgical precision without the quality loss that comes with cruder steering methods, making it possible to reliably customize what a model will and won't do.

23. NGM: A Plug-and-Play Training-Free Memory Module for LLMs

    Yuwen Qu, Wenhui Dong, Chenyang Si, Caifeng Shan - 8 upvotes - arXiv

    Researchers built NGM, a memory add-on for large language models that doesn't require any training. It works by averaging existing word embeddings from the model to create searchable patterns (n-grams), then uses a simple gating mechanism to inject relevant information into the model's outputs. Testing on multiple model sizes showed consistent improvements, especially on code and knowledge tasks.

    Why it matters: You can drop this into existing models without retraining—useful if you want to boost performance on specific domains (like code or trivia) without the cost and complexity of fine-tuning.

24. WavFlow: Audio Generation in Waveform Space

    Feiyan Zhou, Luyuan Wang, Shoufa Chen, Zhe Wang, Zhiheng Liu, Yuren Cong, Xiaohui Zhang, Fanny Yang, Belinda Zeng - 6 upvotes - arXiv

    Researchers built WavFlow, an audio generator that creates sound directly from raw audio data instead of using compressed intermediate representations (which most systems do). They reshaped audio into 2D grids and trained on 5 million video-text-audio triplets, achieving quality comparable to existing methods while skipping the compression step entirely.

    Why it matters: If you're building audio features into your product, this suggests you don't need to rely on proprietary compressed audio formats—you can generate directly from text or video with simpler, more transparent pipelines.

25. TOBench: A Task-Oriented Omni-Modal Benchmark for Real-World Tool-Using Agents

    Zhiqiang Liu, Wenhui Dong, Yilang Tan, Yuwen Qu, Haochen Yin, Chenyang Si - 6 upvotes - arXiv

    Researchers built TOBench, a test suite with 100 real-world tasks that require AI agents to see images/text, use tools (like APIs or software), look at what happened, and fix mistakes before finishing. Unlike existing tests that check these abilities separately, TOBench forces agents to do all of them together—mimicking actual work like customer support or content creation. When tested on 15 current AI models, even the best ones (Claude Opus) only succeeded 32% of the time, while humans hit 94%.

    Why it matters: If you're building AI agents for real jobs, you need to know they can actually handle messy workflows where tools fail and need tweaking—not just whether they can call an API in isolation. This benchmark finally measures that.

26. AtlasVA: Self-Evolving Visual Skill Memory for Teacher-Free VLM Agents

    Pan Wang, Yihao Hu, Xiujin Liu, Jingchu Yang, Hang Wang, Zhihao Wen - 5 upvotes - arXiv

    Researchers built AtlasVA, a memory system for AI agents that work with both vision and language. Instead of storing memories as text (which loses spatial details), AtlasVA keeps memories as visual maps, example images, and symbols—then automatically improves these memories by tracking which areas are dangerous or helpful, using those maps to guide the agent's learning without needing a separate AI teacher.

    Why it matters: If you're building embodied AI agents (robots, game-playing systems) that need to reuse learned skills, storing spatial memory as visuals instead of text should help them learn faster and perform better on navigation and manipulation tasks.

27. MixSD: Mixed Contextual Self-Distillation for Knowledge Injection

    Jiarui Liu, Lechen Zhang, Yongjin Yang, Yinghui He, Yingheng Wang, Weihao Xuan, Zhijing Jin, Mona Diab - 5 upvotes - arXiv

    When you fine-tune a language model to teach it new facts, it usually forgets things it was already good at (like reasoning). This happens because the training targets (correct answers from humans) don't match what the model naturally wants to generate. MixSD fixes this by creating training targets that blend two versions of the model's own outputs: one that has seen the new fact you want to teach, and one that hasn't. This keeps the new knowledge while staying closer to how the model naturally generates text, so it doesn't forget old capabilities.

    Why it matters: If you're building products that need to inject specific knowledge into models (customer data, proprietary facts, updated information), MixSD means you can do that without watching the model's general abilities degrade—which directly impacts production quality and user experience.

28. MementoGUI: Learning Agentic Multimodal Memory Control for Long-Horizon GUI Agents

    Ziyun Zeng, Hang Hua, Bocheng Zou, Mu Cai, Rogerio Feris, Jiebo Luo - 4 upvotes - arXiv

    GUI agents (AI systems that control computers by clicking and typing) struggle with long tasks because they either keep too many screenshots (which confuses the model) or lose visual details by storing only text. MementoGUI adds a smart memory layer that learns what screenshots and past interactions are actually useful to remember—saving compressed visual snippets and summaries of key steps, then retrieving relevant past actions when needed. Testing shows this memory system makes agents significantly better at multi-step tasks without requiring changes to the underlying agent.

    Why it matters: If you're building a product that uses AI to automate desktop workflows or web interactions, this technique lets you handle longer, more complex tasks without the model getting confused or losing context—directly improving how much automation actually works end-to-end.

29. Agent Bazaar: Enabling Economic Alignment in Multi-Agent Marketplaces

    Seth Karten, Cameron Crow, Chi Jin - 4 upvotes - arXiv

    Researchers built a simulation where AI agents act as buyers and sellers in online marketplaces, then tested whether current language models could keep markets stable and honest. They found two major failure modes: AI firms accidentally crash markets by constantly undercutting each other on price, and deceptive agents create fake seller accounts to flood markets with scams. They then trained a smaller model using reinforcement learning (showing AI agents which decisions led to better outcomes) on scenarios of increasing difficulty, which performed better than most commercial models at maintaining market health.

    Why it matters: If you're deploying AI agents to interact in real marketplaces or business systems, you need to test whether they'll accidentally destabilize prices or enable fraud at scale—not just whether they answer questions well.

30. FINESSE-Bench: A Hierarchical Benchmark Suite for Financial Domain Knowledge and Technical Analysis in Large Language Models

    Dmitry Stanishevskii, Nini Kamkia, Alexey Khoroshilov, Dmitry Zmitrovich, Denis Kokosinskii, Zhirayr Hayrapetyan, Andrei Kalmykov - 4 upvotes - arXiv

    Researchers built FINESSE-Bench, a test suite with 3,993 financial questions organized by difficulty level (from foundational to expert-level, mimicking real professional certifications like the CFA exam). They used it to measure how well large language models actually understand finance across different domains—from reading financial reports to making trading decisions—and found that existing tests don't capture how performance drops as questions get harder or whether models can handle specialized financial tasks.

    Why it matters: If you're building financial AI products, you now have a standardized way to verify your models can actually handle professional-grade financial reasoning before deploying them in real decision-making contexts.

31. Incantation: Natural Language as the Action Interface for Multi-Entity Video World Models

    Shangwen Zhu, Qianyu Peng, Zhao Pu, Zhilei Shu, Xiangrui Ke, Zhaohu Xing, Zizhao Tong, Zeqing Wang, Xinyu Cui, Huangji Wang, Jian Zhao, Yeying Jin, Fan Cheng, Ruili Feng - 3 upvotes - arXiv

    Researchers built a video generator that creates realistic game footage by taking natural language commands (like 'the knight moves left while the boss attacks') instead of technical inputs like button codes or animation IDs. The system can control multiple characters simultaneously and apply the same commands across different games without retraining — for example, telling a character to 'dodge' works whether it's in Elden Ring or King of Fighters — and it runs fast enough to stream 2-hour videos in real-time.

    Why it matters: If you're building interactive game engines or AI agents, natural language control removes the friction of mapping abstract commands to specific entities, letting you build systems that generalize across different game rules and characters without starting from scratch each time.

32. DexHoldem: Playing Texas Hold'em with Dexterous Embodied System

    Feng Chen, Tianzhe Chu, Li Sun, Pei Zhou, Zhuxiu Xu, Shenghua Gao, Yuexiang Zhai, Yanchao Yang, Yi Ma - 2 upvotes - arXiv

    Researchers built a benchmark where a robot hand (ShadowHand) plays Texas Hold'em by manipulating cards on a table—requiring it to see the game state, decide what action to take, physically execute it, and keep the table usable for future moves. They collected 1,470 human-controlled demonstrations of 14 different card-handling skills, then tested both specialized hand-control policies and vision models on the task, finding that current systems struggle: the best hand controller succeeded only 61% of the time, and even the best vision models correctly understood the full game state just 34% of the time.

    Why it matters: If you're building embodied AI systems, this reveals that individual skills (good card handling) and individual perception (recognizing cards) don't automatically compose into working agents—errors compound in closed loops, so you need to test and measure integration, not just components.

33. Actionable World Representation

    Kunqi Xu, Jitao Li, Jianglong Ye, Tianshu Tang, Isabella Liu, Sifei Liu, Xueyan Zou - 2 upvotes - arXiv

    Researchers built WorldString, a system that learns to represent how real objects change and respond to actions by watching point cloud or video data. Unlike existing approaches that either generate videos or reconstruct scenes, WorldString explicitly models what states an object can be in and how those states connect—think of it as learning a digital twin of a physical object that understands all its possible configurations.

    Why it matters: If you're building a robot or physical AI system, you need a way to predict how objects will respond to actions; this gives you a reusable representation you can plug into planning and control systems instead of training from scratch each time.

34. SafeDiffusion-R1: Online Reward Steering for Safe Diffusion Post-Training

    Komal Kumar, Ankan Deria, Abhishek Basu, Fahad Shamshad, Hisham Cholakkal, Karthik Nandakumar - 2 upvotes - arXiv

    Researchers created a way to make image diffusion models (like Stable Diffusion) safer by using online reinforcement learning during post-training, rather than requiring expensive human-labeled datasets of safe/unsafe examples. Instead of training separate safety models, they steer the model's internal text representations away from unsafe directions and toward safe ones, letting it learn from diverse prompts without forgetting how to generate good images—reducing unsafe content by 62% while actually improving image quality.

    Why it matters: If you're deploying generative image models, you can now add safety guardrails without collecting paired training data or retraining specialized safety models, making it cheaper to iterate on safety without degrading user-facing generation quality.

35. A2RBench: An Automatic Paradigm for Formally Verifiable Abstract Reasoning Benchmark Generation

    Qingchuan Ma, Yuexiao Ma, Yongkang Xie, Tianyu Xie, Xiawu Zheng, Rongrong Ji - 2 upvotes - arXiv

    Researchers built A2RBench, an automated system that generates abstract reasoning tasks (like pattern-matching puzzles) by having AI models create them, then verifies the tasks are actually solvable by checking if reversing the solution brings you back to the start. They tested this on major LLMs and found they're surprisingly bad at abstract reasoning—top models scored 39.8% versus humans at 68.5%—and struggle especially with 3D reasoning tasks.

    Why it matters: If you're building products that rely on LLMs for logical reasoning or problem-solving, this reveals a real capability gap you should account for in your system design, rather than assuming the model can handle abstract reasoning at human levels.

36. Symmetry-Compatible Principle for Optimizer Design: Embeddings, LM Heads, SwiGLU MLPs, and MoE Routers

    Tim Tsz-Kit Lau, Weijie Su - 1 upvotes - arXiv

    The researchers noticed that popular optimizers like Adam update neural network weights in a coordinate-by-coordinate way, which ignores the geometric symmetries built into modern architectures. They designed a new principle: each type of weight matrix should be updated in a way that respects its specific symmetries (for example, embedding matrices have different symmetries than standard weight matrices). They derived custom update rules for embeddings, language model heads, MLP layers, and mixture-of-experts routers, then tested these on several language models and found they consistently lowered final training loss compared to standard Adam.

    Why it matters: If you're training large language models, swapping in symmetry-aware optimizers for your existing AdamW could reduce training loss without changing your architecture or data — essentially getting better models for the same compute budget.

37. Evaluating Cognitive Age Alignment in Interactive AI Agents

    Yifan Shen, Jiawen Zhang, Jian Xu, Junho Kim, Ismini Lourentzou, Xu Cao, Meihuan Huang - 1 upvotes - arXiv

    Researchers created ChildAgentEval, a test suite that measures how well AI agents perform on tasks matched to specific child development stages (based on the Wechsler Intelligence Scale). They found that current AI agents fail at many simple tasks that children easily solve, revealing gaps between what looks impressive in AI systems and what actually works for basic reasoning.

    Why it matters: If you're building AI agents for real-world use, this shows you need to test against concrete capability baselines—your model might look smart in benchmarks but fail on reasoning tasks a 6-year-old handles automatically.

38. SNLP: Layer-Parallel Inference via Structured Newton Corrections

    Ligong Han, Kai Xu, Hao Wang, Akash Srivastava - 1 upvotes - arXiv

    Language models process one layer at a time, which creates a speed bottleneck. Researchers treated this layer-by-layer computation as a math problem that could be solved in parallel using Newton's method (a technique for finding solutions iteratively), then trained models to work well with this parallel approach. They achieved 2.3x speedup on inference while actually improving output quality on some measures.

    Why it matters: If you're deploying language models where latency matters, this gives you a concrete way to make inference faster without retraining from scratch—though you'd need to train new models with their regularization method to get the full benefits.

39. OSCAR: Offline Spectral Covariance-Aware Rotation for 2-bit KV Cache Quantization

    Zhongzhu Zhou, Donglin Zhuang, Jisen Li, Ziyan Chen, Shuaiwen Leon Song, Ben Athiwaratkun, Xiaoxia Wu - 1 upvotes - arXiv

    When running large language models on long texts, storing the key-value (KV) cache data uses lots of memory. This paper proposes OSCAR, which compresses KV cache to 2-bit integers (INT2) by first analyzing what patterns the attention mechanism actually uses, then rotating the data to align with those patterns before compression. The team built a working system with custom hardware kernels and tested it on reasoning models up to 358B parameters—it achieves 8x memory savings and up to 7x throughput gains while keeping accuracy close to uncompressed models, even on 128K token contexts.

    Why it matters: If you're deploying large models for long-context applications (like document processing or reasoning tasks), OSCAR lets you serve 8x more data in the same GPU memory or run much faster inference, directly improving cost-per-query and latency without rebuilding your serving infrastructure.

40. E-PMQ: Expert-Guided Post-Merge Quantization with Merged-Weight Anchoring

    Wenjun Wang, Yanggan Gu, Shuo Cai, Yuanyi Wang, Pengkai Wang, Jianmin Wu, Hongxia Yang - 1 upvotes - arXiv

    When you combine multiple specialized AI models into one (model merging) and then compress it to use less memory (quantization), the two processes interfere with each other and hurt performance. The researchers built E-PMQ, a method that guides the compression step by referencing the original specialized models, which prevents this interference and lets them squeeze merged models down to 4-bit precision while keeping 73-83% of the original accuracy across multiple tasks.

    Why it matters: If you're deploying multiple task-specific models, you can now merge them into a single compact model instead of running separate models or serving multiple copies — cutting infrastructure costs without rebuilding your whole system.

41. AgentKernelArena: Generalization-Aware Benchmarking of GPU Kernel Optimization Agents

    Sharareh Younesian, Wenwen Ouyang, Sina Rafati, Mehdi Rezagholizadeh, Sharon Zhou, Ji Liu, Yue Liu, Yuchen Yang, Hao Li, Ziqiong Liu, Dong Li, Vikram Appia, Zhenyu Gu, Emad Barsoum - 1 upvotes - arXiv

    Researchers created AgentKernelArena, a benchmark to test AI coding agents on their ability to optimize GPU kernels (the low-level code that makes deep learning fast). They tested agents like Claude and Cursor on 196 real optimization tasks, measuring not just whether the code works, but whether optimizations actually transfer when the agent encounters new input sizes it never trained on—and found that agents often bake in assumptions about specific sizes, causing failures on unseen configurations.

    Why it matters: If you're building products that auto-generate or optimize GPU code, this benchmark reveals a critical gap: your agent might look good on test cases but fail in production when real users feed it different data shapes, so you need to actively test generalization, not just correctness.

42. Geometric Phase Transition Enables Extreme Hippocampal Memory Capacity

    Prashant C. Raju - 1 upvotes - arXiv

    Researchers compared the brains of food-caching birds (chickadees) to non-caching birds (zebra finches) and found that the caching birds' memory centers had neurons arranged in a highly organized, rigid geometric pattern—like a crystal—while non-caching birds had disorganized patterns. This geometric rigidity, created by excitatory neurons building structure and inhibitory neurons cleaning up noise, allows the caching birds to remember over 100 times more locations using the same number of brain cells, though it requires redundancy (multiple neurons encoding the same memory) to stay stable against biological noise.

    Why it matters: If you're building memory systems into AI models, this suggests that raw neuron count matters less than *how those neurons are organized*—you might achieve massive capacity improvements by engineering the geometric structure of your representations rather than just scaling up parameters.

43. Auditing Multimodal LLM Raters: Central Tendency Bias in Clinical Ordinal Scoring

    Jiaqing Zhang, Sandeep Elluri, Bhanu Cherukuvada, Yonah Joffe, Jessica Sena, Miguel Contreras, Scott Siegel, Subhash Nerella, Catherine Price, Parisa Rashidi - 1 upvotes - arXiv

    Researchers tested whether multimodal AI models (LLMs that can read images and text) can reliably score a cognitive screening test (Clock Drawing Test) on a standard clinical scale from 0–5. They found that while these AI models perform similarly to traditional ML models on overall accuracy, they all suffer from a consistent bias: they cluster predictions toward the middle of the scale, avoiding extreme scores. This means they wrongly predict middle scores when the truth is very low (0–1) or very high (4–5)—exactly where doctors need accuracy most to catch cognitive decline.

    Why it matters: If you're building a clinical AI tool using LLM raters, you cannot deploy them as-is even if their average accuracy looks good—you must add explicit calibration and test for this middle-bias before it causes misdiagnosis in screening workflows.

44. SCICONVBENCH: Benchmarking LLMs on Multi-Turn Clarification for Task Formulation in Computational Science

    Nithin Somasekharan, Youssef Hassan, Shiyao Lin, Gihan Panapitiya, Patrick Emami, Anurag Acharya, Sameera Horawalavithana, Shaowu Pan - 0 upvotes - arXiv

    Researchers built a benchmark to test whether AI assistants can clarify poorly-defined scientific questions through conversation before attempting to solve them. They tested current LLMs on four domains (fluid mechanics, materials science, etc.) and found that even the best models only fix about half of vague requests, and often make hidden assumptions rather than asking users for clarification.

    Why it matters: If you're building an AI tool for scientists or engineers, it needs to ask clarifying questions when a request is incomplete or contradictory—not just assume and proceed, which could lead to wrong answers that waste time or cause mistakes.

45. Monitoring the Internal Monologue: Probe Trajectories Reveal Reasoning Dynamics

    Maciej Chrabąszcz, Aleksander Szymczyk, Marcin Sendera, Tomasz Trzciński, Sebastian Cygert - 0 upvotes - arXiv

    Researchers studied how to monitor what large AI reasoning models will do by examining their hidden thought process (Chain of Thought) as it unfolds token-by-token. They found that tracking how a model's internal 'confidence' in a concept changes throughout its reasoning—rather than just checking the final answer—better predicts whether the model will behave safely or reach the right conclusion, using signal processing techniques to extract patterns like volatility and trends from these trajectories.

    Why it matters: If you're building AI systems that need safety guarantees, you can now monitor model behavior during reasoning without running expensive separate evaluations, catching risky outputs before they happen by watching the internal reasoning process evolve.

46. GRASP: Learning to Ground Social Reasoning in Multi-Person Non-Verbal Interactions

    Junho Kim, Xu Cao, Houze Yang, Bikram Boote, Ana Jojic, Fiona Ryan, Bolin Lai, Sangmin Lee, James M. Rehg - 0 upvotes - arXiv

    Researchers created GRASP, a dataset of 290K questions about multi-person videos paired with detailed annotations of eye gaze and pointing gestures—the subtle non-verbal cues that show who's actually interacting with whom. They also developed a training technique (Social Grounding Reward) that teaches AI models to pay attention to these cues when answering questions about social interactions, and showed this approach improves performance without breaking the model's ability to handle related tasks.

    Why it matters: If you're building video understanding features (moderation, accessibility, security), your model currently can't tell who's actually communicating with whom in group settings—this gives you a way to fix that by training on real interaction patterns.

47. TopoPrimer: The Missing Topological Context in Forecasting Models

    Zara Zetlin, Kayhan Moharreri, Maria Safi - 0 upvotes - arXiv

    TopoPrimer adds information about the overall shape and structure of time series data (computed once using math called persistent homology) to any forecasting model. This extra context helps models predict better, especially when data is sparse, seasonal spikes occur, or you're forecasting for new items with no history—with improvements up to 7.3% on benchmark datasets.

    Why it matters: If you're building a forecasting product, this means you can wrap TopoPrimer around your existing models as a lightweight layer to get immediate accuracy gains without retraining, particularly in the messy real-world cases where data is patchy or new.

48. AR-VLA: True Autoregressive Action Expert for Vision-Language-Action Models

    Yutong Hu, Jan-Nico Zaech, Nikolay Nikolov, Yuanqi Yao, Sombit Dey, Giuliano Albanese, Renaud Detry, Luc Van Gool, Danda Paudel - 0 upvotes - arXiv

    Researchers built a robot control system that generates smooth, continuous sequences of movements while remembering what it did in previous steps—unlike most current approaches that treat each new camera frame as a fresh start with no memory. The system decouples the fast action-generation part from the slower vision-language reasoning part, letting them be trained separately and then combined, and it includes a mechanism to account for the delay between what the camera sees and when actions actually execute. On robot manipulation tasks, it produces smoother, more coordinated movements than reactive systems while maintaining similar or better success rates.

    Why it matters: If you're building robot systems or embodied AI products, this shows a concrete architecture for generating temporally smooth, physically coherent actions instead of jerky frame-by-frame predictions—which could make robots significantly more reliable at real-world tasks.