🔥 AstraFlow: Dataflow-Oriented Reinforcement Learning for Agentic LLMs

💡 The paper introduces AstraFlow, a dataflow-oriented reinforcement learning system designed to improve the efficiency and scalability of large language model agents. The problem addressed is that current reinforcement learning systems are prohibitively expensive and struggle to support complex workloads, such as multi-policy collaborative training, while efficiently using diverse compute resources.

The authors propose AstraFlow as a solution, which replaces conventional trainer-centered control with principled component abstractions. In AstraFlow, rollout services, dataflow management, and training are decoupled into autonomous components, allowing the system to natively support complex multi-policy agentic RL workloads and efficiently exploit diverse compute resources.

The results show that AstraFlow supports multi-policy training, elastic scaling, heterogeneous cross-region execution, and composable data algorithms without requiring system-level code changes. The system achieves comparable or better accuracy than existing RL systems while speeding up training time by 2.7 times in multi-policy collaborative training. The evaluation is done across various workloads, including math, code, search, and AgentBench, demonstrating the system's versatility and efficiency.

Overall, AstraFlow's contributions include its ability to efficiently support complex workloads, scale to large language model agents, and provide a principled abstraction for reinforcement learning system components, making it a significant advancement in the field of reinforcement learning for large language models.

📅 Published on May 15

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2605.15565
• PDF: https://arxiv.org/pdf/2605.15565
• Project Page: https://infini-ai-lab.github.io/astraflow/

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#DataflowOrientedRL #ReinforcementLearningForLLMs #AgenticLanguageModels #LargeLanguageModelAgents #ScalableRLSystems

🔥 SAM 3: Segment Anything with Concepts

💡 The paper introduces Segment Anything Model 3, a unified model that detects, segments, and tracks objects in images and videos based on concept prompts. The model achieves state-of-the-art performance in promptable concept segmentation and tracking by leveraging a unified model architecture with decoupled recognition and localization. The concept prompts can be short noun phrases, image exemplars, or a combination of both, and the model returns segmentation masks and unique identities for all matching object instances.

To advance promptable concept segmentation, the authors built a scalable data engine that produces a high-quality dataset with 4 million unique concept labels, including hard negatives, across images and videos. The model consists of an image-level detector and a memory-based video tracker that share a single backbone. The recognition and localization are decoupled with a presence head, which boosts detection accuracy.

The results show that Segment Anything Model 3 doubles the accuracy of existing systems in both image and video promptable concept segmentation, and improves previous capabilities on visual segmentation tasks. The authors also open source Segment Anything Model 3 along with a new benchmark for promptable concept segmentation, called Segment Anything with Concepts.

The main contributions of the paper are the introduction of a unified model architecture that achieves state-of-the-art performance in promptable concept segmentation and tracking, the creation of a large-scale dataset with unique concept labels, and the development of a new benchmark for evaluating promptable concept segmentation models. Overall, the paper presents a significant advancement in the field of computer vision and object segmentation, enabling more accurate and efficient detection, segmentation, and tracking of objects in images and videos based on concept prompts.

📅 Published on Nov 20, 2025

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2511.16719
• PDF: https://arxiv.org/pdf/2511.16719
• Project Page: https://ai.meta.com/sam3/

🤖 Models citing this paper:
• https://huggingface.co/AllanVester/SAM3.1-CoreML-FP16
• https://huggingface.co/AllanVester/SAM3.1-CoreML
• https://huggingface.co/embedl/sam3

🚀 Spaces citing this paper:
• https://huggingface.co/spaces/kith777/rag_agent

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#ComputerVision #ObjectSegmentation #ConceptLearning #ImageTracking #PromptableSegmentation

🔥 PaperFit: Vision-in-the-Loop Typesetting Optimization for Scientific Documents

💡 The paper addresses the problem of visual typesetting optimization for scientific documents, which involves transforming a compilable LaTeX paper into a visually polished and page-budget-compliant PDF. The authors argue that existing methods, such as rule-based tools and text-only language models, are insufficient because they operate only on source code and log files, and are unable to predict or verify the two-dimensional layout consequences of their changes.

To solve this problem, the authors introduce a vision-in-the-loop agent called PaperFit, which iteratively renders pages, diagnoses defects, and applies constrained repairs. The authors also formalize the problem as Visual Typesetting Optimization, and introduce a five-category taxonomy of typesetting defects to guide diagnosis.

To evaluate PaperFit, the authors construct a benchmark called PaperFit-Bench, which consists of 200 papers across 10 venue templates and 13 defect types at different difficulty levels. The results of extensive experiments show that PaperFit outperforms all baselines by a large margin, demonstrating the effectiveness of vision-in-the-loop optimization for visual typesetting optimization.

