◉OMNI.SOURCE
01 / RESEARCH REPORT

Today's research,
properly prioritized.

Cross-source signals, ranked into a reading flow for the work ahead.

FUTURE / AUDIO BRIEF

Voice blog — coming later

Audio briefings are planned for a future release.

PLANNED
Priority streamChoose a track to view its papers, community signals, lab notes, and repositories
Daily · 2026-08-15

AI Infrastructure

AI infrastructure for distributed training, inference serving, systems, compilers, kernels, and clusters.

01 / Papers

📄 Papers

Topicother

Hmrishav Bandyopadhyay, Xuanchi Ren, Zijian Huang, Jay Zhangjie Wu, Tianshi Cao, Ruilong Li et al.
low · 2026-08-13

Why it matters This work mainly improves distillation and control consistency for autoregressive video models, not training clusters, serving systems, or runtimes; it may help video-generation model trainers, but its direct value for AI infrastructure researchers is limited.

Method brief
01
Problem

Bidirectional full-clip teachers can use future frames and controls that the student cannot access when generating a target.

02
Method

The method uses a causal teacher, scores targets under the student's cached generated prefix, and perturbs unreliable early-training prefixes.

03
Difference

Teacher initialization, student distillation, and inference share one causal information boundary instead of enforcing causality only on the student.

04
Evidence

Experiments cover short- and long-video benchmarks and report leading aggregate performance among autoregressive methods with stronger adherence to time-varying camera controls.

Abstract

Interactive autoregressive video generation demands both low-latency rollouts and precise online control. Few-step distillation accelerates generation by reducing denoising steps, while online control imposes a causal constraint: frames and blocks should depend on history and controls available during generation. Existing video distribution matching distillation (DMD) pipelines, however, often supervise causal few-step students using bidirectional teachers that score complete clips. The score for a target can therefore depend on future frames and controls that were unavailable when the student generated it, misaligning teacher supervision with the student's causal information set. We introduce Context-Matched Distillation (CMD), a causal DMD framework that aligns teacher supervision with the information available when each target is generated. CMD replaces bidirectional full-clip scoring with a causal teacher that evaluates each target without access to future frames or controls. The same causal teacher initializes the few-step student, establishing a consistent causal formulation across teacher training, student distillation, and inference. Beyond aligning the temporal information boundary, Prefix Scoring matches supervision to the student's realized rollout context by evaluating each target under the cached student-generated prefix that produced it. Prefix Corruption further stabilizes training by perturbing unreliable prefixes produced early in training while preserving this target-context alignment. With a simple causal formulation, CMD naturally extends to frame-wise and chunk-wise generation, long video distillation, and camera-conditioned distillation. Experiments demonstrate state-of-the-art aggregate performance among autoregressive methods on both short- and long-video benchmarks, together with substantially improved adherence to time-varying camera controls.

Potential 33noveltyworkloadopen-sourceinsightpresentationinstitution
10 authors2 institutions9 links
Haokai Zhang, Yuhang Ding, Yunshu Zhou, Xinze Du, Shengtao Zhang, Zhiyue Zhao et al.
low · 2026-08-13

Why it matters This has limited direct relevance to AI infrastructure because its main contribution is runtime memory for improving spatial reasoning in frozen vision-language models, not training, serving, or resource management. For researchers interested in parameter-free agent deployment, it offers a design for persisting verified experience and reusing it through retrieval during inference.

Method brief
01
Problem

A frozen vision-language model must improve spatial reasoning without parameter updates or external spatial tools.

02
Method

The system collects predictions and rewards in a verifiable spatial environment, distills lessons through verifier-guided reflection, and manages retrieval with a transfer reliability score.

03
Difference

It injects verified runtime experience as reusable memory instead of updating model parameters or calling tools such as depth estimation.

04
Evidence

Across five spatial benchmarks and four base vision-language models, it reports the highest macro average in every model block and the best accuracy in most of 20 evaluations.

Abstract

Spatial intelligence is becoming a foundation for embodied agents, robotic planning, and multimodal assistants. To improve the spatial reasoning ability of VLM agents, existing work has mainly followed two lines. One line uses post-training methods, such as supervised fine-tuning and reinforcement learning. Another line adopts an agentic paradigm in which the model calls external spatial tools, such as depth estimation and 3D reconstruction tools, to gather intermediate spatial evidence. We study a complementary and underexplored route: Can a frozen VLM agent improve its spatial reasoning through parameter-update-free self-evolution, without depending on external expert spatial tools at inference time? We present Spatial Memory Agent (SMA), an experience-grounded runtime framework that converts verified spatial experience into reusable transferable lessons. In a verifiable spatial environment, SMA queries the frozen VLM, obtains a predicted answer and reward, and uses verifier-guided reflection to distill compact transferable lessons from spatial experience. SMA further assigns each lesson a Transfer Reliability Score (TRS), which is initialized uniformly and calibrated from later retrieval outcomes as visit evidence of future transfer reliability. During read-only deployment, SMA retrieves lessons by semantic filter and similarity-TRS combined ranking, allowing the retrieved memory to guide frozen model inference. Across five representative spatial benchmarks and four base VLMs, SMA achieves the highest macro average in every base-model block and the best accuracy among the evaluated methods in most of the 20 evaluations, establishing a practical parameter-update-free path for spatial self-evolution across the evaluated frozen model scales and environments.

