AI papers — 2026-06-09

Problem: Existing repository-level coding benchmarks reduce agent evaluation to a single pass/fail resolution metric, obscuring fine-grained intermediate capabilities like repository exploration, code localisation, and context retrieval.

Method: SWE-Explore isolates repository exploration as a standalone evaluation target. Given a repository and an issue, an explorer returns a ranked list of K=5 code regions under a fixed line budget. Ground truth is derived by intersecting line-level read actions across ≥2 independent, verified successful agent trajectories per instance—requiring no manual annotation. Evaluation uses a multi-metric suite (HitRegion, Precision, line Recall, nDCG@500, Context Efficiency) validated against a downstream oracle-repair protocol: each explorer's output becomes the sole context for a fixed coding agent, whose patch acceptance rate confirms metric quality. The benchmark covers 848 issues across 10 programming languages and 203 open-source repositories.

Key results:

• 848 instances, 10 languages, 203 repos; ground truth from trajectory intersection.
• Mini-SWE-Agent + GPT-5.4-mini achieves nDCG@500=0.924, HitFile=0.649; GPT-5.4 scores nDCG=0.905, HitFile=0.655.
• Agentic explorers (Claude Code, OpenHands, Mini-SWE-Agent, etc.) form a clear tier above sparse retrievers (BM25, TF-IDF) and dense RAG baselines.
• File-level hit rates are already strong for modern agents; line-level coverage and efficient ranking remain the key differentiating axes.
• CoSIL achieves the highest recall but at lower context efficiency; no single explorer dominates all dimensions.

Why it matters / caveats: Decoupling exploration from patch synthesis enables targeted debugging of a critical agent capability that pass/fail resolution hides entirely. The trajectory-derived ground truth is biased toward whichever agents generated the seed trajectories—instances unsolvable by strong agents are excluded, which may over-represent well-structured repos.

Problem: On-policy distillation (OPD), which trains a student LLM under dense token-level guidance from a stronger teacher on the student's own sampled rollouts, has rapidly improved reasoning model performance but its parameter-space training dynamics are poorly understood relative to supervised fine-tuning (SFT) and RL with verifiable rewards (RLVR).

Method: The authors apply a suite of parameter-space diagnostics—update sparsity, spectral drift, principal-subspace rotation, effective rank, and cumulative update norm—to models trained on the same task via SFT, RLVR, and OPD. They track how cumulative updates ΔW_t evolve across checkpoints to characterise OPD's update trajectory. A key experiment constrains later training to the low-dimensional subspace identified early in OPD training ("subspace locking"), and ablations vary token sparsification, off-policy rollout generation, and objective composition to isolate which component drives observed geometry.

Key results:

• OPD occupies a "relaxed off-principal regime": update sparsity is SFT < OPD < RLVR; spectral drift and principal-subspace rotation are RLVR < OPD < SFT.
• OPD locks into a narrow low-dimensional update channel very early in training; constraining subsequent updates to this early subspace preserves OPD performance while substantially degrading SFT under the same constraint, showing the locked subspace is functionally sufficient for OPD.
• Subspace locking is robust to token sparsification and off-policy rollout shifts but sensitive to objective composition (mixing OPD with RLVR breaks the lock).
• OPD's cumulative update norm substantially exceeds RLVR's while ending with comparable stable rank—it is not a vanishing-update phenomenon.

Why it matters / caveats: These findings suggest OPD is a geometrically distinct training regime, not merely a point between SFT and RLVR, with implications for compressed or subspace-constrained training schedules. Results are reported on specific model/task configurations; generality across scales and domains is not yet established.

Problem: Current video editing benchmarks evaluate models on isolated, single-edit instructions with coarse global metrics (e.g., CLIP scores), failing to diagnose how models handle compositional user prompts that demand multiple simultaneous edits across a shared spatiotemporal context.

