2026-05-17·Weekly digest

🔬 Research Pulse

Weekly Digest

May 17, 2026

📈 Emerging Trends

🚀 Unified single-checkpoint embodied foundation models

The field is collapsing the historical split between perception, world modeling, and action policy into one shared denoising/generation process driven by a VLM's hidden state. Pelican-Unified 1.0 matches or beats specialist systems on VLM benchmarks, world modeling, and manipulation from one checkpoint, signaling that 'one model, multiple heads' is becoming the default architecture for embodied AI.

Signals:

Pelican-Unified 1.0 jointly generating future video and future actions via a single denoising process
Evo-Depth folding implicit 3D understanding into a 0.9B RGB-only VLA rather than running a separate depth pipeline
IntentVLA conditioning action chunks on a learned intent latent rather than a separate planner

🔨 Builder opportunity: An evaluation harness that stress-tests unified embodied models by holding the checkpoint fixed and swapping only the task head/prompt — exposing where the shared latent is actually load-bearing vs. where modality-specific finetuning is silently helping.

🌱 Feed-forward 3D replaces lift-and-stitch pipelines

Native 3D models trained as residual deltas on top of large reconstruction backbones (VGGT-class) are displacing the dominant 'edit in 2D per view, then NeRF/GS-lift' approach. The shift mirrors what happened in image editing when diffusion replaced inversion-and-stitch — speed and multi-view consistency now come for free at the cost of needing a base 3D model.

Signals:

VGGT-Edit predicting a residual displacement field on a VGGT reconstruction for near-real-time edits
Articraft generating 10,000+ articulated 3D assets agentically via a DSL rather than per-view 2D priors
Evo-Depth treating depth as a modulation signal rather than a separate 3D reconstruction step

🔨 Builder opportunity: A 'Figma for 3D scenes' built directly on a feed-forward backbone — users upload a few photos, get a live VGGT-style reconstruction, then text-edit it with residual heads. The moat is the dataset of (scene, edit prompt, residual field) triples, which DeltaScene-style auto-filtering now makes tractable.

🚀 Memory as a separable, swappable model

Knowledge injection is decoupling from base-model weights: instead of fine-tuning or stuffing RAG context, new work trains dedicated 'memory models' that augment a frozen LLM at inference and dodge both catastrophic forgetting and retrieval-noise sensitivity. Paired with MemEye's finding that current multimodal agent memory leaks fine-grained visual detail, the space is wide open for memory-as-a-component products.

Signals:

MeMo encoding new knowledge into a separately-trained memory model that plugs into open or closed LLMs
MemEye showing 13 memory methods across 4 VLMs all fail on scene→pixel retention and temporal state reasoning
FutureSim revealing frontier agents struggle to incorporate streaming news into forecasts

🔨 Builder opportunity: A vendor-neutral 'memory sidecar' service: ingests an organization's documents/screen recordings/meeting video, trains a small memory model, and exposes it via a standard API that any LLM (Claude, GPT, Gemini, open-weights) can attach to at inference. Sell on the fact that it survives base-model upgrades.

🌱 Environments, not orchestration, are the agent bottleneck

The open agent ecosystem is realizing that prompting frameworks are commoditized; what's missing is reusable, training-grade sandbox infrastructure. Orchard explicitly reframes its contribution as 'Orchard Env' — a harness-agnostic environment service — with the recipes as downstream proof, hinting that the next platform layer is environments-as-a-service, not yet another agent runtime.

Signals:

Orchard centering its contribution on Orchard Env rather than the agent loop
Articraft using a sandboxed harness with structured feedback to scale articulated 3D generation
SDAR's gains coming from training-stability fixes on top of existing multi-turn RL environments

🔨 Builder opportunity: A managed 'gym for agents' offering per-tenant ephemeral sandboxes (browser, code, GUI, OS) with deterministic snapshots, replay, and reward hooks designed for RL — not just inference-time tool use. The wedge is making it cheap enough to run 100k rollouts overnight on a real-looking desktop.

📈 RL stability via teacher–student self-distillation

Multi-turn agentic RL is converging on the pattern of using the policy's own past behavior as a stabilizing teacher, rather than relying solely on reward signals or KL-to-base. SDAR's gated self-distillation produces consistent 7–10% gains across diverse agent benchmarks, suggesting on-policy self-distillation is becoming a default ingredient alongside GRPO.

Signals:

SDAR's sigmoid-gated token-level teacher–student gap stabilizing ALFWorld/WebShop/Search-QA training
IntentVLA using historical visual context as a self-conditioning signal to resolve action ambiguity
Broader trend of frozen-anchor regularization replacing handcrafted KL penalties in agent RL

🔨 Builder opportunity: An open-source RL post-training library that bakes in gated self-distillation, intent-latent conditioning, and standard environment adapters — essentially 'TRL but agent-native' — so small teams can fine-tune Qwen3/Llama-class models into stable multi-turn agents without rebuilding the training stack.

🌱 Adaptive forecasting is the new agent frontier

Static benchmarks are saturated, but FutureSim shows the best frontier agent hits only 25% on chronologically-replayed news forecasting — many do worse than abstention. The implication: today's agents can use tools but can't yet update beliefs over time, and this gap is the next benchmark axis the field will optimize against.

Signals:

FutureSim's January–March 2026 replay window exposing long-horizon adaptation failures
MemEye showing temporal state reasoning is broken even when memory is present
MeMo's emphasis on plug-in knowledge updates as a workaround for frozen base models

🔨 Builder opportunity: A 'live-context agent' product targeting analysts, traders, and policy teams: continuously ingests a curated news/data stream into a memory model, scores its own calibration against resolved events, and surfaces only forecasts where its track record beats abstention. The differentiator is the public scoreboard.

🚀 Efficiency on commodity hardware beats scale-up narratives

A throughline across compute and robotics this month: clever layout and small models on cheap silicon are outperforming bigger systems on bigger hardware. Cache-locality-aware state-vector simulation makes integrated laptop GPUs competitive for quantum sim, while a 0.9B VLA beats larger 3D-aware baselines — both stories say the win is in the data layout and inductive bias, not the parameter count.

Signals:

Cache-locality state partitioning converting integrated GPUs from sub-CPU to 1.9×–5.9× speedups
Evo-Depth's 0.9B model beating larger 3D-aware VLAs on four benchmarks
Energy-per-algorithm becoming a first-class quantum metric via the algorithms-per-joule framework
FU-MPC running a joint frontier+uncertainty optimization onboard a UAV via a lightweight surrogate

🔨 Builder opportunity: A 'physics-aware compiler' SaaS that takes ML/quantum/robotics workloads and re-lays them out for the user's actual silicon (laptop GPU, edge SoC, onboard MCU) — measured wins on energy-per-task become the marketing surface. Lean into the algorithms-per-joule framing as a sales artifact for sustainability-conscious buyers.

🤖 AI

🧠 LLMs

1. Self-Distilled Agentic Reinforcement Learning

Authors: Zhengxi Lu, Zhiyuan Yao, Zhuowen Han... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: How can dense token-level self-distillation guidance (OPSD) be effectively transferred to multi-turn LLM agent RL settings, where compounding instability and asymmetric handling of negative teacher rejections (due to imperfect skill retrieval/utilization) break naive applications of OPSD on top of trajectory-level RL?

Summary: SDAR integrates on-policy self-distillation as a gated auxiliary loss into agentic RL, where a sigmoid gate over detached token-level teacher–student gaps asymmetrically strengthens learning from teacher-endorsed tokens while softening negative rejections. This stabilizes multi-turn RL training and produces consistent gains (+7–10%) over GRPO and naive hybrid baselines across ALFWorld, WebShop, and Search-QA on Qwen2.5/Qwen3.

Key Results: SDAR consistently beats GRPO and hybrid RL-OPSD baselines across Qwen2.5 and Qwen3 model families on three agent benchmarks: +9.4% on ALFWorld, +7.0% on Search-QA, and +10.2% on WebShop-Acc over GRPO. It also avoids the training instability observed in naive GRPO+OPSD combinations, with gains holding across model scales.

Key Findings:

Naive combination of GRPO with OPSD destabilizes multi-turn agent training due to compounding instability and symmetric handling of teacher rejections.
An asymmetric sigmoid-gated auxiliary distillation objective recovers stability and yields large absolute gains (+9.4% ALFWorld, +7.0% Search-QA, +10.2% WebShop-Acc) over GRPO.
Improvements are consistent across Qwen2.5 and Qwen3 model scales and across three structurally different agent benchmarks, suggesting the gating mechanism is broadly applicable.