Potential 31noveltyworkloadopen-sourceinsightpresentationinstitution
8 authors0 institutions7 links
Yuyang Yin, Zixiang Li, Longxuan Deng, Hongkai Li, Shifang Zhao, Junnan Liu et al.
low · 2026-08-12

Why it matters This paper targets film, games, and architectural previsualization rather than training, inference serving, or cluster infrastructure. Its direct value for AI-infrastructure work is limited, although its persistent structured state could inform systems for editable generation that avoid rebuilding an entire scene after every change.

Method brief
01
Problem

Existing image and video generation methods lack an explicit world state that supports repeated edits while preserving scene memory.

02
Method

The system constructs a 3D state with prior-guided conflict-aware dual-view initialization, converts user intent into structured state transitions, and refines camera trajectories through render feedback.

03
Difference

Instead of regenerating the full scene for each edit, it maintains reusable scene elements, attributes, and camera configurations as a shared editable world.

04
Evidence

The abstract reports high-quality 3D worlds for video creation and game-like prototyping, but gives no specific metrics or baseline comparisons.

Abstract

Previsualization is an intermediate layer between ideas and production in film, games, architecture, and urban design. It lets creators iteratively refine scenes, actions, cameras, and spatial-temporal dynamics. Yet existing generative methods rely on simple prompts to jointly control all of these factors through one-shot image or video synthesis, offering weak controllability and limited support for iterative editing. Fundamentally, a world comprises multiple elements with geometry, appearance, and other attributes, together with cameras. Different frames are produced through local modifications or recombinations of this shared state, which is otherwise largely reused. Therefore, we argue that the missing component is an explicit and persistent working state. To address this, we present StateFlow, a state-centric framework for generative previsualization. Rather than generating videos in one shot, StateFlow uses an editable 3D world to organize scene structure, evolution, and cameras, while off-the-shelf video models enhance visual quality when higher fidelity is desired. This world is maintained as a persistent structured 3D state of scene elements and camera configurations, serving as the core working representation for previsualization. Built on this insight, StateFlow has three stages to construct, evolve, and access the world state. State construction lifts generated 2D content into a coherent 3D world through prior-guided, conflict-aware dual-view initialization, while State evolution translates user intent into structured state transitions while preserving world memory, avoiding full-scene regeneration for each edit. State access uses render-feedback reflection to refine camera plans into visually feasible trajectories, avoiding reliance on VLM semantics alone. Experiments show that StateFlow produces high-quality 3D worlds for video creation and game-like prototyping.

Potential 28noveltyworkloadopen-sourceinsightpresentationinstitution
12 authors0 institutions11 links
Kuan Xing, Ye Wang, Changyi Gan, Yuheng Li, Thao Nguyen, Yi Chang et al.
low · 2026-08-07

Why it matters This paper mainly addresses intent parsing and style control for artist-grounded image generation, not training, serving, compilers, or cluster infrastructure. Its backend-aware planning and feedback loop have only an indirect systems connection, so it offers limited direct value to an AI-infrastructure researcher.

Method brief
01
Problem

Artist names can trigger recurring motifs, palettes, or period signatures instead of preserving the intended scene and style.

02
Method

Atelier represents artistic intent as a control state containing scene anchors, preserve-or-transform decisions, style hypotheses, artist evidence, and shortcut constraints, then iteratively refines generated candidates.

03
Difference

It combines artist-level knowledge and local patch references with backend-aware generation plans rather than relying only on prompts or retrieval.

04
Evidence

ArtIntentBench evaluates two artists across several generation and shortcut-auditing tasks, and the paper claims gains over prompt, retrieval-augmented, and agent baselines on both open-weight and closed-source generators.

Abstract

Artist-grounded image generation requires more than appending an artist name to a prompt. Image models often respond to artist names through canonical shortcuts, such as recurring motifs, generic palettes, or overrepresented period signatures, rather than preserving the user's intended scene. We introduce Atelier, a shortcut-aware control-state planning framework for artist-grounded image generation. Atelier translates underspecified artistic intent into an explicit control state that separates scene anchors, preserve/transform decisions, style-regime hypotheses, role-bound artist evidence, and shortcut-avoidance constraints. It grounds this state using artist-level knowledge and local patch references, compiles backend-aware generation plans, and iteratively refines candidates through global and local authenticity feedback. We further introduce ArtIntentBench, a benchmark covering Van Gogh and Qi Baishi across artwork re-rendering, period/style-controlled generation, historically unseen subjects, shortcut auditing, and human preference evaluation. Across open-weight and closed-source generators, Atelier improves artist-level style fidelity, preserves source structure more faithfully, and substantially reduces shortcut substitution compared with prompt-engineered, retrieval-augmented, and general-purpose agent baselines. These results suggest that artist-grounded generation is bottlenecked not only by image synthesis, but by the upstream inference of explicit, evidence-grounded artistic controls.