The authors conclude that bridging the gap from compilable source to publication-ready PDF requires vision-in-the-loop optimization, and that Visual Typesetting Optimization constitutes a critical missing stage in the document automation pipeline. Overall, the paper contributes a new approach to visual typesetting optimization, a benchmark for evaluating VTO methods, and a demonstration of the importance of vision-in-the-loop optimization for producing high-quality scientific documents.

📅 Published on May 11

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2605.10341
• PDF: https://arxiv.org/pdf/2605.10341

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#VisionInLoopTypesetting #ScientificDocumentOptimization #LaTeXTypesetting #DocumentLayoutOptimization #TypesettingAutomation

🙏💸 500$ FOR THE FIRST 500 WHO JOIN THE CHANNEL! 🙏💸

Join our channel today for free! Tomorrow it will cost 500$!

https://xn--r1a.website/+-WZeIeP8YI8wM2E6

You can join at this link! 👆👇

https://xn--r1a.website/+-WZeIeP8YI8wM2E6

🔥 EnvFactory: Scaling Tool-Use Agents via Executable Environments Synthesis and Robust RL

💡 The paper introduces EnvFactory, a framework that automates the creation of executable tool environments and natural multi-turn trajectories for training large language models with agentic reinforcement learning. The problem addressed is that current approaches to equip large language models with tool-use capabilities are limited by the lack of scalable and robust execution environments and the scarcity of realistic training data. Existing methods rely on costly real-world APIs, simulators that are prone to hallucination, or synthetic environments that are often single-turn or based on pre-collected documents.

EnvFactory addresses these challenges by autonomously exploring and verifying stateful, executable tool environments from authentic resources, and synthesizing natural multi-turn trajectories through topology-aware sampling and calibrated refinement. This approach produces grounded queries with implicit intents, which are more effective for reinforcement learning training.

The method involves using a fully automated framework to generate environments and trajectories. The results show that using only 85 verified environments across 7 domains, EnvFactory generates a large number of trajectories, achieving superior training efficiency and downstream performance. The framework improves the performance of Qwen3-series models by up to 15 percent on certain benchmarks, and by up to 8.6 percent and 6 percent on other conversational benchmarks.

The contributions of the paper are that EnvFactory provides a scalable, extensible, and robust foundation for agentic reinforcement learning, and that it achieves superior performance with fewer resources compared to prior work. The framework has the potential to advance the field of large language models and their application to real-world problems. Overall, the paper presents a significant contribution to the field of artificial intelligence and natural language processing.

📅 Published on May 18

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2605.18703
• PDF: https://arxiv.org/pdf/2605.18703

🤖 Models citing this paper:
• https://huggingface.co/LARK-Lab/EnvFactory-1.7B
• https://huggingface.co/LARK-Lab/EnvFactory-4B
• https://huggingface.co/LARK-Lab/EnvFactory-8B

📊 Datasets citing this paper:
• https://huggingface.co/datasets/LARK-Lab/EnvFactory-SFT-ALL
• https://huggingface.co/datasets/LARK-Lab/EnvFactory-SFT-FILTERED
• https://huggingface.co/datasets/LARK-Lab/EnvFactory-RL

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#ExecutableEnvironments #ToolUseAgents #AgenticReinforcementLearning #RobustRL #LanguageModelTraining

🔥 Semantic Generative Tuning for Unified Multimodal Models

💡 The paper addresses the issue of unified multimodal models where visual understanding and generation are not well aligned due to separate training objectives. The prevailing approach of optimizing understanding through text signals and generation through pixel objectives leads to isolated representation spaces. To bridge this gap, the authors propose a novel approach called Semantic Generative Tuning, which uses semantic segmentation as a generative proxy to align and synergize multimodal capabilities.

The method involves formulating hierarchical visual tasks as generative proxies, with a focus on high-level semantic tasks like image segmentation. The authors find that segmentation provides structural semantics that enhance both vision-centric perception and generative layout fidelity. Unlike low-level tasks, segmentation does not distract models with texture details, making it an optimal proxy.

The results show that Semantic Generative Tuning fundamentally improves feature linear separability and optimizes visual-textual attention allocation patterns. Extensive evaluations demonstrate that this approach consistently improves both multimodal comprehension and generative fidelity across mainstream benchmarks. The authors provide a systematic investigation into generative post-training and introduce a new paradigm that leverages segmentation to align multimodal capabilities. The code for the proposed method is made available for further research and development. Overall, the paper presents a significant contribution to the field of unified multimodal models by introducing a novel approach that enhances multimodal alignment and performance.

📅 Published on May 18

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2605.18714
• PDF: https://arxiv.org/pdf/2605.18714
• Project Page: https://song2yu.github.io/SGT/

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#MultimodalLearning #SemanticSegmentation #GenerativeModels #UnifiedMultimodalModels #MultimodalRepresentationLearning