Technical Novelty: SDAR reframes On-Policy Self-Distillation as a gated auxiliary objective rather than a co-equal loss, using a sigmoid gate over detached token-level signals to asymmetrically amplify distillation on teacher-endorsed positive-gap tokens while softly attenuating negative teacher rejections — addressing the failure mode where privileged-skill rejections may stem from imperfect skill retrieval rather than true policy errors. This is distinct from prior hybrid RL+OPSD recipes that treat both directions of teacher disagreement symmetrically.

What's New: Prior work either uses RL alone with sparse trajectory rewards or naively layers OPSD-style distillation on top of RL. SDAR is the first to identify that negative teacher signals in skill-conditioned privileged settings are unreliable (skill retrieval can fail) and to introduce an asymmetric gating mechanism that treats positive and negative teacher gaps differently — turning OPSD from a brittle co-objective into a stable auxiliary signal.

Extension Opportunities:

Apply SDAR's gated auxiliary distillation framework to other multi-turn agentic domains such as code-agent SWE-bench tasks, tool-use benchmarks (tau-bench), or embodied robotics RL where trajectory rewards are similarly sparse.
Investigate alternative gating functions beyond sigmoid (e.g., learned gates, temperature-annealed gates, or per-skill calibrated gates) to better balance positive endorsement vs. negative rejection signals from the privileged teacher.
Extend the privileged-context teacher branch to incorporate retrieval-augmented or tool-augmented oracles, and study how the quality of skill retrieval interacts with the asymmetric treatment of negative rejections.

Replicability: The abstract does not mention code or data release. Reproduction would require multi-GPU RL training on Qwen2.5 / Qwen3 model families across three established agent benchmarks (ALFWorld, WebShop, Search-QA) — typically tens to low-hundreds of GPU-hours per run on A100/H100-class hardware for GRPO-style rollouts plus a teacher branch with privileged context.

Research Gaps:

The approach still depends on the quality of skill retrieval/utilization in the privileged teacher; cases where retrieval is systematically biased are not directly addressed.
Generalization beyond the three benchmarks (ALFWorld, WebShop, Search-QA) — particularly to longer-horizon, open-ended agentic settings with tool use or code execution — remains unexplored.

2. Pelican-Unified 1.0: A Unified Embodied Intelligence Model for Understanding, Reasoning, Imagination and Action

Authors: Yi Zhang, Yinda Chen, Che Liu... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: Can a single embodied foundation model jointly handle understanding, reasoning, imagination (future prediction), and action without sacrificing specialist-level performance — replacing the typical pipeline of three isolated expert systems for VLM, world modeling, and policy?

Summary: Pelican-Unified 1.0 is an embodied foundation model that uses a single VLM as both understanding and reasoning module, projecting its hidden state into a latent that drives a Unified Future Generator producing both future videos and future actions in one denoising process. The model jointly optimizes language, video, and action losses through a shared representation, and matches or beats specialist systems on VLM benchmarks (64.7), world modeling (66.03 on WorldArena), and manipulation (93.5 on RoboTwin) from one checkpoint.

Key Results: With a single checkpoint, Pelican-Unified 1.0 achieves: (1) 64.7 average across eight VLM benchmarks — best among comparable-scale models; (2) 66.03 on WorldArena — ranked first; (3) 93.5 average on RoboTwin — second-best among compared action methods. Demonstrates that a shared VLM backbone feeding a Unified Future Generator (UFG) with joint video+action denoising heads preserves performance across all three axes simultaneously.

Key Findings:

A single VLM backbone can serve as a shared semantic space for scenes, instructions, visual context, and action history without performance loss on standard VLM benchmarks (64.7, best at scale)
Joint denoising of future video and future action conditioned on the same latent variable achieves first-place WorldArena performance (66.03) while remaining competitive on action benchmarks (93.5 on RoboTwin)
Backpropagating language, video, and action losses into one shared representation does not force a trade-off — the unified model preserves specialist strength across all four capabilities

Technical Novelty: The core novelty is architectural unification at the representation level: one VLM produces a single dense latent that simultaneously conditions a joint video-and-action denoising generator, with language/video/action losses all backpropagated into the shared representation. Prior embodied stacks (e.g., RT-2, OpenVLA, world-model + policy hybrids) keep understanding, world modeling, and action policies as separate experts; here they share gradients and a single forward pass produces task-, action-, and future-oriented chains of thought.

What's New: Unlike prior embodied stacks that compose separate VLM, world model, and policy modules (RT-2, OpenVLA, GR00T-style architectures), Pelican-Unified 1.0 collapses these into a single VLM + shared-latent + joint-modality denoiser, with all losses flowing into one representation. The autoregressive chain-of-thought spanning task, action, and future-oriented reasoning in one forward pass is also novel.

Extension Opportunities:

Scale the unified paradigm to longer-horizon tasks by extending the UFG's denoising window and evaluating on multi-minute manipulation or navigation rollouts
Replace the dense latent bottleneck with a discrete/quantized latent (VQ-style) to enable explicit planning, search, or RL fine-tuning over imagined futures
Add a tactile/proprioceptive modality head to the UFG to test whether the unification principle generalizes beyond vision+action to richer sensorimotor channels

Replicability: Abstract does not mention code, weights, or training compute. Reproduction would likely require multi-node GPU clusters typical of VLM + video diffusion training (tens to hundreds of H100-class GPUs), plus access to RoboTwin and WorldArena benchmarks. Replicability is moderate-to-low pending official release.

Research Gaps:

No discussion in the abstract of long-horizon temporal consistency between imagined video futures and executed actions, or how drift accumulates
Unclear how the dense latent bottleneck scales when adding modalities beyond vision and action (audio, tactile, force feedback), or whether unification still holds at larger model scales

3. MemEye: A Visual-Centric Evaluation Framework for Multimodal Agent Memory

Authors: Minghao Guo, Qingyue Jiao, Zeru Shi... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: Existing multimodal agent memory evaluations allow visually grounded questions to be answered via captions or textual traces without preserving fine-grained visual evidence, and they omit harder cases requiring reasoning over changing visual states. How can we rigorously evaluate whether long-term agent memory truly preserves and reasons over visual evidence?

Summary: MemEye is a new evaluation framework and benchmark for multimodal agent memory that probes whether agents actually preserve visual evidence (scene→pixel) and reason over its evolution, rather than relying on caption-level shortcuts. Across 13 memory methods and 4 VLM backbones on 8 life-scenario tasks, current memory architectures fall short on fine-grained visual detail retention and temporal state reasoning.

Key Results: The authors introduce MemEye, a two-dimensional evaluation framework (evidence granularity from scene-level to pixel-level × usage from single evidence to evolutionary synthesis) and a new benchmark spanning 8 life-scenario tasks with ablation-driven validation gates (answerability, shortcut resistance, visual necessity, reasoning structure). Evaluating 13 memory methods across 4 VLM backbones, they demonstrate that current architectures still fail to preserve fine-grained visual details and reason about state changes over time.

Key Findings:

Current VLM memory methods rely heavily on textual/caption shortcuts and fail when fine-grained pixel-level visual evidence is required
Reasoning over evolving visual states (evolutionary synthesis) is a major weakness across all 13 evaluated memory methods
Effective long-term multimodal memory hinges on three pillars: evidence routing, temporal tracking, and detail extraction

Technical Novelty: Prior multimodal memory benchmarks conflate caption-based recall with true visual grounding; MemEye's novelty is a 2-D taxonomy (granularity × usage) plus four ablation-driven validation gates that explicitly filter out questions answerable via text shortcuts and questions that don't require visual state evolution — yielding the first benchmark specifically targeting fine-grained visual evidence preservation and temporal visual reasoning.

What's New: First evaluation framework to jointly axis multimodal memory along visual evidence granularity AND usage complexity, with explicit ablation gates that invalidate caption-shortcut answers — closing a long-standing loophole in prior visual memory benchmarks.

Extension Opportunities:

Design a memory architecture with explicit pixel-level evidence routing (e.g., region-of-interest caching tied to entity IDs) and benchmark it against the 13 baselines on MemEye's pixel-level tier
Add a temporal-state-tracking module (e.g., scene-graph diffs across timesteps) on top of existing VLM memory backbones to target the 'evolutionary synthesis' axis where current methods fail
Extend MemEye beyond static life-scenarios to embodied/streaming video agents and audio-visual memory, reusing the four validation gates to detect shortcut answers in new modalities

Replicability: The abstract does not mention a code or data release. Reproduction would require 4 VLM backbones (likely open and closed weights) and inference across 13 memory methods on 8 task scenarios — moderate compute (multi-GPU inference cluster) but no training implied; full reproduction depends on the authors releasing the benchmark dataset.