Potential 26noveltyworkloadopen-sourceinsightpresentationinstitution
7 authors3 institutions20 links

AreaInference Systems / Memory and Decoding OptimizationTopicKV cache / long context memory

CategoryAreaInference Systems / Memory and Decoding OptimizationTopicKV cache / long context memory
Yuxuan Zhang, Haozhong Xiong, Yubo Huang, Jiayi Song, Jinpeng Yu, Haofan Wang et al.
high · 2026-08-13

Why it matters This paper treats long-form video generation as a bounded-context streaming problem: a pose-retrieved history block, a permanent anchor, and a rolling window avoid storing the full sequence, while sequence parallelism and operator fusion deliver 19.63 FPS on two H100 GPUs. For inference-system researchers, the design is a useful pattern for keeping memory and per-block latency independent of stream duration; the paper reports nearly stable quality and identity over three minutes, whereas prior systems degrade or require hours of offline computation.

Method brief
01
Problem

Diffusion-based human animation struggles to provide real-time response, long-duration stability, and bounded memory at once.

02
Method

The system adapts a bidirectional DiT into a block-causal generator, distills sampling to three steps, and manages context with Pose-Retrieval Sink Attention.

03
Difference

Its cache combines a permanent first-block sink, a pose-retrieved historical block, and a three-slot rolling window instead of retaining the complete sequence.

04
Evidence

The paper reports 19.63 FPS on two NVIDIA H100 GPUs and nearly constant perceptual quality and identity across a three-minute benchmark.

Abstract

Pose-driven human animation synthesizes a video of a target person from a single reference image and a driving pose stream. Real-time generation is essential for interactive applications such as live streaming, telepresence, and virtual avatars, yet diffusion-based systems require minutes to hours per clip, precluding responsive interaction. We present LiveAnimate, to our knowledge the first animation system to combine real-time streaming with stable long-form generation at billion scale, built on a 14B-parameter video Diffusion Transformer (DiT). A two-stage training pipeline first adapts a pretrained bidirectional DiT into a block-causal autoregressive generator through Reference-Anchored Teacher-Forcing Adaptation, and then reduces the sampling budget to three steps through Block-wise Self-Forcing Distillation. To preserve appearance over extended streams, we introduce Pose-Retrieval Sink Attention (PR-Sink), a bounded KV-cache mechanism combining a Static Sink that permanently anchors the first generated block, a Dynamic Sink that holds a pose-retrieved historical block, and a three-slot Rolling Window. When a pose recurs, PR-Sink restores the relevant appearance context without retaining the entire sequence, so memory and per-block latency remain constant regardless of stream duration. Together with Ulysses sequence parallelism and operator fusion, these designs enable 19.63\,FPS streaming inference on two NVIDIA H100 GPUs. On a three-minute benchmark, LiveAnimate maintains nearly constant perceptual quality and identity from the first 30 seconds to the final minute, while prior systems degrade substantially or require hours of offline computation for the same rollout. These results establish a new operating point in quality, latency, and duration for interactive full-body animation.

Potential 59noveltyworkloadopen-sourceinsightpresentationinstitution
9 authors2 institutions15 links
CategoryAreaInference Systems / Memory and Decoding OptimizationTopicKV cache / long context memory
Yuanyang Yin, Gongxuan Wang, Yifan Zhan, Chuanhao Li, Kaipeng Zhang, Feng Zhao
high · 2026-08-13

Why it matters The system moves persistent world state out of the denoiser context and KV cache into a camera-indexed external bank, so session growth does not directly expand the active context; on one H200 at 384×640, it generates each 1.5-second chunk in 2.11 seconds, linking long-horizon memory with interactive latency.

Method brief
01
Problem

Long sessions make history storage in the denoiser context or KV cache increasingly expensive, while few-step generation inherits limitations from its teacher.

02
Method

It combines an external world-state bank, a sparse-attention long-horizon teacher, and a three-step student trained with a 30-second distribution-matching objective under self-forced rollouts.

03
Difference

The teacher is designed for long-horizon supervision using chunk grouping, selected distant-frame retrieval, and a linear-attention global state rather than serving only as a fixed generator.

04
Evidence

The paper claims reduced long-term drift without classifier-free guidance, 2.11-second generation per 1.5-second chunk on one H200, and leading WBench performance while remaining competitive on VBench-Long and VBench-2.0.

Abstract