Method: CoVEBench provides 416 curated source videos and 626 multi-point editing instructions, each specifying approximately 3 atomic edit operations (subject, background, camera, style, motion, position, effects). Instructions are decomposed into 9,990 MLLM-verified checklist items via GPT-5, Gemini-3-Flash, and DeepSeek-V4-Pro. Evaluation uses three complementary scores: Instruction Following Score (IFS, whether each edit was executed), Video Realism Score (VRS, quality of executed edits), and Union Accuracy Score (UAS, both must pass). Video fidelity is assessed via masked spatial comparison (SEM, SSIM) against unchanged regions using Qwen3.5-122B-A10B as the MLLM judge. Automated quality metrics include Aesthetic Predictor v2.5, VisualQuality-R1, and motion smoothness measures.

Key results:

• 10 models evaluated (open- and closed-source), including Seedance 2.0, InsV2V, VACE, Lucy.
• Closed-source models achieve notably higher UAS (union accuracy) than open-source models.
• A "format-content tradeoff" is confirmed: increasing the number of simultaneous edit dimensions directly degrades realism and fidelity on the unedited portions.
• Current models frequently omit edits, violate preservation constraints, or introduce artifacts when handling ≥3 operations simultaneously.
• 67.2% of initial LLM-generated checklist items passed quality audits, yielding a reliable evaluation framework.

Why it matters / caveats: Reveals compositional video editing as a major unsolved frontier and provides fine-grained diagnostic tools beyond holistic scores. Benchmark relies on MLLM judges that may themselves have blind spots in compositional reasoning.

Problem: Video world models that maintain 3D spatial consistency across generated frames use explicit RGB point-cloud memory, which requires repeated rasterise-and-VAE-encode round-trips—computationally expensive and informationally lossy because the pixel-space detour discards the diffusion model's native latent features.

Method: The authors propose latent spatial memory: instead of storing RGB colours, each observed frame is encoded into a VAE latent tensor and each latent-grid cell is lifted into world-space 3D coordinates via depth-guided back-projection, producing a persistent 3D cache of (world-coordinate, latent-token) pairs. At query time, cache points are projected onto the target camera grid at latent resolution using z-buffered projection, yielding a target-view latent tensor in the backbone's native space with a binary visibility mask—no re-encoding needed. This is integrated into Mirage, a video world model built on Wan2.2-TI2V-5B with a ControlNet-style side branch and an initialize→readout→update cycle. Dynamic objects and sky regions are excluded from cache updates via an open-vocabulary entity extractor and video segmenter.

Key results:

• Mirage achieves WorldScore Average Score of 70.36, surpassing the previous best Spatia (69.73), Voyager (66.08), and all general video models (best: CogVideoX-I2V 60.64).
• Up to 10.57× faster end-to-end video generation vs. RGB point-cloud baselines.
• Up to 55× lower GPU memory for the 3D cache vs. RGB-cache baselines.
• Strong reconstruction quality on RealEstate10K with the closed-loop evaluation protocol.

Why it matters / caveats: Latent-space caching directly reuses the VAE encoder's learned representations, avoiding both information loss and the per-step encode/render bottleneck—a principled efficiency gain for long-horizon world generation. The approach relies on a depth-and-pose estimator; failure modes in monocular depth estimation will propagate to cache quality.

Problem: LLM agents that encode reusable task procedures as textual skills incur per-step context overhead (repeated skill insertion) and expose proprietary procedures as readable prompt content vulnerable to prompt-injection attacks.

Method: LatentSkill trains a hypernetwork skill compiler (Gϕ) that converts a textual skill document into a plug-and-play LoRA adapter in a single forward pass. The backbone LLM remains frozen; adapters are stored in a cache and hot-swapped at inference. Training proceeds in two stages: (1) document-level pretraining where the compiler must generate adapters sufficient to reconstruct or complete truncated skill documents; (2) trajectory-supervised fine-tuning where the same adapter is mounted across all steps of a teacher trajectory, encouraging trajectory-consistent policy knowledge. At inference, multiple skills are composed via parameter-space arithmetic (weighted sum of LoRA updates). Evaluated on ALFWorld (embodied household tasks) and Search-QA (search-augmented QA).

Key results:

• ALFWorld seen split: +21.4 pp success rate vs. in-context skill baseline; unseen split: +13.4 pp; using 64.1% fewer prefill tokens.
• Search-QA: +3.0 EM points vs. in-context baseline; 72.2% lower skill-token overhead.
• Generated skill LoRAs form separable clusters by domain in weight space; skill strength is linearly controllable via the LoRA scaling coefficient α.
• Parameter-space composition of decomposed skill components preserves or improves performance.

Why it matters / caveats: Weight-space skills provide efficiency, modularity, and reduced attack surface simultaneously. The compiler must be retrained when the backbone LLM changes; composition works well when skill descriptions are semantically decomposed, but degrades otherwise.

Problem: Existing embodied benchmarks tie agents to simulator-specific action spaces, sensor assumptions, and pipelines, making it impossible to determine whether performance reflects general interactive spatial reasoning or adaptation to a particular simulator.

Method: SpatialWorld unifies eight heterogeneous simulation backends (AI2-THOR, ProcTHOR, VirtualHome, CARLA, EmbodiedCity, multi-agent variants of the above, and lightweight 3D-game environments) under a shared simulator-agnostic protocol. Agents operate under vision-only partial observability (no privileged state information) using a text-based action interface native to MLLMs for navigation, viewpoint, interaction, and task-control decisions. Each of the 760 human-annotated tasks includes a validated initial state, a reference trajectory, and a terminal-state verifier. Domains span household routines, work/study, entertainment, travel, social collaboration, and digital spatial games. Fifteen advanced agents were evaluated.

Key results:

• Best commercial model GPT-5 achieves 17.4% task success rate (TSR); best open-source model Qwen-3.5 achieves 14.1% TSR.
• Clear mismatch between task success and execution efficiency across all evaluated agents.
• Substantial domain-specific performance variation; no agent is uniformly strong.
• All models fall far short of human-level performance on active spatial exploration tasks.

Why it matters / caveats: Provides a rigorous, simulator-agnostic test of genuine interactive spatial reasoning rather than simulator-specific skills. The 760-task scale and 8-backend diversity are strengths, but text-based high-level action interfaces may not capture low-level dexterity requirements.

Problem: KV cache memory scales linearly with context length, making ultra-long context serving (>64K tokens) prohibitively GPU-memory-intensive even when >90% of cached history is irrelevant to the current decoding step.

Method: Lookahead Sparse Attention (LSA) is built atop DeepSeek-V4's existing architecture. A standalone dual-encoder Neural Memory Indexer—mirroring DeepSeek-V4's native Lightning Indexer but with a Sigmoid activation and threshold-based (non-top-k) selection—is triggered every τ=64 decoding steps to proactively predict which compressed KV chunks will be needed in the next window and fetches only those from CPU to GPU. The indexer is trained entirely independently on pre-computed hidden states and relevance labels without loading the full backbone, completing in approximately one H20-GPU-hour. All highly-compressed HCA layers (128:1 ratio) are retained for global context awareness; only CSA layers are upgraded to LSA.

Key results:

• KV cache footprint reduced to 13.5% of full-context baseline (86.5% reduction) averaged across LongBench-v2, LongMemEval, and RULER.
• +0.6 pp absolute accuracy improvement over DS-V4-Flash on the same benchmarks.
• At 500K context length, KV cache overhead suppressed by >90% with no degradation in core reasoning.
• Indexer training requires only ~1 H20-GPU-hour.

Why it matters / caveats: Near-free long-context serving efficiency for DeepSeek-V4-class models, with a surprisingly cheap decoupled training strategy. The project has been suspended due to organizational changes at Tencent; the released checkpoints are preliminary and no production deployment is confirmed.

Problem: Researchers routinely apply human psychometric questionnaires (PVQ-40/21 for Schwartz values, BFI-44/10 for Big Five personality) to LLMs to predict their behavior in user interactions, but the ecological validity of this approach has not been rigorously tested against actual LLM generation behavior.