Research Gaps:

No existing memory architecture explicitly routes and preserves pixel-level visual evidence across long horizons
Lack of mechanisms for tracking and reasoning about visual state changes over time within agent memory

4. Orchard: An Open-Source Agentic Modeling Framework

Authors: Baolin Peng, Wenlin Yao, Qianhui Wu... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: How can the open-source community train scalable agentic LLMs across multiple domains (coding, GUI, personal assistance) without relying on proprietary infrastructure, given that most open frameworks focus on orchestration/evaluation rather than training?

Summary: Orchard is an open-source agentic-modeling framework whose core contribution is Orchard Env — a lightweight, harness-agnostic environment service for sandbox lifecycle management — on top of which three domain recipes (coding, GUI, personal assistant) deliver SOTA open-source results. The paper argues that a reusable training-oriented environment layer, not just orchestration, is the missing piece for open agent research.

Key Results: Orchard demonstrates SOTA open-source results across three domains using a shared environment layer: (1) Orchard-SWE (built on Qwen3-30B-A3B-Thinking) hits 64.3% on SWE-bench Verified after SFT and 67.5% after SFT+RL, using 107K distilled trajectories from MiniMax-M2.5 and Qwen3.5-397B; (2) Orchard-GUI, a 4B VLM, achieves 74.1% on WebVoyager, 67.0% on Online-Mind2Web, and 64.0% on DeepShop with only 0.4K distilled trajectories + 2.2K open-ended tasks; (3) Orchard-Claw achieves 59.6% pass@3 on Claw-Eval (73.9% with the ZeroClaw harness) using just 0.2K synthetic tasks.

Key Findings:

A shared environment layer + domain-specific recipes can produce SOTA open-source agents across coding (67.5% SWE-bench Verified), GUI (74.1% WebVoyager), and personal-assistant tasks (73.9% Claw-Eval w/ ZeroClaw) — challenging proprietary systems
Credit-assignment SFT extracts learning signal from unresolved trajectories, materially boosting SFT performance before any RL is applied
Strong GUI and assistant agents can be trained with surprisingly small data budgets (0.4K+2.2K and 0.2K tasks respectively), suggesting environment quality matters more than trajectory volume

Technical Novelty: Three pieces stand out: (1) a harness-agnostic environment service (Orchard Env) that decouples sandbox lifecycle from agent harness and pipeline stage, enabling reuse across SFT/RL/eval; (2) credit-assignment SFT that extracts productive sub-trajectories from failed rollouts rather than discarding them; (3) Balanced Adaptive Rollout for RL that adapts sampling to stabilize training. Prior open frameworks (e.g., AgentBench, OpenHands) emphasize orchestration/eval; Orchard is positioned as a training-first infra layer.

What's New: Unlike AgentBench, OpenHands, or SWE-agent (orchestration/eval-focused) and proprietary systems (closed training stacks), Orchard targets the training infrastructure gap with a harness-agnostic environment service reusable across SFT, RL, and eval — and validates it with three working recipes rather than a single demo domain.

Extension Opportunities:

Add new domain recipes on top of Orchard Env (e.g., scientific computing, robotics simulation, multi-agent negotiation) by reusing the sandbox lifecycle primitives
Generalize credit-assignment SFT — which mines productive segments from unresolved trajectories — to other partial-success domains like math proof search or long-horizon planning
Extend Balanced Adaptive Rollout to multi-modal or multi-agent RL settings where reward sparsity and rollout cost vary across task types

Replicability: Explicitly open-source ('open-source framework', 'open-source models'); base models (Qwen3-30B-A3B-Thinking, a 4B VLM) are publicly available. Reproducing Orchard-SWE would require nontrivial compute — 107K trajectory distillation + RL on a 30B MoE model likely needs a multi-node H100 cluster. Orchard-GUI (4B, 2.6K tasks) and Orchard-Claw (0.2K tasks) are far more accessible and could plausibly be reproduced on a small GPU budget.

Research Gaps:

No mention of cross-domain transfer — recipes are trained per-domain; whether a single agent can co-train across SWE/GUI/Claw via shared Orchard Env is open
Scaling laws of credit-assignment SFT and Balanced Adaptive Rollout aren't characterized — unclear how they behave on smaller base models or sparser-reward domains

⚡ CUDA/Systems

1. VGGT-Edit: Feed-forward Native 3D Scene Editing with Residual Field Prediction

Authors: Kaixin Zhu, Yiwen Tang, Yifan Yang... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: How can we perform high-quality text-conditioned 3D scene editing directly in 3D space (natively) rather than via the indirect 2D-lifting pipeline, which suffers from blurry textures and inconsistent geometry due to 2D editors lacking spatial awareness across viewpoints?

Summary: VGGT-Edit is a feed-forward framework for text-conditioned native 3D scene editing that predicts a residual 3D displacement field on top of a VGGT reconstruction backbone, replacing the dominant 'edit per-view in 2D then lift to 3D' pipeline. It pairs depth-synchronized text injection with a residual transformation head and is trained on a new automatically-filtered dataset (DeltaScene), yielding sharper, more multi-view-consistent edits at near-real-time speed.

Key Results: The paper demonstrates that VGGT-Edit substantially outperforms 2D-lifting baselines on text-conditioned 3D scene editing, producing sharper object details, stronger multi-view consistency, and near-instant inference speed (feed-forward). They construct the DeltaScene Dataset via an automated pipeline with 3D agreement filtering for ground-truth quality. Note: the abstract does not cite specific quantitative numbers (PSNR/SSIM/LPIPS/runtime ms), only qualitative claims of superiority over 2D-lifting baselines.

Key Findings:

Native 3D residual editing beats 2D-lifting baselines on sharpness and cross-view geometric consistency, validating that spatial-aware editing avoids the blur/inconsistency failure mode of per-view edit pipelines
Predicting residual displacements (rather than regenerating the scene) preserves background stability while still allowing localized text-driven deformation
A feed-forward editing path is feasible: one forward pass produces an edited 3D scene, eliminating the iterative optimization loops common in NeRF/3DGS editing

Technical Novelty: Three components are new vs. prior work: (1) depth-synchronized text injection that aligns semantic guidance with the VGGT backbone's spatial pose tokens rather than treating text as a generic 2D condition; (2) a residual transformation head that directly predicts 3D geometric displacements (deltas) over the reconstructed scene instead of regenerating geometry, preserving background stability; (3) the DeltaScene dataset with automated 3D agreement filtering — purpose-built for supervising residual 3D edits. Together these enable feed-forward native 3D editing rather than the prevailing per-view-edit-then-lift paradigm.

What's New: Unlike prior 3D editing work that edits 2D renderings and lifts results back into NeRF/3DGS (e.g., Instruct-NeRF2NeRF–style pipelines), VGGT-Edit edits directly in 3D via a residual field over a feed-forward reconstruction backbone. The depth-synchronized text injection is a specific architectural innovation for grounding language in the backbone's pose-aware token space, and the residual head sidesteps full regeneration, which is the typical source of background drift in generative 3D editors.

Extension Opportunities:

Extend the residual transformation head to support multi-step or compositional edits (chained instructions, e.g., 'rotate the chair then change its color'), exploring whether residual deltas compose cleanly in 3D space
Apply the depth-synchronized text injection mechanism to dynamic/4D scenes (e.g., on top of feed-forward video reconstruction backbones) so edits propagate temporally as well as spatially
Build an interactive editing UI that exposes the residual field prediction as a brush/region-conditioned tool, letting users localize edits via 3D masks rather than only natural language

Replicability: The abstract does not mention code or dataset release status. The DeltaScene dataset is described as generated by an automated pipeline, so reproducing it is plausible if the pipeline is published. Training likely requires multi-GPU compute (VGGT-class backbones are heavy transformer models trained on multi-view data); inference is claimed to be near-instant (single forward pass), making evaluation cheap if weights are released. Without an arXiv code link or HF release noted, replicability should be considered uncertain pending the project page.

Research Gaps:

Scope of edits supported is unclear from the abstract — whether residual displacement fields can capture appearance/texture edits and topology-changing edits (adding/removing objects), not just geometric deformation, is not addressed
No discussion of how the automated DeltaScene pipeline's 3D agreement filter handles ambiguous or subjective edits, or whether the synthetic supervision distribution limits generalization to real captured scenes

🦾 ROBOTICS

1. Evo-Depth: A Lightweight Depth-Enhanced Vision-Language-Action Model

Authors: Tao Lin, Yuxin Du, Jiting Liu... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: How can Vision-Language-Action (VLA) models gain robust 3D spatial understanding for robotic manipulation without depending on extra depth sensors, heavy geometry foundation models, or noisy explicit 3D inputs (depth maps/point clouds)?