Interactive world models must support persistent memory, responsive interaction, and long-horizon generation, yet these requirements place conflicting demands on the model. Maintaining history in the denoiser context or key-value cache incurs growing cost, forcing a trade-off between session length and retained memory, while low-latency interaction relies on few-step generation whose capabilities are bounded by its teacher. Evoke addresses both limitations by externalizing persistent world state and redesigning the teacher for long-horizon interactive generation. Scene geometry is maintained in an external, camera-indexed world state bank, from which only view-relevant information is retrieved, keeping the denoiser context bounded as the session grows. Rather than treating the teacher as a fixed generator, we design it for long-horizon supervision: its sparse attention combines chunk-wise grouping, retrieval of selected distant frames, and a linear-attention global state, yielding linear growth in memory and compute while enabling supervision over long horizons. Such supervision exposes content drift that stays locally plausible within short windows, while per-chunk conditioning enables prompt changes and event control throughout the sequence. A 30-second distribution-matching objective, applied under self-forced rollouts, transfers both capabilities to a three-step student that uses no classifier-free guidance, improving resistance to long-term drift while preserving responsive conditioning. With bounded context and recurrent external memory, Evoke supports open-ended, continuously evolving generation; on a single H200 at 384times 640, each 1.5,s chunk is generated in 2.11,s. As a three-step world model, Evoke achieves state-of-the-art performance on WBench while remaining competitive on VBench-Long and VBench-2.0.

Potential 40noveltyworkloadopen-sourceinsightpresentationinstitution
6 authors3 institutions5 links
Paper / Worth tracking
CategoryAreaInference Systems / Memory and Decoding OptimizationTopicKV cache / long context memory
Bo Liu, Qiang Liu
medium · 2026-08-05

Why it matters Maglev offers a way to bound inference memory without giving up parallel training: inference runs only the decoder, which injects recurrent memory instead of reading the full history. This is relevant to long-context systems constrained by GPU memory, and parameter sharing can reduce model storage while retaining most of the reported gains.

Method brief
01
Problem

Sliding-window attention limits historical context, while full attention increases memory and access costs with sequence length.

02
Method

A full-history prefiller generates memory targets, and a decoder uses sliding-window attention plus recurrent key/value injection to produce fixed-size memories.

03
Difference

The stronger prefiller supervises memory during training but is removed at inference, leaving only the decoder path.

04
Evidence

The abstract reports better validation loss and downstream pretraining benchmarks than sliding-window and latent recurrent Transformer baselines, with most gains preserved under parameter sharing.

Abstract

We introduce , a recurrent Transformer architecture with fixed-size memory that generalizes sliding-window attention while remaining parallelizable during training. consists of two coupled models: a prefiller Q, which leverages full attentionIn practice, we use interleaved full and sliding-window attention for Q, as this yields stronger performance. The essential requirement is that Q be more expressive than P, with access to the full history. to produce memory targets m'_t, and a decoder P, which uses only sliding-window attention and recurrent K/V injection to produce decoder memories m_t for next-token prediction. We train with a memory consistency loss that aligns m_t with m'_t, allowing inference to use P alone. Empirically, improves validation loss and downstream pretraining benchmarks over sliding-window and latent recurrent transformer baselines. Moreover, sharing parameters between P and Q reduces parameter memory while preserving most of the gains.

Potential 30noveltyworkloadopen-sourceinsightpresentationinstitution
2 authors1 institutions1 links

AreaInference Systems / Serving EnginesTopicagent serving systems

CategoryAreaInference Systems / Serving EnginesTopicagent serving systems
Cheng Qian, Wenting Zhao, Liangwei Yang, Heng Wang, Jielin Qiu, Heng Ji et al.
medium · 2026-08-12

Why it matters The work shows that some capability can move from model weights into inference-time code, routing, and output checks, giving serving and orchestration teams a way to improve a target model without retraining it. The evidence is limited to four Theory-of-Mind benchmarks and does not establish latency, cost, or production-serving effects.

Method brief
01
Problem

Conventional capability transfer updates the target model's parameters during training, while this paper tests whether transfer can happen entirely at test time.

02
Method

Each builder model uses 5% of the data for validation and iteratively refines a harness across multiple rounds before evaluating the final harness on the full test set.

03
Difference

The harness moves unstable reasoning into deterministic code and adds benchmark-specific routing and strict answer-format enforcement instead of making the target model reason or sample more.

04
Evidence

Across four Theory-of-Mind benchmarks, average target-model performance rises from 0.49 to 0.91, with the largest gains for weaker target models.

Abstract

Recent work on distillation transfers the capabilities of large models to smaller ones often by updating the latter's parameters, through teacher forcing, on-policy distillation, and related training-time methods. In this paper, we ask whether such transfer can instead occur at test time. We study strong-to-weak scaffolding: whether a stronger builder model can construct inference-time harnesses that help a weaker target model solve tasks more reliably without any parameter updates. Using four representative Theory-of-Mind benchmarks, each builder model uses 5% of the data as a validation set to iteratively refine its harness over multiple rounds, after which the finalized harness is evaluated on the full test set. Empirically, this form of test-time capability transfer is highly effective, nearly doubling average target-model performance from 0.49 to 0.91. Our analysis shows that the gains come primarily from offloading unstable model reasoning into deterministic code, benchmark-specific routing, and strict answer-format enforcement, rather than from encouraging the target model to reason more extensively or sample more broadly. We further find that builder-model reasoning effort improves harness quality monotonically, platform effects are modest relative to the builder model's own capability, and weaker target models receive the largest gains. These results suggest that inference-time harness design is an important complement to conventional training-time distillation, enabling strong models to transfer cognitive structure to weaker models without retraining.