🔥 GoLongRL: Capability-Oriented Long Context Reinforcement Learning with Multitask Alignment

💡 The paper introduces GoLongRL, a new approach to long context reinforcement learning that focuses on capability oriented data construction and multitask alignment. The existing methods for long context reinforcement learning often result in homogeneous task coverage and reward formulations that do not accurately reflect real world requirements. To address this issue, the authors propose two main contributions.

First, they introduce a capability oriented data construction method that involves creating a dataset of 23,000 reinforcement learning samples with verifiable rewards, spanning 9 task types, each with its own evaluation metric. The dataset is openly released along with the construction pipeline and training code. The results show that this dataset outperforms a closed source dataset called QwenLong-L1.5 under the same training setup.

Second, the authors propose a new method called TMN-Reweight for heterogeneous multitask optimization. This method combines task level mean normalization for cross task reward scale alignment with difficulty adaptive weighting for more reliable advantage estimation. The results show that TMN-Reweight improves average performance over the vanilla GRPO method, while preserving or improving general capabilities across evaluations.

The authors also train a model called Qwen3-30B-A3B on the new dataset and achieve long context performance comparable to other state of the art models, such as DeepSeek-R1-0528 and Qwen3-235B-A22B-Thinking-2507. This suggests that the new dataset and TMN-Reweight method can substantially improve long context capability. Overall, the paper presents a new approach to long context reinforcement learning that focuses on capability oriented data construction and multitask alignment, and achieves state of the art results.

📅 Published on May 19

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2605.19577
• PDF: https://arxiv.org/pdf/2605.19577
• Project Page: https://huggingface.co/collections/Kwai-Klear/golongrl

🤖 Models citing this paper:
• https://huggingface.co/Kwai-Klear/GoLongRL-4B
• https://huggingface.co/Kwai-Klear/GoLongRL-30B-A3B

📊 Datasets citing this paper:
• https://huggingface.co/datasets/Kwai-Klear/GoLongRL

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#ReinforcementLearning #LongContextLearning #MultitaskAlignment #CapabilityOrientedLearning #DeepLearning

🔥 Code as Agent Harness

💡 The paper discusses the concept of code as agent harness, where large language models are used as operational substrates for agent reasoning and execution in agentic systems. The authors argue that code is no longer just a target output, but serves as a unified infrastructure layer across multiple domains and applications. They introduce a unified view that centers code as the basis for agent infrastructure, and organize their survey around three connected layers: the harness interface, harness mechanisms, and scaling the harness.

The harness interface layer explores how code connects agents to reasoning, action, and environment modeling. The harness mechanisms layer examines planning, memory, and tool use for long-horizon execution, as well as feedback-driven control and optimization. The scaling layer discusses how to extend the harness from single-agent systems to multi-agent settings, where shared code artifacts support multi-agent coordination, review, and verification.

The authors summarize representative methods and practical applications of code as agent harness, including coding assistants, GUI/OS automation, embodied agents, scientific discovery, personalization and recommendation, DevOps, and enterprise workflows. They also outline open challenges for harness engineering, such as evaluation beyond final task success, verification under incomplete feedback, regression-free harness improvement, consistent shared state across multiple agents, human oversight for safety-critical actions, and extensions to multimodal environments.

The paper provides a unified roadmap toward executable, verifiable, and stateful AI agent systems by centering code as the harness of agentic AI. The authors demonstrate the potential of code as agent harness to enable more efficient, adaptable, and reliable agent systems, and highlight the need for further research in harness engineering to address the open challenges and limitations of this approach. Overall, the paper contributes to the development of agentic systems by providing a new perspective on the role of code in agent infrastructure and highlighting the potential benefits and challenges of this approach.

📅 Published on May 18

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2605.18747
• PDF: https://arxiv.org/pdf/2605.18747

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#AgenticSystems #LargeLanguageModels #AgentReasoning #CodeAsInfrastructure #ArtificialIntelligence

🔥 TideGS: Scalable Training of Over One Billion 3D Gaussian Splatting Primitives via Out-of-Core Optimization

💡 The paper introduces TideGS, a scalable training framework for 3D Gaussian Splatting with over one billion primitives on a single GPU. The problem with training 3D Gaussian Splatting at a large scale is that it is memory-bound, with each Gaussian primitive having a large attribute vector that quickly exceeds GPU capacity. Prior systems were limited to tens of millions of Gaussians on commodity single-GPU hardware.