Summary: Evo-Depth is a 0.9B-parameter Vision-Language-Action model that injects implicit depth understanding into RGB-only manipulation policies via a lightweight depth encoder, a depth-aware modulation fusion module, and a progressive alignment training schedule. It outperforms larger 3D-aware VLA baselines on four simulation benchmarks and real-world tasks while being smaller, faster, and more memory-efficient than competitors.

Key Results: Evo-Depth, with only 0.9B parameters, achieves superior performance across four simulation benchmarks. In real-world experiments, it attains the highest average success rate among compared methods while simultaneously having the smallest model size, lowest GPU memory usage, and highest inference frequency. (Specific numeric breakdowns per benchmark are not given in the abstract.)

Key Findings:

Implicit depth features extracted from multi-view RGB can deliver spatial grounding competitive with explicit depth-sensor pipelines, without the sensor noise.
Depth-aware modulation (rather than naive token concatenation) is an effective way to fuse depth into vision-language representations for action generation.
Progressive Alignment Training bridges the gap between depth-enhanced perception and downstream action learning, enabling a small 0.9B model to beat larger 3D-VLA baselines.
Evo-Depth achieves the highest real-world success rate while having the smallest size, lowest GPU memory, and highest inference frequency among compared methods.

Technical Novelty: The combination of (1) a lightweight Implicit Depth Encoding Module that derives compact depth features directly from multi-view RGB without a heavy geometry foundation model, (2) a Spatial Enhancement Module that fuses depth into vision-language tokens via depth-aware modulation rather than concatenation, and (3) a Progressive Alignment Training strategy that staged-aligns depth-enhanced representations with action learning. Prior work either added explicit depth sensors or leaned on large 3D foundation models — Evo-Depth gets implicit 3D awareness cheaply.

What's New: Unlike prior 3D-aware VLAs that bolt on depth sensors, point clouds, or massive geometry foundation models, Evo-Depth derives implicit 3D awareness purely from RGB using a compact encoder and modulation-based fusion — yielding spatial reasoning at a fraction of the parameter and compute budget.

Extension Opportunities:

Replace the Implicit Depth Encoding Module with self-supervised video-based depth pretraining (e.g., from large unlabeled robot teleop video) to further compress depth features while improving generalization to novel scenes.
Extend the Spatial Enhancement Module's depth-aware modulation to handle temporal 4D reasoning (motion + depth) for dynamic manipulation tasks like catching or pouring liquids.
Distill Evo-Depth's implicit depth features into an even smaller edge-deployable VLA (<300M params) targeting on-robot inference on Jetson-class hardware for low-latency closed-loop control.

Replicability: The abstract does not mention code or data release. Reproduction would require a multi-view RGB robot manipulation dataset plus the four (unnamed) simulation benchmarks; training a ~0.9B-parameter VLA typically needs 8×A100/H100-class GPUs for several days. The lightweight design implies inference can run on a single consumer GPU.

Research Gaps:

No reported quantitative ablation in the abstract isolating the contribution of the Implicit Depth Encoding Module vs the Spatial Enhancement Module vs Progressive Alignment Training.
Generalization to long-horizon, deformable-object, or dynamic-scene manipulation (beyond standard pick-and-place benchmarks) is not addressed.

2. IntentVLA: Short-Horizon Intent Modeling for Aliased Robot Manipulation

Authors: Shijie Lian, Bin Yu, Xiaopeng Lin... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: How can VLA (Vision-Language-Action) robot policies avoid inter-chunk conflict and unstable execution caused by short-horizon observation aliasing — where visually similar observations under partial observability lead to inconsistent intent sampling across adjacent replanning steps?

Summary: IntentVLA argues that robot imitation data is fundamentally multimodal — the same observation can map to different action chunks depending on a demonstrator's short-horizon intent — and that stateless frame-conditioned VLAs resample inconsistent intents across replanning steps. The authors propose conditioning chunk generation on a compact intent latent derived from recent visual history, and introduce AliasBench to measure this failure mode directly, showing improved stability across four benchmarks.

Key Results: The authors introduce IntentVLA, a history-conditioned VLA that encodes recent visual observations into a compact short-horizon intent representation conditioning chunk generation. They evaluate across four benchmarks: AliasBench (their new 12-task ambiguity-aware benchmark on RoboTwin2 with matched training/eval environments isolating aliasing), SimplerEnv, LIBERO, and RoboCasa. The abstract claims IntentVLA improves rollout stability and outperforms strong VLA baselines, but does not cite specific numeric improvements or success-rate deltas.

Key Findings:

Frame-conditioned VLAs suffer measurable inter-chunk conflict under partial observability because they re-infer intent independently per replan
A compact short-horizon intent latent encoded from recent observations is sufficient to stabilize chunk generation without long-horizon memory
Standard VLA benchmarks (SimplerEnv, LIBERO, RoboCasa) underweight aliasing failures, motivating the purpose-built AliasBench with 12 tasks and matched train/eval environments

Technical Novelty: Prior frame-conditioned VLAs condition chunk generation only on the current observation + instruction, making them stateless across replans. IntentVLA's novelty is (1) explicitly modeling a compact short-horizon intent latent from recent visual history as an auxiliary conditioning signal for chunked action prediction, and (2) AliasBench, the first benchmark designed specifically to isolate observation-aliasing failures in VLA evaluation with matched training/eval distributions.

What's New: Reframes a known VLA failure mode (action-chunk instability) as an observation-aliasing problem rooted in multimodal demonstration data, and offers both a modeling fix (intent conditioning) and an evaluation fix (AliasBench) — combining diagnosis, method, and benchmark in one contribution.

Extension Opportunities:

Extend the short-horizon intent representation to multi-horizon hierarchical intents (e.g., combining short-horizon tactical intent with long-horizon goal intent) for complex multi-stage tasks like cooking or assembly
Apply the intent-conditioning idea to real-world bimanual manipulation where partial observability from occlusion is more severe than in simulation, and study whether intents transfer sim-to-real
Develop an uncertainty-aware variant that flags low-confidence intent estimates and triggers active perception (e.g., camera motion or asking the human) instead of committing to a possibly wrong intent

Replicability: The abstract does not mention code or model release. Reproduction would require access to RoboTwin2, SimplerEnv, LIBERO, and RoboCasa simulators plus a strong VLA backbone (likely OpenVLA, π0, or similar in the 3B–7B parameter range), so multi-GPU training (8×A100/H100 class) is likely needed. AliasBench would need to be open-sourced to verify aliasing-specific claims.

Research Gaps:

No reported numbers in the abstract, so the magnitude of stability/success improvement vs. baselines is unclear
Real-world (non-simulated) validation is not mentioned — sim-to-real transfer of intent representations remains open

3. Articraft: An Agentic System for Scalable Articulated 3D Asset Generation

Authors: Matt Zhou, Ruining Li, Xiaoyang Lyu... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: How can we overcome the scarcity of large, diverse datasets of articulated 3D objects (objects with movable parts like joints/hinges) that is bottlenecking machine learning research in robotics, simulation, and 3D understanding?

Summary: Articraft is an agentic system that has an LLM write programs against a custom DSK to procedurally generate articulated 3D objects, with a sandboxed harness handling validation and structured feedback. Using it, the authors built Articraft-10K — 10,000+ articulated assets across 245 categories — and show this dataset supports training articulated-asset models and downstream robotics/VR use.

Key Results: The authors built Articraft-10K, a curated dataset of over 10,000 articulated assets spanning 245 categories, generated automatically by their LLM-driven agentic system. The abstract claims superior asset quality versus both state-of-the-art articulated-asset generators and general-purpose coding agents (specific benchmark numbers not disclosed in abstract), and demonstrates downstream utility for training articulated-asset models, robotics simulation, and VR applications.

Key Findings:

Reducing articulated-asset generation to LLM-driven program synthesis (against a constrained SDK) outperforms both specialized articulated-asset generators and general-purpose coding agents on quality
A restricted, validating harness materially improves LLM output by removing distractions like URDF authoring and environment management
The resulting Articraft-10K dataset (10K+ assets, 245 categories) is sufficiently large and diverse to be useful for training articulated-asset models and for robotics simulation / VR

Technical Novelty: Reframing articulated 3D generation as program synthesis against a purpose-built DSK (parts, geometry composition, joints, tests) executed inside a sandboxed harness that returns structured validation feedback — rather than direct geometric generation (diffusion/mesh) or unguided code generation. The key novel piece is the co-design of the SDK + restricted workspace + automated validator that shields the LLM from URDF/environment plumbing.