Potential 52noveltyworkloadopen-sourceinsightpresentationinstitution
9 authors1 institutions8 links
CategoryAreaInference Systems / Serving EnginesTopicagent serving systems
Chenhao Dang, Siyuan Xiong, Conghui He, Weijia Li
low · 2026-08-11

Why it matters For agent-serving researchers, this offers a possible way to reduce reliance on expensive closed models by constraining smaller models with reusable skills on consumer GPUs. Its main contribution is skill generation and behavior control, not serving runtime, scheduling, or systems optimization.

Method brief
01
Problem

Small language models need executor-specific skills to perform real-world agent tasks reliably.

02
Method

SKILLER uses a strong model as actor and critic, treats the small-model agent as the environment, and passes all reinforcement-learning signals through natural language.

03
Difference

Rather than directly training the small model, it generates reusable natural-language skills tailored to that model and executor.

04
Evidence

Across five benchmarks, the abstract reports gains of 4.3 to 20.4 points for the 9B model and 1.8 to 13.3 points for the 4B model over four baselines.

Abstract

Agent skills represent a standardized format for packaging procedural knowledge and domain expertise, serving within agent harness systems as an essential mechanism to continually constrain a language model's behavior space for repeatable, high-quality task execution. However, because strong closed-source models entail high inference costs, current popular agent harnesses, such as Codex and OpenClaw, remain prohibitively expensive when deploying these skills to accomplish real-world tasks. The rapid capability enhancement of open-source models deployable on consumer-grade GPUs presents a compelling opportunity to drastically reduce these costs by leveraging skill-based behavioral constraints. Nevertheless, automatically generating effective skills tailored specifically for such compact models remains a significant practical challenge. To address this, we propose SKILLER, a natural-language-driven reinforcement learning framework designed to automatically generate executor-specific skills for small models, which employs a strong model as the actor and critic, treats the small-model agent system as the environment, and propagates all reinforcement learning signals entirely via natural language. Extensive experimental evaluations across five relevant benchmarks using Qwen3.5-9B and Qwen3.5-4B demonstrate that SKILLER outperforms three open-source and one closed-source skill generation or evolution methods, achieving absolute gains ranging from 4.3 to 20.4 percentage points for the 9B model and 1.8 to 13.3 points for the 4B model, while remarkably matching the performance of strong closed-source models on single-skill tasks in SkillsBench. The project is available at https://github.com/DANG-ai/SKILLER.

Potential 43noveltyworkloadopen-sourceinsightpresentationinstitution
4 authors3 institutions3 links
CategoryAreaInference Systems / Serving EnginesTopicagent serving systems
Xingyu Tan, Xiaoyang Wang, Qing Liu, Xiwei Xu, Xin Yuan, Liming Zhu et al.
high · 2026-08-06

Why it matters SkillZip targets an infrastructure bottleneck in agent serving: it can hydrate a dependency-closed subset of a large skill library within a context budget and expand routines only when execution requires them. The reported results make it relevant for systems serving agents with libraries that grow from hundreds to 100K skills and must absorb updates without discarding procedural guarantees.

Method brief
01
Problem

Existing systems retrieve whole skill packages, compress text, and build execution graphs only after retrieval, limiting sub-skill reuse and reliable execution.

02
Method

SkillZip compresses section-level execution graphs by replacing recurring contract-valid motifs with reversible ported macros and hydrates only the required compact context at inference time.

03
Difference

The abstraction preserves boundary signatures, dependency closure, verifier reachability, and source-level expansion while ReZip uses execution evidence to integrate new skills and revise risky macros.

04
Evidence

Experiments on technical and embodied-agent benchmarks report up to 12.2 points over the strongest baseline, a 3.46x compression ratio, 99.2% dependency preservation, and 98.7% verifier reachability.

Abstract

Large Language Models (LLMs) increasingly act as agents whose procedural knowledge is stored in reusable skill packages and loaded at inference time. As skill libraries grow, a central challenge is to expose the smallest sufficient executable context under a limited context budget. Existing systems struggle to reuse routines below the whole-skill level, preserve procedural contracts during compression, keep compressed routines executable and expandable, and update the compressed library as skills evolve. These challenges reveal a unit mismatch: skills are retrieved as packages, compressed as text, and converted into execution graphs only after retrieval, whereas reliable reuse requires a contract-bearing procedural unit. We propose SkillZip, an execution-aware procedural abstraction framework that performs contract-preserving compression over section-level graphs. SkillZip rewrites recurring contract-valid motifs into reversible ported macros while preserving boundary signatures, dependency closure, verifier reachability, and source-level expansion. At inference time, it hydrates a compact, dependency-closed context and expands macros only when required. ReZip further integrates new skills and revises risky macros using execution evidence. Comprehensive experiments1 on technical and embodied agent benchmarks show SkillZip consistently outperforms the strongest baseline by up to 12.2 points, while achieving a 3.46x compression ratio with 99.2% dependency preservation and 98.7% verifier reachability. Scaling analyses further confirm robust retrieval across skill libraries ranging from 200 to 100K skills.