Method: Eight open-source LLMs from four families (Gemma3-4B/27B, Qwen2.5-7B/72B, Qwen3-30B-A3B/235B-A22B, GPT-OSS-20B/120B) are profiled with two methods: (1) Likert self-report scores on PVQ-40, PVQ-21, BFI-44, and BFI-10; (2) generation probability profiles derived from the psychometrically validated Value Portrait (VP) dataset—real user queries where each candidate response is tagged with Schwartz values and Big Five traits via human correlation (r≥0.3), and model log-probabilities over those responses are averaged by construct. Agreement is measured by Spearman ρ and NDCG between the two profile types.

Key results:

• Within-method questionnaire agreement: ρ=0.74 (PVQ-40↔PVQ-21), ρ=0.77 (BFI-44↔BFI-10).
• Cross-method (questionnaire vs. generation probability): ρ=0.31 (Gen↔PVQ-40), 0.28 (Gen↔PVQ-21), 0.26 (Gen↔BFI-44), 0.11 (Gen↔BFI-10)—multiple models yield negative correlations.
• Persona prompts (e.g., "you are a young adult") shift questionnaire responses in human-consistent directions but produce no measurable shift in generation probability profiles.
• The coherence of questionnaire responses is attributable to models recognising explicit construct keywords in item wording, not stable underlying dispositions.

Why it matters / caveats: Questionnaire-based LLM profiling is an unreliable predictor of real-world generation behavior and should not be used for safety-critical characterisation. Generation probability profiling over psychometrically validated response sets is proposed as a better alternative, but this method is restricted to constructs for which validated response sets exist.

Problem: Gains from memory mechanisms in action-conditioned video world models are entangled with backbone, training, retrieval, and evaluation differences across papers, making it impossible to isolate the effect of memory design alone.

Method: Echo-Memory fixes a shared video diffusion-transformer backbone, optimizer, camera-action encoding scheme, sampler, and evaluation pipeline, and varies only the memory representation across four families: (1) raw context (prior frames appended as visual evidence), (2) compression-based memory (CaM, StoryMem—reweighted/shortened history), (3) spatial summaries with different readout paths (SPMem, VMem), and (4) block-wise state-space recurrence (VideoSSM-style). Evaluation uses three purposely misaligned branches: replay quality (reconstruct a known sequence), in-domain loop revisit (return to a previously seen location in training-distribution scenes), and open-domain return probes (return to a location after large camera excursions in OOD scenes).

Key results:

• Block-wise state-space recurrence is the strongest mechanism for open-domain return tasks.
• Raw context is a strong capacity baseline, improving open-domain return far more than it improves replay metrics.
• Aggressive spatial and hybrid-compression memories lose salient evidence needed for return: compactness is not a free substitute for capacity.
• The three evaluation branches routinely disagree: replay fidelity is an unreliable proxy for world memory quality.

Why it matters / caveats: Provides the field with a matched comparison protocol for memory designs and identifies implicit state recurrence as under-valued relative to spatial compression approaches. The controlled setting is narrower than full world models and may not capture backbone-memory co-optimisation benefits.

Problem: Game benchmarks for VLMs report single first-attempt scores per (agent, game) pair, ignore how agents adapt under repeated interaction, and lack unified protocols for heterogeneous agent classes (commercial VLMs, open-weight VLMs, keyboard-mouse policies, gamepad policies).

Method: OmniGameArena comprises 12 newly built Unreal Engine 5 games spanning Solo (7), PvP (3), and Coop (2), authored specifically for this benchmark to reduce pretraining leakage risk. All agent classes connect via documented unified action adapters (keyboard-mouse and gamepad). The Improvement Dynamics Curve (IDC) harness runs each (agent, game) instance for multiple rounds: the agent plays K episodes, a tool-using reflector LLM autonomously inspects trajectories and decides what to read, then refines a bounded skill prompt. Both the per-round score trajectory and a transfer score on held-out task variants are reported. Twelve agents were evaluated on the cold-start leaderboard; four top agents were run through IDC.

Key results:

• No single VLM dominates across all 12 games; commercial agents hold a wide gap over open-weight VLMs and specialised policies.
• All four IDC agents improve over their cold-start baselines under reflection; peak performance is typically reached mid-curve rather than at the final reflection round.
• Origin-task improvement and held-out variant transfer diverge in experiments—a critical observable hidden by single-round leaderboard scores.