What's New: Prior articulated-3D generators rely on neural mesh/diffusion approaches that struggle with structural/kinematic validity, while general coding agents lack domain priors. Articraft is novel in (1) framing articulated generation as program synthesis, (2) providing a tight DSL focused on parts/joints/tests, and (3) wrapping the LLM in a harness that enforces validity and returns structured feedback — yielding a scalable dataset-generation pipeline rather than one-shot asset synthesis.

Extension Opportunities:

Extend the DSL to support soft-body or deformable articulations (cloth, cables, fluids) beyond rigid joints, broadening coverage for manipulation research
Use Articraft-10K to fine-tune a feed-forward articulated-asset generator (image/text-to-articulated-3D) that bypasses the per-asset LLM agent loop for inference-time speed
Integrate the harness with a physics-simulator-in-the-loop reward (e.g., grasp success in Isaac Sim) so the LLM optimizes assets for downstream robotic-task fidelity rather than just structural validity
Apply the program-synthesis-with-harness paradigm to adjacent domains: scene graphs, animation rigs, or procedural environments

Replicability: The abstract does not mention code/data release explicitly, though the dataset Articraft-10K is described as a deliverable and would presumably be published. Reproduction requires significant LLM API budget (likely thousands of agent runs at frontier-model rates for 10K assets), plus a 3D/physics validation stack (URDF + simulator). No specialized training compute appears necessary on the generation side — the LLM does the heavy lifting via API.

Research Gaps:

Diversity and realism ceiling is bounded by what the LLM can express in the DSL — long-tail or highly novel articulations may still be underrepresented
No mention of physical realism beyond geometric/kinematic validity (mass, friction, dynamic fidelity for sim-to-real transfer remain open)

4. FU-MPC: Frontier- and Uncertainty-Aware Model Predictive Control for Efficient and Accurate UAV Exploration with Motorized LiDAR

Authors: Jianping Li, Pengfei Wan, Zhongyuan Liu... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: How can a UAV exploit a motorized rotating LiDAR's independent scanning degree of freedom as an explicit decision variable that jointly optimizes for both exploration coverage progress and localization uncertainty, rather than treating scan direction as a fixed pattern decoupled from UAV motion?

Summary: FU-MPC introduces a hierarchical UAV exploration framework that treats a motorized rotating LiDAR's scan direction as an explicit decision variable in a receding-horizon controller, jointly optimizing exploration utility (frontier coverage) and localization uncertainty along a globally planned flight path. A lightweight surrogate evaluation makes the joint optimization tractable onboard, and experiments show gains over both fixed-scan and uncertainty-only baselines in complex environments.

Key Results: The authors built a UAV platform with an independently actuated rotating LiDAR and demonstrated in complex environment experiments that their hierarchical framework (global frontier-viewpoint planner + FU-MPC local scan controller) improves exploration efficiency while maintaining robust localization compared to (a) fixed-pattern scanning baselines and (b) uncertainty-only baselines. The abstract does not report specific numeric improvements (coverage %, ATE/RPE values, runtime ms), only qualitative comparative wins; lightweight surrogate evaluation is claimed to enable real-time onboard execution.

Key Findings:

Decoupling sensor pointing from UAV motion via a motorized LiDAR yields exploration efficiency gains without forcing extra translational/rotational maneuvers that risk localization degradation.
Jointly optimizing frontier utility and localization uncertainty beats uncertainty-only active-sensing baselines, indicating that exploration progress must be a first-class term in the scan objective.
A surrogate-based MPC formulation is lightweight enough for real-time onboard scan control while still coordinating with a global topology-aware viewpoint planner.

Technical Novelty: Prior LiDAR exploration work either (a) uses fixed scan patterns decoupled from planning, or (b) optimizes only localization-driven active sensing. FU-MPC is novel in treating motorized LiDAR rotation as an explicit MPC decision variable that jointly balances frontier-aware exploration utility against direction-dependent localization uncertainty, with a lightweight surrogate so the receding-horizon optimization runs onboard in real time. The hierarchical decomposition — topology-aware viewpoint sequencing globally, scan-only MPC locally along an already-planned flight trajectory — is also a distinctive structural choice.

What's New: The paper is the first (per its claim) to expose motorized LiDAR rotation as an explicit MPC decision variable coupled to both exploration progress and pose uncertainty, rather than as a fixed scan pattern or a localization-only active sensing target. The two-tier architecture — global viewpoint sequencing plus local scan-only MPC riding on top of the flight trajectory — is also a fresh decomposition for this hardware class.

Extension Opportunities:

Replace the hand-designed surrogate utility/uncertainty terms with a learned policy (e.g., RL or imitation from FU-MPC rollouts) that predicts optimal LiDAR rotation directly from local occupancy + frontier features, potentially handling longer horizons than receding-horizon MPC.
Extend the decision variable from 1-DOF rotation to a multi-DOF gimbaled or solid-state steerable LiDAR, and co-optimize sensor pointing with UAV trajectory in a fully coupled trajectory-and-sensing MPC rather than the current hierarchical split.
Generalize the framework to multi-UAV swarm exploration where each agent's scan direction is also conditioned on teammates' predicted coverage, turning scan allocation into a distributed task-assignment problem with localization-aware coupling.