Potential 36noveltyworkloadopen-sourceinsightpresentationinstitution
7 authors0 institutions20 links

AreaTraining Systems / Parallel and Distributed TrainingTopiclarge-scale pretraining systems

CategoryAreaTraining Systems / Parallel and Distributed TrainingTopiclarge-scale pretraining systems
Lei Bai, Jiaqi Cao, Chiyu Chen, Guanzhou Chen, Kai Chen, Guangran Cheng et al.
medium · 2026-08-13

Why it matters This is relevant to engineers building training platforms for scientific agents because it combines multi-task RL, agent rollout, online speculative decoding, and off-policy correction in one pipeline, with explicit attention to stability during long-horizon training. The abstract gives no hardware utilization, throughput, cost, or cluster-scale measurements, so it is more useful as a source of training-system design ideas than as an infrastructure evaluation.

Method brief
01
Problem

The model must handle scientific multimodal understanding, reasoning, generation, tool interaction, and long-horizon tasks.

02
Method

The pipeline starts from scientific multimodal pretraining and applies supervised fine-tuning, multi-task RL, agentic RL, and on-policy distillation.

03
Difference

It extends time-series modeling toward numerical forecasting and adds a separate memory decoder for specialization without changing the frozen 397B backbone.

04
Evidence

The paper reports competitive results across several benchmark groups, while the memory decoder raises the Biology-Instructions average from 56.92 to 60.32.

Abstract

Scientific discovery increasingly requires AI systems that can reason over scientific evidence of heterogeneous modalities, interact with scientific tools and environments, and sustain progress across long task horizons. We present Intern-S2-Preview, a series of scientific agentic foundation models designed to support multimodal scientific understanding, reasoning, generation, and long-horizon tasks. The training pipeline begins with scientific multimodal pre-training over rendered scientific documents, interleaved image-text data, and diverse scientific corpora. Starting from the pretrained checkpoint, we apply a unified post-training pipeline consisting of supervised fine-tuning, scalable multi-task reinforcement learning (RL), black- and white-box agentic RL, and on-policy distillation. This pipeline is supported by practical techniques that improve rollout and training stability and efficiency, including partial rollout with off-policy correction, adaptive length regularization, online speculative decoding, robust multi-task optimization, and trace-aware experience assembly for agentic tasks. At the architecture level, Intern-S2-Preview-397B extends time series modelling from efficient long-sequence understanding to numerical forecasting, while Memory Decoder is studied as a separate memory-augmented path for rapid scientific specialization without modifying the frozen 397B backbone. Evaluations across scientific, multimodal, agentic, and general-purpose benchmarks show that Intern-S2-Preview-397B achieves competitive or leading results in multiple settings. The time series modules improve scientific signal understanding and forecasting on SciTS, while the separate Intern-MemDec-4B extension improves the Biology-Instructions average score from 56.92 to 60.32 without modifying the frozen 397B backbone.

Potential 55noveltyworkloadopen-sourceinsightpresentationinstitution
12 authors0 institutions11 links
Paper / Supporting signal
CategoryAreaTraining Systems / Parallel and Distributed TrainingTopiclarge-scale pretraining systems
Xi Wang, Ziyang Cai, Zheng Zhan, Harry Dong, Ying Fan, Gustavo de Rosa et al.
low · 2026-08-09

Why it matters The change is relatively friendly to inference infrastructure: it keeps the standard transformer and KV cache while adding latent-state feedback with claimed negligible per-token decoding overhead. If reproducible, serving stacks could gain shorter reasoning traces without replacing their cache machinery; however, the paper studies model architecture and training rather than throughput, latency, or cluster efficiency.

Method brief
01
Problem

Standard autoregressive transformers pass only the sampled token to the next step and discard the top-layer hidden state.

02
Method

A gated linear unit fuses the previous top-layer hidden state with the sampled token embedding and feeds the result into the next step.

03
Difference

Training introduces latent feedback late and mixes a small share of deeper feedback passes to preserve parallel teacher forcing.

04
Evidence

Experiments train 1B-parameter models on up to 400B tokens and report gains in validation loss, few-shot evaluation, math and code generation, and instruction tuning.

Abstract