The authors observe that 3D Gaussian Splatting training is inherently sparse and trajectory-conditioned, meaning that each iteration only activates the Gaussians visible from the current camera batch. This insight allows the authors to manage parameters across an SSD-CPU-GPU hierarchy using three techniques: block-virtualized geometry for spatial locality, a hierarchical asynchronous pipeline to overlap I/O with computation, and trajectory-adaptive differential streaming that transfers only incremental working-set deltas between iterations.

The TideGS framework enables training with over one billion Gaussians on a single 24 GB GPU, achieving the best reconstruction quality among evaluated single-GPU baselines on large-scale scenes. This is a significant improvement over prior out-of-core baselines, which were limited to approximately 100 million Gaussians, and standard in-memory training, which was limited to approximately 11 million Gaussians. The results demonstrate that TideGS can scale beyond prior systems, making it a promising solution for large-scale 3D Gaussian Splatting applications.

📅 Published on May 19

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2605.20150
• PDF: https://arxiv.org/pdf/2605.20150
• Project Page: https://sponge-lab.github.io/TideGS/

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#3DGaussianSplatting #ScalableDeepLearning #OutofCoreOptimization #GPUAcceleration #ComputerVisionTechniques

🔥 Uni-Edit: Intelligent Editing Is A General Task For Unified Model Tuning

💡 The paper introduces Uni-Edit, a novel intelligent image editing task designed to enhance unified multimodal models' understanding, generation, and editing capabilities. Currently, these models are trained using complex multi-stage pipelines and mixed multi-task training, which can lead to performance trade-offs rather than mutual reinforcement. To address this issue, Uni-Edit proposes a single task, single training stage, and single dataset approach. The authors identify image editing as an ideal general task that naturally demands both visual understanding and generation. However, existing editing data relies on simplistic instructions, which underutilize a model's understanding capacity.

To overcome this limitation, the authors develop an automated and scalable data synthesis pipeline that transforms diverse visual question answering data into complex and effective editing instructions with embedded questions and nested logic. This pipeline yields Uni-Edit-148k, a dataset pairing diverse reasoning-intensive instructions with high-quality edited images. The authors conduct extensive experiments on two models, BAGEL and Janus-Pro, and demonstrate that tuning solely on Uni-Edit achieves comprehensive enhancements across all three capabilities without any auxiliary operations. The results show that Uni-Edit is a general task that can unify and improve the performance of unified multimodal models, making it a valuable contribution to the field of data science and artificial intelligence.

📅 Published on May 20

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2605.21487
• PDF: https://arxiv.org/pdf/2605.21487
• Project Page: https://zhengdian1.github.io/Uni-Edit-proj/

🤖 Models citing this paper:
• https://huggingface.co/Uni-Edit/Uni-Edit-BAGEL

📊 Datasets citing this paper:
• https://huggingface.co/datasets/Uni-Edit/Train-Data

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#IntelligentImageEditing #UnifiedMultimodalModels #ImageEditingTasks #MultimodalModelTuning #MultitaskLearningApproaches

🔥 PEEK: Context Map as an Orientation Cache for Long-Context LLM Agents

💡 The paper introduces PEEK, a system designed to improve the performance of large language model agents operating over long and recurring external contexts, such as document corpora and code repositories. The problem with existing approaches is that they do not preserve reusable orientation knowledge about the recurring context itself, which includes information about what the context contains, how it is organized, and which entities, constants, and schemas have historically been useful.

To address this issue, PEEK uses a context map, a small and constant-sized artifact in the agent's prompt, to cache and maintain this orientation knowledge. The context map is maintained by a programmable cache policy consisting of three modules: a Distiller that extracts transferable knowledge from inference-time signals, a Cartographer that translates it into structured edits, and a priority-based Evictor that enforces a fixed token budget.

The results show that PEEK improves over strong baselines in long-context reasoning and information aggregation tasks by 6.3-34.0 percent, while using 93-145 fewer iterations and incurring 1.7-5.8 times lower cost than the state-of-the-art prompt-learning framework, ACE. Additionally, PEEK improves solving rate and rubric accuracy in context learning tasks by 6.0-14.0 percent and 7.8-12.1 percent, respectively, at 1.4 times lower cost than ACE. These gains generalize across different language models and agent architectures, including OpenAI Codex, a production-grade coding agent. Overall, the paper demonstrates that using a context map helps long-context language model agents interact with recurring external contexts more accurately and efficiently.

📅 Published on May 19

🔗 Links:
• GitHub: https://github.com/huggingface
• arXiv: https://arxiv.org/abs/2605.19932
• PDF: https://arxiv.org/pdf/2605.19932
• Project Page: https://zhuohangu.github.io/blog-post-peek/

━━━━━━━━━━━━━━━━━━━━━━━━
📢 By: https://xn--r1a.website/PaperNexus

#LongContextLLM #ContextMap #OrientationCache #LargeLanguageModelAgents #RecurringContextProcessing