Why it matters / caveats: First benchmark to expose adaptation dynamics under agentic reflection in interactive games, and the divergence between origin-task and transfer scores challenges the assumption that skill refinement generalises. Newly authored UE5 games reduce contamination risk but the 12-game scale limits statistical coverage.

Problem: Existing world-action models (WAMs) for robot manipulation couple world prediction and action execution at the same short temporal resolution, forcing the video branch to spend capacity on dense adjacent-frame variations that are redundant and weakly informative for control.

Method: AHA-WAM uses a dual Diffusion Transformer (DiT) architecture with temporal asymmetry: a slow world planner DiT runs at low frequency (one pass per multi-step horizon) and maintains a rolling KV-memory over past observations, exposing reusable layerwise latent context encoding long-horizon scene evolution. A fast action expert DiT queries this context via layerwise joint attention and executes short action chunks at high frequency in closed loop. Horizon-adaptive offset training teaches the world branch to predict across variable time offsets, and Observation-Guided Video-Context Routing (OVCR) lets the action expert blend world context with real-time observation state without rerunning the expensive world DiT. Evaluated on RoboTwin 2.0 and four real-world manipulation tasks with no robot-data pretraining.

Key results:

• RoboTwin 2.0: 92.80% average success (vs. LingBot-VA 92.24%, FastWAM 91.83%, π05 79.75%).
• 4 real-world tasks: 78.3% success (vs. FastWAM 68.33%, π05 76.67%).
• Closed-loop control at 24.17 Hz, a 4.59× speedup over FastWAM (5.26 Hz).
• Achieves state-of-the-art without any robot-data pretraining.

Why it matters / caveats: Temporal decoupling of planning and control enables both higher task accuracy and much faster inference—addressing a practical bottleneck for real-time robotic deployment. Evaluation is limited to tabletop manipulation; applicability to mobile or dexterous manipulation at scale remains to be shown.

Problem: One-step diffusion-based video restoration models cannot run in real-time at high resolutions on consumer GPUs due to two bottlenecks: quadratic spatial attention over the full frame and high latency/memory overhead of large 3D video autoencoders.

Method: SwiftVR is a streaming one-step generative video restoration framework with three components: (1) Mask-Free Shifted-Window Self-Attention (MFSWA)—applies window partitioning only along spatial axes (not temporal, since chunk-wise streaming already bounds temporal length), uses deterministic index tensors for cross-window shifts rather than cyclic shifts or attention masks, keeping all attention on standard dense SDPA kernels without hardware-specific sparse implementations; (2) Restoration-aware Autoencoder (ReAE)—a compact autoencoder jointly fine-tuned with the DiT under the one-step streaming protocol; (3) causal chunk-wise streaming protocol that bounds temporal extent. Three-stage training: full-attention latent flow-matching → MFSWA distillation from the teacher → joint pixel-space fine-tuning with video discriminator.

Key results:

• Single H100: 54 FPS at 1080p, 31 FPS at 2560×1440 (QHD), 14 FPS at 4K UHD.
• Consumer RTX 5090: 26 FPS at 1080p without retraining or custom kernels.
• All compared diffusion-based VR baselines (FlashVSR-Tiny, SeedVR2-3B, DOVE, Upscale-A-Video) run out of memory at 4K on a single H100.
• 1.62× throughput gain of MFSWA over full-attention teacher at the same resolution.
• First reported generative VR model to achieve real-time 1080p on consumer hardware.

Why it matters / caveats: Demonstrates that standard dense SDPA with spatial-only windowing is sufficient for real-time generative restoration, enabling consumer deployment without custom kernels. Perceptual quality is measured by no-reference metrics only; user-study validation is not included.

Problem: LLM agent harness skills and SOPs are typically revised by heuristic self-reflection or by reusing observed successes/failures as if counts alone were reliable belief, leading to noisy edits that can hurt future tasks.