Autoregressive transformers compute along two axes: horizontally across generated tokens, and vertically through model depth. Dense attention gives each token broad horizontal access to the past, but the vertical feedback channel between decoding steps remains narrow: only the sampled token returns to the bottom of the stack, while the top-layer hidden state is discarded. We introduce the full-bandwidth transformer, which widens this channel with latent feedback: at each decoding step, the previous top-layer hidden state is fused with the sampled token embedding through a gated linear unit and fed back as the next input. Latent feedback lets non-verbalized computation re-enter the stack with a renewed depth budget, while preserving the standard transformer architecture, KV cache, and language-modeling objective. To train full-bandwidth transformers without losing parallel teacher forcing, we use a scheduled multi-pass objective that introduces latent feedback late in pretraining and mixes a small fraction of deeper feedback passes for stability. We train 1B-parameter full-bandwidth transformers up to 400B tokens and find that latent feedback improves validation loss, 5-shot language-model evaluation, math and coding generation, and instruction-tuned performance. With negligible per-token decoding overhead, full-bandwidth transformers match or approach standard transformers trained with roughly 1.5times more tokens, and manage to produce shorter reasoning traces at equal or better accuracy.

Potential 37noveltyworkloadopen-sourceinsightpresentationinstitution
8 authors3 institutions28 links

AreaInference Systems / Serving EnginesTopicbatching / routing / latency

CategoryAreaInference Systems / Serving EnginesTopicbatching / routing / latency
Tao Feng, Fangxu Yu, Haozhen Zhang, Zhongjie Dai, Liangqi Yuan, Zijie Lei et al.
high · 2026-08-07

Why it matters This work turns model routing from fragmented research code into infrastructure for building, evaluating, and deploying routers while measuring response quality and inference cost together. It is most useful to serving teams that select among models for cost control, personalization, or multi-turn workloads.

Method brief
01
Problem

Existing routers use incompatible formulations and implementations, which makes fair comparison and extension difficult.

02
Method

The paper defines routing through five components and automates supervision construction plus joint evaluation of quality and inference cost.

03
Difference

The infrastructure covers single-turn, multi-turn, personalized, generic, memory-augmented, vision, and time-series routing tasks.

04
Evidence

Experiments report a 14.6% relative gain over the strongest fixed-model baseline and show benefits from lightweight and user-conditioned routers.

Abstract

No single large language model (LLM) is optimal across all queries and budget constraints, making model routing essential for cost-effective deployment. Existing routers adopt diverse formulations and implementations, making fair comparison and extension difficult. We present a unified formulation of LLM routing as a sequential decision process characterized by five components: context encoders, model encoders, scoring functions, decision rules, and learning signals, covering single-turn, multi-turn, and personalized routing. Based on this formulation, we develop an automated pipeline for constructing routing supervision and evaluating routers jointly on response quality and inference cost. The resulting benchmark, xRouteBench, spans generic LLM, memory-augmented, vision, time-series, and personalized routing tasks. We further introduce LLMRouter, an open-source modular infrastructure with more than 16 representative routers. Our empirical study shows that learned routers outperform the strongest fixed-model baseline by 14.6% relatively, lightweight routers become more competitive under tight cost constraints, and user-conditioned routing consistently improves personalization.

Potential 65noveltyworkloadopen-sourceinsightpresentationinstitution
12 authors5 institutions30 links

AreaInference Systems / Serving EnginesTopicLLM serving / inference engines

Paper / High priority
CategoryAreaInference Systems / Serving EnginesTopicLLM serving / inference engines
Lijie Yang, Hongyin Luo, Jiawei Zhao, Tri Dao, Ravi Netravali
high · 2026-08-11

Why it matters This work changes how an inference service allocates test-time compute under a fixed hardware budget: instead of sampling many complete traces independently, it keeps concentrating memory and compute on promising reasoning prefixes. That matters for serving large reasoning models under GPU-memory and throughput limits; the paper reports higher accuracy and trace-completion throughput while using fewer tokens.

Method brief
01
Problem

Parallel sampling creates severe memory bottlenecks through independent traces, while subtractive pruning underutilizes hardware and cannot sufficiently shift the output distribution.

02
Method

Gambit periodically prunes partial reasoning trajectories and branches immediately from high-quality prefixes using a lightweight hidden-state scorer.

03
Difference

It performs beam search at the thought level rather than the token level while keeping hardware continuously occupied during pruning and expansion.

04
Evidence

Across multiple models and benchmarks, the paper reports higher accuracy than pruning baselines, more than twice the trace-completion throughput, and up to 68.5% lower token use than standard parallel sampling.

Abstract

Test-time compute scaling is a primary driver of performance in large reasoning models (LRMs), but extreme inefficiency bounds current approaches, shifting the critical question from how much compute to spend, to where to allocate it. We formalize test-time reasoning as a constrained compute allocation problem over partial trajectories. Under a fixed hardware budget, existing paradigms fail to actively allocate the compute to the most promising partial progress: traditional parallel sampling treats traces independently and induces severe memory bottlenecks, while subtractive pruning starves hardware and fails to actively and sufficiently shift the output distribution. To overcome this dichotomy, we introduce Gambit, an inference algorithm that executes thought-level beam search. By periodically pruning unpromising trajectories and immediately branching from high-quality prefixes, Gambit dynamically concentrates compute onto the most promising reasoning traces via a light-weight scorer probing hidden states while maintaining continuous high hardware utilization. Extensive evaluations across multiple models and benchmarks demonstrate that Gambit strictly dominates existing baselines. Under identical hardware constraints, our method yields up to a +6.7\% absolute accuracy gain on HMMT-24 and +3.3\% on AIME-25 over pruning baselines, delivers >2times higher throughput on trace completion, and reduces total token consumption by up to 68.5\% relative to standard parallel sampling.