Replicability: A project page exists (https://kafeiyin00.github.io/FU-MPC/) which typically hosts code, videos, and hardware specs, but the abstract does not confirm open-source release. Reproduction requires custom hardware (UAV with an independently actuated rotating LiDAR motor assembly), which is the primary barrier; compute is modest since the controller is designed for onboard real-time execution (likely an embedded GPU/CPU class compute like Jetson Orin or similar).

Research Gaps:

Existing UAV exploration systems treat LiDAR coverage as tightly coupled to UAV pose/motion, so expanding coverage costs extra flight maneuvers and risks localization quality.
Prior active-sensing work for motorized/steerable LiDARs rarely treats scan direction as a decision variable that simultaneously serves frontier-driven exploration utility and direction-dependent localization uncertainty.

💻 COMPUTE

1. Energy efficiency of quantum computers

Authors: Miquel Carrasco-Codina, Pau Escofet, Paul Hilaire... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: How much energy do quantum computers consume across different physical platforms, and how can we benchmark their energy efficiency relative to classical counterparts in a principled, platform-agnostic way?

Summary: The authors propose an energy-efficiency metric (algorithms-per-joule) for quantum computers and apply it across five leading hardware platforms — superconducting, silicon spin, trapped ion, neutral atom, and photonic qubits — incorporating real compilation constraints and expert input. The work establishes both concrete energy figures for today's machines and a benchmarking framework intended to evaluate future architectures.

Key Results: The paper defines energy efficiency as the ratio of algorithms executable per unit time to hardware energy consumed during that time, and surveys five physical platforms (superconducting qubits, silicon spin qubits, trapped ions, neutral atoms, photonic qubits) with expert input. It provides concrete energy consumption values for current quantum computers and accounts for algorithm compilation constraints, though specific numerical benchmarks are not enumerated in the abstract.

Key Findings:

Energy efficiency must be defined as a workload-relative metric (algorithms per unit energy), not raw power draw, because platforms differ vastly in gate speed and overhead
Each of the five platforms has distinct energy bottlenecks (e.g., cryogenics for superconducting/silicon, lasers for ions/neutral atoms, room-temperature optics for photonics) that drive different efficiency trade-offs
Algorithm compilation overhead materially affects platform comparisons and cannot be abstracted away when assessing real-world energy cost

Technical Novelty: First cross-platform energy efficiency framework for quantum computers that incorporates compilation constraints rather than treating qubits as abstract resources. Prior work focused on single-platform energy audits (mostly superconducting dilution refrigerators) or theoretical thermodynamic bounds; this synthesizes practitioner input across all five leading modalities into a comparable metric.

What's New: Unifies five disparate quantum hardware modalities under a single energy benchmarking framework, integrates compilation overhead (typically ignored in physics-level energy analyses), and is grounded in expert elicitation rather than purely theoretical models.

Extension Opportunities:

Build an open-source benchmarking tool that ingests hardware specs (cooling, control electronics, laser power) and a target algorithm, then outputs energy-per-useful-operation for cross-platform comparison
Extend the framework to include error-corrected logical qubits, modeling how surface code overhead and magic state distillation scale energy consumption with logical algorithm depth
Apply the framework to hybrid quantum-classical workloads (VQE, QAOA) where classical co-processor energy is non-trivial, and identify the crossover point versus pure classical HPC solvers

Replicability: Abstract does not mention released code, data, or a public benchmark suite. Reproducing the analysis would require platform-specific hardware energy measurements (or vendor disclosures) plus compiler toolchains (Qiskit, Cirq, t|ket⟩) — no significant compute needed; the bottleneck is access to operational hardware telemetry.

Research Gaps:

No treatment in the abstract of fault-tolerant/error-corrected regime energy costs, which will dominate at useful problem scales
Lacks direct head-to-head energy comparison against classical HPC for specific algorithmic tasks where quantum advantage is contested

2. Accurate Modeling of Rydberg Atoms and Their Interactions: Theory and Implementation in PairInteraction

Authors: Johannes Mögerle, Frederic Hummel, Alicia Keil... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: How can we accurately and efficiently model single-atom Rydberg properties and pairwise Rydberg-Rydberg interactions for divalent atoms (Sr, Yb) in arbitrary geometries, including near surfaces, within a single unified open-source framework?

Summary: The paper presents a unified theoretical and computational framework for Rydberg atoms that combines multi-channel quantum defect theory (MQDT) for accurate divalent-atom structure with static electromagnetic Green's tensors for arbitrary-geometry pair interactions including nearby surfaces. It is implemented in an updated open-source PairInteraction package that achieves ~10× speedup over prior software and is validated against experimental $^{174}$Yb Stark-map data.

Key Results: The authors implement a unified MQDT + static EM Green's tensor framework in an updated PairInteraction package and demonstrate (1) one order of magnitude speedup for pair-potential calculations vs. prior software, and (2) excellent agreement with experimental data on a Stark map of $^{174}$Yb. MQDT handles divalent-atom Rydberg states; Green's tensor handles arbitrary-geometry interactions including surface-induced modifications.

Key Findings:

MQDT provides precise single-atom Rydberg state descriptions for divalent atoms (Sr, Yb), confirmed by excellent match with a measured $^{174}$Yb Stark map
Static Green's tensor formalism cleanly generalizes pair-interaction calculations to arbitrary geometries, including modifications from nearby surfaces, in a single framework
The new PairInteraction implementation achieves one order of magnitude speedup for pair-potential calculations relative to the previous version (Weber et al. 2017) via high-performance libraries and a modular architecture

Technical Novelty: Unifying MQDT (precise divalent-atom Rydberg structure) with a static electromagnetic Green's tensor formalism (arbitrary-geometry two-atom interactions including surfaces) in a single high-performance open-source code, replacing prior approaches that either treated only alkalis, only free-space dipole-dipole interactions, or required separate tools.

What's New: Prior tools (e.g., original PairInteraction, ARC) focused mainly on alkalis and free-space interactions. This work is the first to integrate MQDT for divalent atoms with a Green's-tensor-based interaction calculator that handles structured EM environments, all in one extensible open-source package with substantial performance gains.

Extension Opportunities:

Extend the Green's tensor module to dynamic/frequency-dependent tensors to capture retardation, Casimir-Polder, and photon-mediated long-range interactions near nanophotonic structures and cavities
Add MQDT parameter sets and channel models for additional divalent/multi-valence species (e.g., Ca, Yb isotopes, Er, Dy, Ho) and integrate ML-based fitting of MQDT parameters from spectroscopic data
Couple the package to optimal-control or tweezer-array simulation pipelines to design gate protocols and lattice geometries directly from computed pair potentials, including near dielectric/superconducting surfaces

Replicability: Yes — PairInteraction is open-source (extending Weber et al., J. Phys. B 50, 2017). The pair-potential calculations are designed for desktop/workstation compute; speedups suggest typical runs are feasible on a single multi-core CPU without specialized hardware. Stark-map validation data for $^{174}$Yb is referenced for benchmarking.

Research Gaps:

Framework is limited to static (non-retarded) Green's tensors; dynamic/QED effects and photon-mediated interactions in cavities/waveguides are not yet covered
MQDT coverage and benchmarking is demonstrated primarily for Sr and Yb; broader divalent/lanthanide species and many-body (>2 atom) interactions remain to be incorporated

3. Quantum-Secure Physical Unclonable Function enabled by Silicon Photonics Integrated Circuits

Authors: G. Sarantoglou, N. Tzekas, G. Moustakas... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: How can silicon photonic PUFs leverage quantum (single-photon) readout to achieve authentication that is secure against passive eavesdropping and adversaries with similar fabrication capabilities, a regime that has been largely unexplored despite the convergence of silicon photonics and quantum cryptography?

Summary: The paper experimentally realizes a silicon-nitride programmable MZI-mesh PUF whose secret signature comes from fabrication variations, then numerically introduces a quantum readout protocol using single-photon states and maximally mixed inputs to hide the unitary from eavesdroppers. Monte Carlo evaluation with experimental parameters reports equal error rates as low as 10^-14, positioning the device as a viable substrate for quantum-secure hardware authentication.

Key Results: Experimentally demonstrated a SiN programmable Mach-Zehnder interferometer (MZI) mesh implementing a unitary transformation as a PUF, with the secret signature derived from uncontrollable fabrication-induced waveguide variations. Using experimentally measured parameters, they numerically evaluated a quantum readout protocol pairing single-photon states with maximally mixed states (to hide the unitary from eavesdroppers). Monte Carlo analysis of false acceptance/rejection rates as a function of detected events and corrected errors achieved equal error rates (EER) as low as 10^-14.

Key Findings:

A SiN programmable MZI mesh successfully behaves as a PUF, with fabrication-induced waveguide variations providing a unique, uncontrollable unitary signature
A single-photon quantum readout protocol with maximally mixed states can hide the underlying unitary from passive eavesdroppers while still enabling legitimate authentication
Authentication performance reaches equal error rates of ~10^-14, robust even against adversaries possessing devices from the same fabrication process

Technical Novelty: First combination of single-photon quantum readout with a programmable silicon-nitride MZI-mesh PUF, where maximally mixed input states are used to cryptographically conceal the underlying unitary transformation from passive eavesdroppers — a quantum-secure readout regime that prior photonic-PUF work (which used coherent/classical light and exposed the unitary) did not address.

What's New: Unlike prior photonic PUFs that rely on classical/coherent-light readout and leave the device transformation observable, this work introduces a quantum readout layer (single photons + maximally mixed states) on a CMOS-compatible SiN MZI mesh, fusing hardware-rooted unclonability with information-theoretic concealment of the secret transformation.

Extension Opportunities:

Build a full end-to-end hardware prototype that integrates on-chip single-photon sources and superconducting nanowire detectors with the SiN MZI mesh to remove the simulation gap and benchmark real-world EER
Extend the protocol to a challenge-response key-distribution scheme (rather than authentication only), pairing the photonic PUF with QKD-style post-processing for device-anchored quantum key generation
Stress-test against ML-based modeling attacks where an adversary trains a surrogate unitary from observed challenge-response pairs, quantifying how single-photon obfuscation degrades attack accuracy versus classical readout

Replicability: No mention of public code or datasets in the abstract. Reproducing the experimental side requires a SiN photonic foundry run plus a programmable MZI mesh testbed (thermo-optic phase shifters, fiber coupling, photodetectors); the quantum-readout evaluation is numerical Monte Carlo using measured device parameters and is reproducible on a standard workstation if the mesh transfer matrices are released.

Research Gaps:

Lack of an end-to-end experimental quantum readout demonstration — the quantum protocol is evaluated numerically using experimental parameters, not measured with real single-photon hardware on the SiN chip
Limited treatment of active/adaptive adversaries (e.g., coherent attacks, ML modeling attacks, or side-channel leakage from the thermo-optic tuning electronics) beyond same-fabrication passive eavesdroppers

4. Scalable self-testing of generic multipartite quantum states

Authors: Jinchang Liu, Elias X. Huber, Zhenyu Du... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: How can we self-test generic n-partite quantum states (certifying the underlying state purely from measurement statistics) without the exponential sample complexity that breaks scalability for existing methods?

Summary: The paper presents a self-testing protocol that certifies almost all n-qubit states from measurement statistics alone using only polynomial samples, breaking the exponential scaling barrier of prior generic multipartite self-testing. The enabling primitive is a device-independent scheme for evaluating multipartite Pauli measurements with just a linear number of Bell-pair ancillas plus standard projective and Bell measurements. This both yields scalable self-testing and serves as a general primitive for device-independent learning and certification in large quantum networks.

Key Results: The authors construct a protocol that robustly self-tests almost all n-qubit states using only polynomial sample complexity in n, overcoming the exponential barrier of prior generic self-testing schemes. The core building block is a device-independent evaluator for multipartite Pauli measurements that uses only a linear number O(n) of ancillary Bell pairs plus standard projective and Bell measurements — i.e., implementable on near-term hardware. The abstract does not cite specific numerical benchmarks, dataset sizes, or fidelity thresholds.

Key Findings:

Almost all n-qubit states can be robustly self-tested with polynomial (rather than exponential) sample complexity in n.
Device-independent evaluation of arbitrary multipartite Pauli observables is achievable using only O(n) ancillary Bell pairs plus standard Bell and projective measurements.
The same primitive generalizes to a broad family of device-independent learning and certification protocols, not just state self-testing.

Technical Novelty: Prior generic n-partite self-testing required estimating exponentially many correlators, since each new party multiplied the measurement-setting space. The novelty is a device-independent subroutine that evaluates arbitrary multipartite Pauli observables using only linearly many Bell-pair ancillas plus Bell and projective measurements, which collapses the sampling cost from exponential to polynomial while remaining robust to noise. This reframes self-testing as a modular primitive built on DI-Pauli-measurement, generalizing beyond the bespoke nonlocal-game constructions used previously.

What's New: It is the first generic multipartite self-testing scheme with polynomial sample complexity, and it does so via a hardware-friendly DI-Pauli-measurement subroutine (linear Bell-pair overhead, standard measurements) rather than exotic nonlocal games — turning self-testing into a reusable primitive instead of a bespoke proof per state family.

Extension Opportunities:

Integrate the device-independent Pauli evaluator into shadow-tomography or classical-shadow learning pipelines to produce a fully DI version of scalable state learning with provable sample bounds.
Implement the protocol end-to-end on a small photonic or trapped-ion testbed (5–10 qubits) using linear Bell-pair ancillas and benchmark robustness vs. realistic noise/loss to validate the polynomial scaling claim experimentally.
Extend the framework from n-qubit pure states to mixed states, qudits, or continuous-variable systems, and to certifying specific resource properties (entanglement depth, magic, non-locality) rather than full state identity.

Replicability: The abstract makes no mention of released code, data, or simulation artifacts. Reproducing the theoretical results requires only standard quantum-information analysis; an experimental demonstration would need a platform supporting O(n) high-fidelity Bell pairs, joint Bell measurements, and projective measurements — feasible at small n on photonic, trapped-ion, or superconducting hardware, but not commodity compute.

Research Gaps:

No explicit treatment of mixed states, qudits, or continuous-variable systems — the result is stated for n-qubit pure states and 'almost all' of them, leaving measure-zero exceptional families uncertified.
The abstract reports asymptotic scaling but does not specify concrete sample-complexity constants, noise thresholds, or an experimental demonstration validating practicality at useful n.

5. Accelerating State-Vector Quantum Simulation on Integrated GPUs via Cache Locality Optimization: A Cross-Architecture Evaluation

Authors: Gabriel Fernandes Thomaz, Jerusa Marchi, Eduarda Rodrigues Monteiro... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: How can state-vector quantum simulation be efficiently executed on integrated (consumer-grade laptop) GPUs in a vendor-agnostic way, given that poor spatial locality in the state vector creates a memory bandwidth bottleneck that degrades GPU speedup as qubit count grows?

Summary: The paper proposes a cache-locality-aware state partitioning scheme that makes state-vector quantum simulation viable on integrated laptop GPUs from Intel, AMD, and Apple. Evaluated on Quantum Phase Estimation up to 28 qubits, it converts memory-bandwidth-bound baselines from slower-than-CPU into meaningful speedups (e.g., 0.95x → 1.89x on Intel i5; 3.71x → 5.88x on M1 Pro), showing that consumer hardware can host useful quantum circuit simulation when laid out for the LLC.

Key Results: Using a Quantum Phase Estimation (QPE) benchmark across Intel, AMD, and Apple integrated GPUs, the proposed state partitioning optimization reverses GPU performance degradation at large qubit counts. For 28-qubit simulation: Intel Core i5 GPU speedup over CPU improved from 0.95x (slower than CPU) to 1.89x; Apple M1 Pro speedup improved from 3.71x to 5.88x. The optimization yields consistent execution-time improvements across all tested architectures.

Key Findings:

Naive state-vector simulation on integrated GPUs degrades sharply with qubit count because of poor spatial locality and limited memory bandwidth — to the point of being slower than the CPU on Intel at 28 qubits.
Reorganizing the state vector to maximize last-level cache reuse roughly doubles GPU-over-CPU speedup on Intel (0.95x → 1.89x) and adds ~58% to the Apple M1 Pro speedup (3.71x → 5.88x).
The optimization is vendor-agnostic and delivers consistent gains across Intel, AMD, and Apple iGPUs, demonstrating that data-center-class hardware is not a prerequisite for usable quantum simulation.

Technical Novelty: A vendor-agnostic state partitioning that reorganizes the quantum state vector so that gate-application traversals fit within the last-level cache, minimizing main-memory fetches. Prior high-performance simulators are tuned for data-center NVIDIA hardware via cuQuantum/CUDA; this work explicitly targets integrated GPUs where memory bandwidth (rather than raw FLOPs) dominates, and shows the locality reorganization is what unlocks them.

What's New: Most state-vector simulator work optimizes for NVIDIA data-center GPUs via vendor frameworks (e.g., cuQuantum). This paper targets the underexplored integrated-GPU regime where the bottleneck is bandwidth, not compute, and shows a portable locality-centric reorganization is the right lever — with a cross-vendor evaluation rather than a single-vendor demo.

Extension Opportunities:

Extend the partitioning scheme to distributed/multi-GPU integrated setups (e.g., chaining laptops or pairing iGPU + dGPU) to push qubit ceilings beyond 28 while preserving cache-locality gains.
Apply the same locality-aware partitioning to other gate-heavy circuits beyond QPE (e.g., VQE, QAOA, Shor's algorithm) and characterize where the optimization's benefit saturates as a function of gate locality.
Integrate the technique into existing open-source simulators (Qiskit Aer, Qulacs, cuQuantum's CPU/OpenCL paths) via a SYCL/OpenCL backend so non-NVIDIA users get a drop-in speedup.

Replicability: The abstract does not mention a code/data release. Reproduction would require the QPE benchmark implementation plus access to the three evaluated platforms (Intel Core i5 iGPU, an AMD integrated GPU, Apple M1 Pro). Memory needs scale as 2^n complex amplitudes — a 28-qubit run requires ~4 GB (single precision) to ~8 GB (double precision) of RAM, well within laptop budgets.

Research Gaps:

No exploration of distributed or hybrid CPU+iGPU execution to scale past the 28-qubit ceiling implied by laptop memory.
Evaluation is limited to one algorithm (QPE); generalization to circuits with different gate-locality profiles (e.g., heavily entangling random circuits) is not characterized.

🏥 HEALTHCARE

1. MeMo: Memory as a Model

Authors: Ryan Wei Heng Quek, Sanghyuk Lee, Alfred Wei Lun Leong... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: How can new, domain-specific knowledge be efficiently incorporated into frozen LLMs without retraining, accessing model weights/logits, or suffering retrieval-based limitations like noise sensitivity and corpus-size-dependent costs?

Summary: MeMo introduces a modular framework where new knowledge is encoded into a dedicated, separately-trained 'memory model' that augments a frozen LLM at inference time, requiring no access to the LLM's weights or logits. This avoids catastrophic forgetting and retrieval-noise sensitivity while enabling plug-and-play integration with both open and closed-source LLMs, with corpus-size-independent retrieval cost.

Key Results: MeMo was evaluated on three benchmarks — BrowseComp-Plus (web-scale browsing/QA), NarrativeQA (long-document QA), and MuSiQue (multi-hop QA) — and demonstrated strong performance versus existing knowledge-injection and retrieval methods across diverse settings. The abstract reports qualitative gains (robustness to retrieval noise, no catastrophic forgetting, retrieval cost independent of corpus size) but does not cite specific accuracy/F1 numbers.

Key Findings:

A separate memory model can encode cross-document relationships more effectively than chunk-based retrieval, improving multi-hop and long-context QA
Decoupling memory from the base LLM eliminates catastrophic forgetting while preserving plug-and-play compatibility with proprietary APIs
Inference-time retrieval cost becomes independent of corpus size, addressing a key scalability bottleneck of RAG
MeMo is robust to retrieval noise relative to standard RAG pipelines on BrowseComp-Plus, NarrativeQA, and MuSiQue

Technical Novelty: Rather than fine-tuning the LLM (LoRA/full FT) or using retrieval-augmented generation, MeMo trains a separate auxiliary 'memory model' that encodes knowledge and interfaces with a frozen base LLM through input-level signals only — no weight or logit access required. This makes it the first plug-and-play knowledge-injection approach compatible with closed-source LLMs while still capturing cross-document relationships that flat RAG misses.

What's New: Most prior knowledge-injection work either fine-tunes the LLM (risking forgetting and requiring weight access) or uses RAG (noise-sensitive, corpus-scaling cost). MeMo's contribution is treating memory itself as a trained model that interfaces only via inputs — a black-box-compatible alternative that captures inter-document structure RAG cannot.

Extension Opportunities:

Apply MeMo to continual/streaming knowledge updates where the memory model is incrementally fine-tuned on new documents, enabling real-time domain adaptation for closed-source LLMs like GPT-4 or Claude via API only
Compose multiple specialized MeMo memory models (e.g., legal + medical + code) as a mixture-of-memories at inference time, routing queries to relevant memory experts
Distill the memory model into smaller, task-specific adapters or explore quantized/edge-deployable variants to enable on-device personalization atop proprietary cloud LLMs

Replicability: The abstract does not mention released code, model weights, or datasets. The three benchmarks (BrowseComp-Plus, NarrativeQA, MuSiQue) are public. Reproducing would require training a dedicated memory model (likely a transformer of moderate size) on each corpus — estimated single-node multi-GPU compute (e.g., 4–8 A100s for several days per benchmark), plus API or local-inference budget for the frozen base LLM.

Research Gaps:

No reported numerical comparisons in the abstract against strong baselines like long-context LLMs, GraphRAG, or parameter-efficient fine-tuning
Unclear how the memory model itself is updated for streaming/continual knowledge, and what its training cost and staleness profile look like at scale

2. FutureSim: Replaying World Events to Evaluate Adaptive Agents

Authors: Shashwat Goel, Nikhil Chandak, Arvindh Arun... Published: 2026-05-14 | Citations: 0 arXiv | PDF

Research Question: How can we realistically measure AI agents' ability to adapt to new information in dynamic, open-ended environments beyond their training cutoff, rather than relying on static benchmarks that don't capture temporal adaptation?

Summary: FutureSim is a benchmark that evaluates AI agents' ability to adapt to new information by replaying real-world news chronologically and asking agents to forecast events resolving over a January–March 2026 window. The benchmark reveals that frontier agents are surprisingly poor at long-horizon adaptive forecasting, with the best achieving only 25% accuracy and many performing worse than abstention.

Key Results: FutureSim evaluates frontier agents on forecasting world events over a three-month window (Jan-Mar 2026) using chronological replay of real news. Results show clear capability separation: the best agent achieves only 25% accuracy, and many agents perform worse on Brier skill score than making no prediction at all (negative skill vs. baseline).

Key Findings:

Best frontier agent reaches only 25% accuracy on three-month-ahead world event forecasting
Many agents have worse Brier skill score than making no prediction, indicating systematic miscalibration
Ablations isolate distinct contributions of test-time adaptation, search, memory, and uncertainty reasoning to forecasting performance

Technical Novelty: The novelty lies in grounded chronological replay: rather than static QA or sandbox simulations, FutureSim feeds agents real news articles in the actual order they occurred and resolves questions as real-world events unfold, evaluating agents in their native harnesses. This couples open-ended adaptation, long time-horizons, and ground-truth resolution in one benchmark.

What's New: Unlike prior forecasting benchmarks (static prediction markets, snapshot QA) or agent sandboxes (synthetic environments), FutureSim grounds evaluation in real chronological world events and tests agents in their native deployment harnesses over multi-month horizons.

Extension Opportunities:

Extend the replay window beyond 3 months to test year-long adaptation horizons, and add domain-specific tracks (finance, science, geopolitics) with specialized resolution criteria
Build adaptive memory/retrieval modules that ingest the chronological news stream and benchmark them as plug-ins to existing agent harnesses to isolate which adaptation mechanism (memory vs. search vs. reasoning) drives gains
Use FutureSim as a training signal — generate synthetic forecasting trajectories from historical replays to fine-tune agents on calibration and uncertainty reasoning, then re-evaluate on held-out future periods

Replicability: The abstract doesn't explicitly mention code/data release. Reproduction would require access to a curated news article stream over the evaluation window, a question bank with resolution criteria, and budget to run frontier agents in their native harnesses across a 3-month simulated period — likely API costs in the thousands of dollars given long-horizon agentic runs.

Research Gaps:

Lack of benchmarks that measure adaptive, long-horizon agent behavior on real-world dynamics rather than static or synthetic tasks
Limited tooling to study how memory, search, and uncertainty reasoning interact during extended test-time adaptation

🔥 GitHub Trending

1. 2508965-ship-it/harmonist-orchestral

⭐ 420 stars | Unknown

🚀 Multi-Agent Orchestration Engine 2026 – Build & Deploy AI Swarms with Claude Code

agent-framework agent-system ai-agents claude-code cursor-ide llm

2. WantongC/journal-adapt-writing-skill

⭐ 311 stars | Unknown

Learn any journal's writing conventions from its published papers, then revise your manuscript to match — section by section.

academic-writing claude economics journal latex llm

3. agentic-in/elephant-agent

⭐ 277 stars | Python

Personal-Model First Self Evolving AI Agent 🐘

agent agentic agentic-ai context llm memory

4. chiennv2000/orthrus

⭐ 257 stars | Python

Fast, lossless LLM inference via dual-view diffusion decoding.

diffusion-language-models efficient-inference large-language-models llm llm-efficiency model-architecture

5. python-telegramBot/ai-auto-trading

⭐ 163 stars | TypeScript

AI trading bot crypto LLM agent quantitative trading automated trading algorithmic trading Binance Gate.io TypeScript Node.js VoltAgent crypto bot risk management multi-strategy

ai-trading algorithmic-trading automated-trading binance crypto crypto-bot

6. thinkpixelIab/polymarket-ai-trading

⭐ 156 stars | HTML

Polymarket prediction markets AI trading paper trading OpenAI GPT CLOB Kelly mean reversion SQLite Node Express Docker Render Vercel dashboard algorithmic trading quant research forecasting crypto

ai-trading algorithmic-trading clob cryptocurrency dashboard docker

7. keon/jepa

⭐ 97 stars | Python

implementing minimal versions of joint-embedding predictive architecture (JEPA)

jepa pytorch representation-learning self-supervised-learning world-models

8. basionwang-bot/HermesPet

⭐ 89 stars | Swift

让 AI 住在你 MacBook 的刘海里 · 零依赖开箱即用 · 多引擎并行的桌面 AI 伴侣（Swift 6 / SwiftUI / macOS 14+）

ai chatgpt chinese claude deepseek desktop-app

9. johunsang/semble_rs

⭐ 86 stars | Rust

Fast, AI-agent-native code search in Rust — hybrid BM25 + semantic, Tree-sitter AST chunking, dependency & impact analysis. Drop-in replacement for grep/cat/read/ls in Claude Code, Codex, Cursor, Aide

ai-agent bm25 claude-code cli code-search codex

10. NeuralInverse/neuralinverse

⭐ 81 stars | TypeScript

Code Modern. Code Legacy. Code Firmware. - open-source AI-native IDE with agentic coding, Power Mode, legacy modernization, and firmware development

agentic-coding ai code-editor ide llm open-source

11. shootthesound/comfyui-mesh

⭐ 67 stars | Python

Split FLUX.2 and LTX 2.3 across two GPUs (LAN or same-machine) — NVENC compresses activations live on the wire. Icarus (ComfyUI node) + Daedalus (back-half server).

comfyui comfyui-node diffusion-models distributed-inference flux flux2

12. lean-dojo/TorchLean

⭐ 55 stars | Lean

TorchLean is the first unified Lean 4 framework for neural-network specification, execution, and verification.

ai4math ai4science lean4 neural-network pytorch scientific-computing

13. deepelementlab/jupyter-studio

⭐ 49 stars | TypeScript

The AI-native JupyterLab — open-source Cursor for notebooks. Cmd+K inline edit, multi-step agent with cell-level tools (read/edit/run), chat with @cell/@file context, ghost-text completion, one-click

agentic-ai ai ai-agents ai-coding anthropic coding-assistant

14. Thiago-code-lab/aws-certified-ai-practitioner-brasil

⭐ 48 stars | HTML

Repositório com recursos em Português (PT-BR) para estudos da certificação AWS Certified AI Practitioner (AIF-C01)

ai-practitioner aif-c01-study aif-c01-test artificial-intelligence aws aws-certified-cloud-practitioner

15. CHB-learner/PaperPilot

⭐ 33 stars | Python

AI 文献检索与综述 Agent：支持多源检索、代码仓库定位、开放 PDF 下载、证据链与中英双语报告。

academic-research ai-literature-review cli literature-review llm paperpilot

Generated by Research Pulse on 2026-05-17 08:11