Method: Bayesian-Agent treats each reusable skill/SOP as a hypothesis about whether a frozen LLM will succeed under a specific prompt, context, and harness environment. It records verified trajectory evidence, maintains a feature-conditioned categorical posterior over each skill's success and failure modes, and maps the posterior state to interpretable rewrite actions: explore (gather more evidence), patch (add guardrails or fix identified failure modes), split (separate a skill into sub-skills), compress (prune redundant content), or retire (remove a skill with low utility). Model-facing prompts receive executable guardrails and failure-mode patches; posterior summaries remain available for audit. Evaluated as a native backend and with GenericAgent, mini-swe-agent, and Claude Code backends using DeepSeek-V4-Flash and DeepSeek-V4-Pro.

Key results:

• SOP-Bench (incremental repair): 80% → 95% (+15 pp).
• Lifelong AgentBench: 90% → 100% (+10 pp).
• RealFin-Bench (financial reasoning): 45% → 65% (+20 pp).
• Results include positive, negative (one negative case shows GA reaches 90% vs Bayesian-Agent's 85%), and saturated settings—honest assessment of limits.

Why it matters / caveats: Positions skill evolution as posterior-guided harness optimisation rather than uncalibrated prompt accumulation; the Bayesian framing is interpretable and auditable. Sparse agent trajectories may not be IID observations; the categorical posterior's assumptions may not hold for all harness environments.

Problem: No benchmark exists for evaluating instruction following in omni-modal (joint audio-visual) captioning under complex, multi-faceted user constraints; current benchmarks focus on holistic video understanding or text-only instruction following.

Method: OmniCap-IF provides 1,920 high-quality audio-visual samples with 50 constraint types across format dimensions (e.g., Markdown tables, timestamp ranges, keyword inclusion) and content dimensions (pure visual, pure audio, audio-visual). A dual-mechanism evaluation: format and temporal constraints are extracted by a judge LLM then verified by deterministic tools (format checkers, temporal IoU); content constraints are verified by the same MLLM judge answering preset factual questions. Temporal Grounding is included for spatio-temporal precision assessment. The authors also curate OmniCap-IF-54K, a 54K instruction-tuning dataset, and train OmniCaptioner-IF on it.

Key results:

• Significant performance disparities across evaluated models on 1,920 samples.
• A "format-content tradeoff" is confirmed: increasing formatting complexity directly degrades omni-modal reasoning.
• OmniCaptioner-IF achieves notable improvements on both complex instruction adherence and general omni-modal captioning benchmarks.
• Specific absolute benchmark numbers for individual models are not stated in the abstract/intro.

Why it matters / caveats: Closes an evaluation gap for omni-modal AI assistants where real users issue complex, multi-faceted instructions. Benchmark quality depends on MLLM judge accuracy; the 50 constraint types, while comprehensive, may not cover all real-world omni-modal instruction patterns.

Problem: Reward models for LLM post-training must handle heterogeneous evaluation criteria—rule-based verifiers, ground-truth references, procedural checklists, and rubrics—but no unified mechanism integrates all evidence types into a coherent, interpretable framework.

Method: Skill-RM (from Alibaba's Qwen team) reformulates reward modeling as the execution of a reusable Reward-Evaluation Skill comprising a SKILL.md procedure document and a structured resource bank (rubrics, references, checklists, verifiers, aggregation rules). An agentic judge follows the skill's procedure—diagnose → select → verify → aggregate—dynamically retrieving resources from the bank and executing tools (e.g., Python sandbox for code tests). The reward readout is a deterministic function of the resulting execution trace, supporting pointwise scoring, pairwise comparison, and multi-candidate selection. Evaluated on RewardBench2, RM-Bench, JudgeBench, JETTS best-of-N selection, and IFEval/IFBench instruction-following RL.

Key results:

• Skill-RM (Qwen3.5-27B) avg 86.2 across RewardBench2/RM-Bench/JudgeBench vs. Qwen3.5-27B LLM-as-Judge 83.9 (+2.3 avg)—best average in that model family.
• With sample-specific resources: avg 89.1 vs. baseline 83.9 (+5.2 avg).
• Outperforms all scalar/learned, generative/reasoning, rubric-based, and agentic/verifier baselines in matched Qwen3.5-27B comparisons.
• Improves all three benchmarks individually; strongest model overall is Skill-RM + sample-specific.

Why it matters / caveats: Provides a transparent, auditable, and extensible reward modeling framework where the evaluation procedure is itself a documented, modifiable skill. Adding the Skill mechanism introduces inference-time overhead from agentic execution; latency vs. quality tradeoffs are not characterised.

Problem: Deep research web agents achieve high accuracy but adopt brute-force strategies—blind tool dependency (invoking search for simple queries solvable from memory) and performative reasoning (generating long redundant trajectories)—resulting in excessive tool calls and token consumption.

Method: SlimSearcher applies a Multi-Stage Gating mechanism across both SFT and RL. In SFT, Pareto-efficient filtration retains trajectories that are simultaneously correct and efficient (joint correctness × tool-call × token filtering) to build an efficiency-aware demonstration dataset. In RL, Adaptive Reward Gating computes tool and token efficiency rewards relative to the empirical minimum-cost trajectory in the current sampled cohort (not absolute thresholds), applies an exponential mapping to penalise divergence from the minimal necessary path, and cascades these rewards with a strict binary correctness gate to prevent brevity hacking. Evaluated on GAIA, BrowseComp, and XBench-DeepSearch.

Key results:

• Tool-call rounds reduced by 17%–58% across GAIA, BrowseComp, and XBench-DeepSearch.
• On GAIA specifically: 48.4% reduction in tool-call rounds with accuracy maintained or improved.
• Accuracy on BrowseComp: 0.709 (maintained or improved vs. baseline).
• Maintains or improves task accuracy on all benchmarks while cutting tool calls.

Why it matters / caveats: Pushes the accuracy-efficiency Pareto frontier for web agents without sacrificing task performance; the cohort-relative reward avoids the brevity bias of absolute length penalties. Results are on three long-horizon benchmarks; performance on simpler short-horizon tasks is not reported and the approach may be less impactful there.

Problem: Long-context LLM inference is bottlenecked by KV-cache memory; existing KV-cache compression methods either degrade quality substantially or require full prefill before compression, and prior encoder-decoder soft-token compressors are not competitive with KV-cache compression on the accuracy-efficiency frontier.

Method: The authors perform an architecture search by pre-training many encoder-decoder compressor variants from scratch to determine optimal design choices (encoder architecture, training objective, tokenisation, compression ratio scheduling). Guided by these findings, they continually pre-train a family of Latent Context Language Models (LCLMs)—0.6B-parameter encoders paired with a Qwen3-4B-Instruct decoder—on over 350B tokens each at compression ratios of 1:4, 1:8, and 1:16. The encoder maps a long token sequence to a shorter sequence of latent embeddings consumed by the decoder in place of the original context. LCLMs also serve as agent backbones enabling "adaptive expansion": the agent skims compressed context and selectively decompresses relevant segments on demand.

Key results:

• On RULER (4k context): 8.8× faster time-to-first-token (TTFT) vs. no-compression baseline at comparable accuracy on a single H200.
• On LongBench (64k context): 5.2× faster TTFT at comparable accuracy.
• LCLMs establish a new Pareto frontier over KV-cache eviction methods (SnapKV, KVzip, Attention Matching) especially at high compression ratios (1:8 and 1:16).
• Models released on HuggingFace at huggingface.co/latent-context; code at github.com/LeonLixyz/LCLM.

Why it matters / caveats: Encoder-decoder compression is parallelisable at prefill time, compatible with standard inference engines, and can extend the decoder far beyond its native context window—advantages over KV-cache eviction that this work finally makes competitive. Compression is lossy and performance on tasks requiring precise verbatim recall at high compression ratios is not comprehensively characterised.

Generated from PDF text extracted via poppler pdftotext from arxiv.org PDFs. Summaries are based on abstracts, introductions, and experiments sections (up to first 15 pages per PDF). Always verify claims against the original paper.