Potential 60noveltyworkloadopen-sourceinsightpresentationinstitution
5 authors0 institutions10 links

AreaInference Systems / Memory and Decoding OptimizationTopicquantization / compression

Paper / High priority
CategoryAreaInference Systems / Memory and Decoding OptimizationTopicquantization / compression
Zhen Liu, Wenli Huang, Wei Song, Yuhan Liu, Zhiqin Yang, Jingwen Fu
high · 2026-08-07

Why it matters For multimodal inference serving, this replaces fixed pruning heuristics with an automated policy-design path: the claimed results remove 94.4% of visual tokens while retaining over 99% of full-token performance, cutting FLOPs by 9.9x and prefill latency by 6.4x.

Method brief
01
Problem

Visual-token pruning must handle changing objectives, budgets, and model architectures without relying on costly manual trial and error.

02
Method

AutoPrune uses a training-free LLM search over TPDSL, whose 131 reusable atoms cover budget control, token scoring, selection constraints, and token reassembly.

03
Difference

Each search state is encoded as a residual modification of a strong base policy, narrowing the search space toward consequential policy components.

04
Evidence

The evaluation spans 14 multimodal benchmarks and three MLLM backbones and reports quality, FLOP, and prefill-latency results under aggressive pruning.

Abstract

Visual-token pruning can substantially reduce the inference cost of multimodal large language models (MLLMs), yet existing methods largely rely on fixed, handcrafted heuristics and costly expert trial and error. As pruning objectives, budgets, and model architectures diversify, manually navigating the expanding design space becomes increasingly difficult. This paper aims to build an AI4AI framework for visual-token pruning by addressing a natural question: Can large language models automatically design effective visual-token reduction algorithms? Although LLMs possess broad algorithmic knowledge and strong reasoning capabilities, translating such general knowledge into effective solutions for a specialized task remains nontrivial. We argue that the key lies in designing an appropriate search-state representation that connects the internal knowledge of LLMs with the structural requirements and constraints of visual-token pruning. Based on this insight, we propose AutoPrune, a training-free framework for LLM-driven visual-token pruning policy design. At its core, AutoPrune introduces a Token Pruning Domain-Specific Language (TPDSL) comprising 131 reusable atoms for budget control, token scoring, selection constraints, and token reassembly. A key property of TPDSL is that it represents each search state as a residual modification of a strong base policy. This residual formulation narrows the search space and directs the LLM's attention toward the policy components that are most consequential for performance. Experiments on 14 multimodal benchmarks and three MLLM backbones demonstrate the effectiveness, efficiency, and transferability of AutoPrune. Even when removing 94.4% of visual tokens, AutoPrune preserves more than 99% of full-token performance while reducing FLOPs by 9.9x and prefill latency by 6.4x.

Potential 34noveltyworkloadopen-sourceinsightpresentationinstitution
6 authors6 institutions15 links
02 / Lab signals

📝 Lab Notes

Topicother

Lab signal / Supporting signal
low · 2026-07-27

Why it matters This item studies how AI changes work tasks and job boundaries, not distributed training, serving, compilers, or cluster infrastructure, so it has little direct value for an AI-infrastructure researcher.

Source signalsRSS/blog feed
Potential 38substancerelevanceauthorityfreshness
Lab signal / Supporting signal
low · 2026-07-14

Why it matters The post addresses enterprise AI investment management by measuring useful work per dollar, improving efficiency, and scaling high-value workflows; it offers only business context for AI-infrastructure researchers and does not discuss training, serving, or systems implementation.

Source signalsRSS/blog feed
Potential 34substancerelevanceauthorityfreshness
Lab signal / Supporting signal
low · 2026-07-14

Why it matters This product guide targets sales workflows rather than distributed training, inference serving, systems, compilers, kernels, or cluster infrastructure, so it has almost no direct value for this track.

Source signalsRSS/blog feed
Potential 29substancerelevanceauthorityfreshness

AreaInference Systems / Serving EnginesTopicagent serving systems

Lab signal / Supporting signal
CategoryAreaInference Systems / Serving EnginesTopicagent serving systems
low · 2026-07-22

Why it matters The product targets enterprise deployment of trusted voice and chat agents, so it may help agent-serving researchers understand customer and internal workflow use cases; however, the description gives no serving architecture, scheduling, latency, or reliability details.

Source signalsRSS/blog feed
Potential 57substancerelevanceauthorityfreshness