AI papers — 2026-07-30

Problem: LLM-centric vision-language-action (VLA) models route every control step through a billion-parameter language model, creating high computation/memory overhead and latency that limits real-time, resource-constrained robotic deployment.

Method: TurboVLA replaces the conventional V→L→A pathway with a direct V+L→A mapping: a DINOv3 vision encoder and lightweight BERT text encoder independently encode observations and instructions, a compact bidirectional cross-attention module (6 stacked layers, initialized from Grounding DINO-style feature-enhancement weights, hidden dim d=256) fuses vision-language features, and an ACT-style transformer decoder predicts continuous action chunks (12-step, 7-DoF) in a single forward pass conditioned on robot state, trained via behavior cloning with ℓ1 loss (no language-modeling objective), lr 5e-5 on four RTX 4090 GPUs.

Key results:

• LIBERO: 97.7% average success (Spatial 99.2%, Object 99.8%, Goal 97.4%, Long 94.2%) with 0.2B params, 31.2 ms latency, 0.9 GB VRAM on RTX 4090 — vs. π0.5 (96.9%, 3.4B params, 93.6 ms, 12.8 GB).
• RoboTwin 2.0 (50 bimanual tasks): 60.2% average success, 0.4B params, 43.4 ms latency, beating π0.5 (57.0%, 95.6ms) and StarVLA-α (50.3%, 74.9ms).
• Real-world AgileX Piper (4 tasks): 92.5%, 80%, 90%, 87.5% success, outperforming π0.5 on all.
• Ablations: removing language conditioning drops LIBERO avg to 70.8%; bidirectional interaction (97.7%) beats no-interaction (95.2%) and one-way variants (96.1–96.5%); N=6 interaction layers and H=12 action horizon are optimal.

Why it matters / caveats: Shows execution-level manipulation need not depend on a large LLM backbone, enabling deployment on consumer GPUs at ~32 Hz; authors note TurboVLA targets concrete execution instructions and may lack the complex reasoning/high-level planning capacity of LLM-centric VLAs.

Problem: It is unclear whether vision-language models (VLMs) possess "action intelligence" — the ability to decide, moment by moment, what a physical humanoid body should do next — because prior evaluations conflate the VLM's decisions with motor-control execution failures (e.g., losing balance).

Method: HumanCLAW decouples decision-making from execution: a frozen, off-the-shelf VLM is prompted through a contextual reasoning harness (visual-state perception, high-to-mid-to-low reasoning, and a skill-specific verifier) to emit atomic parameterized skills (walk, side_step, step_back, turn_in_place, climb_upstairs, walk_downstairs, sit_in_place, stop). A skill-conditioned motion generator — a 38M-parameter, 10-layer, 8-head self-attention DiT trained with flow matching on AMASS, plus a frozen-base/zero-initialized ControlNet adapter per skill — converts each skill into a 0.5s, 15-frame (30fps) continuous full-body motion chunk. A "half-physics" simulator (built on AI Habitat + Bullet, 120Hz, passive joint stiffness λ=1.0) applies gravity, collision, and object contact while bypassing balance/motor-tracking failure.

Key results:

• HumanCLAW-Bench: 1,218 find-navigate-interact episodes across 41 indoor houses (HSSD dataset), 6 target categories.
• Best model (Gemini-3.1): FindSR 64.9%, NavSR 42.4%, InteractSR only 16.8% (the reported headline success rate); 4 of 9 models achieve ≤0.2% InteractSR.
• Skill fidelity: achievement ratios ~0.97–1.00 (walk 0.966, sit 0.977, stairs 0.74–0.79), vs. MoMask baseline ratios of 0.6–2.1 with 10x higher variance.
• Ablations: removing the verifier drops NavSR 27.0%→2.0%, InteractSR 18.9%→0.0%; removing mid-level reasoning collapses InteractSR 18.9%→0.0%.
• Error analysis: 68% of found-target episodes fail navigation, mostly from body-awareness errors (34%) and distance hallucination (30%); 71% of navigated episodes fail interaction, 58% via "sitting into thin air."

Why it matters / caveats: The findings pinpoint "embodied self-awareness" (self-localization, arrival detection, collision sensing) — not perception or motor control — as the core bottleneck for VLMs acting through a body, suggesting future gains need persistent spatial memory and body-state modeling rather than better recognition. Limitations include a small interaction vocabulary (sit only), abstracted-away balance/motor control, no tactile/proprioceptive signal, and evaluation of frozen models only (no targeted body-awareness training tested).

Problem: In rubric-based RL for language models, GRPO-style pipelines collapse structured, criterion-level rubric feedback into a single response-level scalar advantage broadcast uniformly to all tokens, discarding within-response credit attribution.

Method: CoRT (Counterfactual Replay for Token-level credit weighting) rescores each sampled GRPO response twice using the frozen scoring policy: once under the original rubric-conditioned prompt (x+) and once under a matched criteria-free prompt (x-), producing token-wise log-probability contrasts Δt = ℓ+t − ℓ−t. These contrasts are mapped via a zero-centered sigmoid (replay-margin) transform into bounded per-token weights, activated gradually via a cubic-Hermite SmoothStep schedule and response-mean normalized, then used to redistribute (not replace) the original signed GRPO advantage across tokens without an auxiliary token-scoring model. It is trained on the HIR-16k dataset with Qwen3-4B-Instruct, Qwen2.5-7B-Instruct, and Qwen3-14B, under CSR and AON reward granularities, and is also integrated into DAPO and GSPO objectives.

Key results:

• Average gain of 4.4 percentage points over matched response-level GRPO across comparisons.
• Qwen3-4B, CSR: IFEval prompt/instruction 86.06/90.48 (+1.77/+1.27), IFBench 34.49/36.24 (+2.18/+2.81), MultiDimIF 80.48 (+6.10), AdvancedIF overall 49.18 (+3.16).
• Qwen2.5-7B, CSR: IFEval 81.92/87.51 (+3.36/+3.10), IFBench 34.63/36.30 (+6.40/+6.45), MultiDimIF 78.52 (+11.85).
• Qwen3-14B: CSR improves all reported metrics (e.g., IFBench 40.68/43.11 vs GRPO 39.93/42.53); AON improves IFBench/MultiDimIF but trails GRPO on IFEval.
• With DAPO (Qwen3-4B, CSR): improves all 5 reported metrics; with GSPO: improves 4 of 5 metrics (small MultiDimIF drop).
• General capability checks (Math500, GPQA-Diamond, MMLU-Pro) show largely preserved performance (deltas mostly within ±1.3 points).

Why it matters / caveats: CoRT shows policy-internal counterfactual likelihood contrasts can substitute for a learned token-relevance discriminator (as in RTT), giving comparable or better results while avoiding a separate relevance-training stage. The authors note the signal weakens when criteria have little effect on token likelihoods, are redundant with the prompt, or the reward is noisy, and stability depends on the response-normalization and SmoothStep ramp components.

Problem: Fixed rubrics bottleneck text-space LLM optimization on open-ended tasks, since once a solver satisfies the criteria a rubric measures, uncovered quality dimensions stay invisible, while naively co-evolving the rubric with the solver risks the rubric drifting toward whatever inflates the solver's score rather than reflecting true task quality.

Method: DecoEvo (Decoupled Co-Evolution) maintains two editable natural-language skills under a frozen backbone: a solver skill updated via an inner loop from criterion-level rubric-judge feedback, and a rubric-generator skill updated via an outer loop through two audits — a task-conditioned structural audit (checks omitted requirements against public task descriptions) and a near-tie contrastive audit (rubric-blind pairwise comparisons of stochastic solver rollouts with similar rubric scores). Generator candidates are accepted only via a Pareto-style rule requiring improvement on at least one audit objective without regressing others; aggregate solver score is never used to accept generator edits. Tested on GPT-4o and Qwen3-4B/8B as the shared backbone for all roles.

Key results:

• Outperforms all baselines (Zero-shot, SkillOpt, Score-Coupled Co-Evolution) on all 15 backbone-benchmark combinations (5 benchmarks × 3 backbones: HealthBench, LLMEval-Med, WritingBench, EQ-Bench Creative Writing v3, ResearchQA).
• Average relative gains over SkillOpt: 5.0% (GPT-4o, +3.10 pts), 2.9% (Qwen3-4B, +1.74 pts), 2.8% (Qwen3-8B, +1.78 pts); all significant after Holm correction.
• SC-CoEvo (score-coupled) falls below SkillOpt in 13/15 cases and below Zero-shot in 7/15.
• At matched 1.89× token budget, DecoEvo gains 3.6 pts vs. SkillOpt while Budget-Matched gains only 0.4 and SC-CoEvo loses 1.4.
• Gold-rubric criterion-overlap F1 vs SkillOpt improves ~12 points across benchmarks (e.g., HealthBench 44.6→56.9).
• Ablations: removing verification costs 2.4–2.9 pts (largest), contrastive audit 1.7–2.1 pts, structural audit 1.3–1.7 pts.

Why it matters / caveats: Score-decoupling lets evaluation rubrics evolve alongside a black-box solver without the reward-hacking-like drift seen in score-coupled co-evolution, improving cross-benchmark transfer while keeping only the solver at deployment. The authors note evidence is limited to settings sharing one backbone across all optimization roles and to within-domain (medicine/writing) transfer, leaving cross-backbone, cross-domain, and broader human evaluation untested.

Problem: Existing context-learning benchmarks are restricted to unimodal textual settings, leaving unclear where multimodal models fail when they must ground, apply, and learn from context conveyed through figures, tables, maps, and documents.

Method: CLBench-V organizes tasks into a three-level capability hierarchy — L0 Context Grounding, L1 New Information Application, L2 New Knowledge Learning — combining converted public benchmarks (e.g., ReasonMap, Insight-O3, ZeroBench, CourtSI, MIRBench, Pix2Fact, MMLongBench-Pic, BrowseComp-V3, PRISMM-Bench, CL-Bench) with two newly constructed tasks: financial-report ROE analysis (DuPont-style decomposition: ROE = Net Profit Margin × Asset Turnover × Equity Multiplier) and medical paper conclusion inference. Public-benchmark data is filtered via conversion-time rejection sampling using Qwen3.5-Plus as inspector plus manual review against four criteria (visual dependency, low irrelevant context, multi-hop preference, scope exclusion); evaluation uses task-specific deterministic evaluators or LLM judges (Qwen3.6-27B as main judge).

Key results:

• 3,443 instances across six models (InternVL3.5-30B-A3B, Qwen3.6-27B, Qwen3.5-Plus, Doubao-Seed-2.0-Lite, Kimi-K2.6, GPT-5.4); best overall score only 0.2847 (InternVL3.5-30B-A3B).
• InternVL3.5-30B-A3B: best L0 (0.3080) and L2 (0.3536), but weakest L1 (0.1313).
• Qwen3.5-Plus best on L1 (0.2954); Qwen3.6-27B L1 = 0.2878.
• Judge choice matters: across judges, average scores ranged from 0.1564 (Qwen3-VL-32B-Instruct) to 0.2122 (Qwen3-VL-4B-Instruct).
• Token length weakly correlated with score (e.g., Qwen3.6-27B Pearson r=-0.0042); excluding financial reports, correlation turns positive (r=0.0510 to 0.1429).
• InternVL3.5-30B-A3B scored 0.0000 on Financial Report ROE due to exceeding its context limit.

Why it matters / caveats: The benchmark shows multimodal context learning is far from saturated and that grounding, applying, and knowledge acquisition are dissociable capabilities with divergent model rankings. Limitations: heterogeneous source annotation styles, small diagnostic subsets, LLM-judge bias, and the ROE task currently scoring only final values, not intermediate reasoning steps.

Problem: Sparse, outcome-only terminal rewards in RLVR give LLM game agents no signal about which turn-level decisions caused success or failure, making credit assignment in long-horizon games unreliable.

Method: CAST (Credit Assignment from Solver Teachers) queries a game-specific solver (weighted A* for Sokoban, constraint-satisfaction/exact combinatorial inference for Minesweeper, precomputed BFS distance table for Rush Hour) for state cost-to-go before and after each LLM action, converts the change into a shifted "solver advantage," and shapes it with an asinh compression plus batch-level RMS normalization before adding it (weight α=0.1) to GRPO's outcome advantage inside a DAPO-based training loop. The paper proves that, under a soft-optimal solver assumption, maximizing this scalar advantage is mathematically equivalent to logit-free on-policy distillation from the solver.

Key results:

• Base policy: Qwen3-4B-Instruct-2507, trained on Sokoban, Minesweeper, Rush Hour (Avg@4 success rate, 200 held-out instances/game).
• In-domain average: CAST 62.1 vs. DAPO 44.7, GRPO 44.9, GSPO 41.9, GiGPO 45.4; Unseen-difficulty average: CAST 28.4 vs. DAPO 18.7, GRPO 19.2, GiGPO 20.8.
• Minesweeper ID gain: +14.9 points over best trained baseline.
• Reaches DAPO's peak validation performance in 120/200/140 steps vs. DAPO's 200/400/240 (Sokoban/Minesweeper/Rush Hour) — a 1.7–2.0× speedup.
• Zero-shot OOD transfer: ALFWorld average 37.9 (+5.8 over best baseline), WebShop average 22.7 (+4.8), Overall 30.3 (+5.6 over second-best).
• Solver overhead: ~8.4% of an environment step, but only ~0.01% of trajectory runtime and ~73 ppm of total training-step wall-clock time.
• Replacing the exact solver with a DQN-based learned value network on Rush Hour tracks the exact-solver curve closely with only a slight drop.

Why it matters / caveats: CAST offers a cheap, logit-free way to turn sparse game outcomes into dense turn-level supervision using existing solvers or even learned value networks, improving sample efficiency and zero-shot transfer; however, gains on harder unseen-difficulty settings (e.g., Minesweeper Unseen at 11.0) remain limited, indicating room for improvement on out-of-distribution difficulty.

Problem: Standard agentic reinforcement learning treats related tasks as independent episodes, discarding experience and forcing agents to re-explore from scratch instead of extracting and reusing transferable skills across tasks.

Method: SkillRise organizes similar-but-distinct task instances from the same task family into progressively challenging ordered sequences, then uses a single shared policy (built on Qwen3-1.7B/4B) that alternates between solving each task and rewriting an evolving textual skill document passed directly to the next task—no external memory bank, retriever, or teacher model. Training uses decoupled cross-task credit assignment: task-solving is rewarded by the current task's outcome, while skill curation is rewarded by a discounted return over subsequent tasks' outcomes (discount factor γ=0.6); advantages are computed group-relatively across trials sharing the same task group, sequence position, and phase, then optimized with a clipped PPO-style objective (K=3 tasks, N=8 trials per sequence, 16 sequences per batch).

Key results:

• Pass@1: 85.9% ALFWorld, 84.4% WebShop, 54.6% ScienceWorld, beating strongest baseline GiGPO by 2.3, 7.1, and 8.5 pp respectively.
• Pass@3: 92.2%/96.1%/61.0%, exceeding LaMer (a same-task meta-RL baseline) by 0.8/1.6/14.2 points.
• Cross-task test-time scaling on ALFWorld: 83.6% (K=2) to 87.5% (K=6), with margin over best baseline widening from 3.9 to 8.6 pp.
• Model scale (Qwen3 1.7B→4B): SkillRise gains +7.8 pp (78.1%→85.9%) vs. GRPO +4.7 pp and LaMer +3.3 pp.
• Efficiency: matches RetroAgent's 85.9% ALFWorld accuracy and beats SkillRL by 12.5 pp, while RetroAgent and SkillRL take 6.0x and 4.3x SkillRise's running time.

Why it matters / caveats: SkillRise shows a compact, single-policy end-to-end recipe can outperform multi-stage skill pipelines on both effectiveness and runtime cost, and skills transfer even to same-task repeated attempts and longer sequences. Limitations: relies on task-family metadata to build sequences, experiments capped at 4B parameters, and evaluation limited to three text-based benchmarks with verifiable rewards (per paper's stated Limitation section).

Problem: Existing game world models generate visually plausible gameplay but fail to respect underlying game mechanics (state-dependent rules like health depletion, skill-meter thresholds, and match termination) because they operate purely in pixel space without modeling internal game states.

Method: StatePlay uses a mixture-of-transformers (MoT)-style architecture built on Wan2.2-TI2V-5B (with Wan2.2 VAE and UMT5-XXL text encoder), adding a separate 0.76B-parameter state branch alongside the 5B visual branch, coupled via a shared joint-attention module for bidirectional cross-modal exchange. The visual branch is trained with a flow-matching objective while the state branch (health, skill meters, timer) is supervised with a Smooth L1 regression loss, jointly optimized via weighted summation; both branches receive action conditioning through an action encoder. Training used a custom 10,000-clip state-frame-action dataset built from Street Fighter 3 via the stable-retro framework, balanced across win/lose/macro-success/macro-fail/normal categories (labeled with Gemini-3.1-Pro), trained for 40,000 steps (batch size 4, lr 5×10⁻⁵, 480×832 frames).

Key results:

• State alignment score: 0.947 (average normalized L1 distance below 0.06 across state variables).
• Mechanics fidelity: 82.3% (Gemini-3.1-Pro) and 78.3% (GPT-5.5), an 18.6% improvement over the best baseline (ReactiveGWM, state-aware fine-tuned: 63.7%/59.7%).
• Total model size: 5.759B params vs. baselines up to 37.089B (LingBot-World).
• Ablations: MoT-style backbone outperforms shared-backbone by 17.6% in mechanics fidelity; regression loss (vs. flow matching) for states improves state alignment by 12.1% and mechanics fidelity by 21.6%.
• Action control: Move-Acc 92.5%, Att-Acc 95.0%; SSIM 0.378, LPIPS 0.424.

Why it matters / caveats: The work shows explicit state modeling is essential for moving game world models beyond pixel realism toward genuinely playable, rule-consistent simulation. Evaluation is limited to a single fighting game (Street Fighter 3) due to scarcity of public datasets with synchronized state-frame-action annotations, so broader generalization across game genres remains untested; occasional pixel-level inconsistencies (e.g., health bar mismatches) can still occur when multiple mechanics coincide.

Problem: Existing benchmarks provide limited ability to evaluate whether LLM agents can carry out long-horizon office-suite workflows (documents, spreadsheets, presentations) at an acceptable cost relative to human labor.

Method: The authors build OmegaUse-OfficeVal, a 100-task benchmark constructed via a funnel-based pipeline (1,715 practitioner-proposed tasks filtered to 595, then 282, then 100 via 3-expert screening), with privacy-preserving instruction adaptation and LLM-assisted artifact reconstruction. Each task is annotated with two economic signals (human labor time and task price proxy, the latter from explicit practitioner prices ~20% of the time or a consistency-based aggregation of three expert estimates) and evaluated using deterministic code-based verifiers built from fine-grained rubrics (219 usability items, 2,009 task-completion items) rather than human or LLM-as-judge scoring. Evaluated models include GLM-5.2, Kimi K2.6, DeepSeek-V4-Pro, MiniMax M3, and Qwen3.7-Plus, compared against a human baseline.

Key results:

• 100 tasks, 220 input files, 115 output artifacts; average human labor time 2.32 hours (median 2.03h, max 8.35h); task price proxy mean $6.86, median $5.11.
• Human baseline score: 27.79 vs. best LLM (GLM-5.2): 17.91; Qwen3.7-Plus: 17.51; Kimi K2.6: 17.00; DeepSeek-V4-Pro: 14.48; MiniMax M3: 13.82.
• Cost/task: Human $6.86 vs. Qwen3.7-Plus $0.2152 (cheapest); Time/task: Human 2.324h vs. DeepSeek-V4-Pro 0.184h (fastest).
• Qwen3.7-Plus had highest time-weighted (34.73) and price-weighted (106.50) scores despite not having the top raw score.
• Zero-score task rates: Human 29%; Qwen3.7-Plus 38%; DeepSeek-V4-Pro 50%; MiniMax M3 51%.

Why it matters / caveats: The benchmark shows LLM agents are substantially cheaper and faster than human workers but still fall well short of human-level deliverable quality on long-horizon office tasks, with performance degrading further as required human labor time increases; the fully open-sourced dataset and verifiers enable reproducible, economically-grounded comparison as models improve.

Problem: The paper investigates whether frontier AI agents can autonomously conduct open-ended AI research (not just narrow, verifiable tasks) at the level required for top-tier conference publication.

Method: The authors introduce "shadow evaluations": an agent is given the central research question from an unpublished NeurIPS 2026 submission (without access to the paper) and must independently produce a publishable paper, which the original authors then grade as conference reviewers. Two case studies were run — a "Personas" paper (LLM persona structure/controllability) and a "TabPFN" paper (distribution-shift detection for tabular foundation models) — each giving the agent six days, $3,000 in Anthropic API credits, GPU credits, and a VM. Experiments used Claude Opus 4.8 with extra-high reasoning on the OpenClaw scaffold, with a robustness check repeating one experiment using GPT-5.6 Sol Ultra on Codex (its native scaffold).

Key results:

• Both papers were unambiguously rejected: Personas scored 2/6 (Reject), TabPFN scored 1/6 (Strong Reject); reviewer confidence was 4/5 and 5/5.
• Both agent-written papers had substantially fewer references than the corresponding originals, and both exceeded NeurIPS's 9-page limit by one page.
• Both runs ended with under 50% of the API budget spent (e.g., $1,130–$1,235 of $3,000).
• Across 15 combined self-review rounds, the internal reviewer never once returned an acceptance.
• Dry runs without reasoning showed the same failures plus weaker literature review; extra-high reasoning improved quality.
• No evidence of reward hacking found in code/log review; five instances of subagent hallucination were all caught by the orchestrator.

Why it matters / caveats: The results suggest current frontier agents can handle the engineering of AI research (debugging, running experiments, literature review) but fail at judgment, creative problem-solving, backtracking, resource/time awareness, and instruction-following needed for genuine research contributions. Key caveats: only two papers were studied, reviewers were non-blind (aware papers were AI-generated) and had authored competing solutions themselves, and the evaluation involved significant researcher judgment in scaffold and paper selection.

Problem: Reasoning LLMs remain vulnerable to prompt injection and jailbreak attacks, and RL-based adversarial training on limited human/production attack datasets causes models to overfit to known patterns while staying exposed to adaptive adversaries.

Method: GPT-Red is an agentic red-teaming LLM trained via self-play RL, initialized from GPT-5.5, where an attacker and a diverse population of simultaneously-trained defender models compete: the attacker gets a stateful defender_model tool (plus a terminal tool) to iteratively query and refine attacks against a chosen defender before submitting a final attack, while defenders are rewarded for task completion and resisting attacks. Training environments are built by converting existing capability RL tasks (browsing, connector/email-calendar tools, generic function calling, agentic coding, computer-use screenshots via OpenAI Images 2.0, and content-policy jailbreak dialogues) into adversarial tasks where the attacker may edit only a designated tool response or non-privileged file region. GPT-Red is trained at compute scale comparable to OpenAI's largest RL post-training runs and used to generate adversarial prompts for RL training of the production model GPT-5.6.

Key results:

• On the 2025 Q4 Indirect Prompt Injection (IPI) Challenge, GPT-Red achieves higher average attack success rate (ASR) than human red-teamers and a GPT-5.5 baseline (with/without defender access).
• Later attacker checkpoints hit 67–82% ASR against early defenders vs. 12–29% for early attackers against late defenders (co-evolution effect).
• Cross-model transfer matrix shows source-vs-target ASR ranging ~25% to 99% depending on model pairing, indicating specialized, non-fully-transferable attacks.
• Held-out robustness of GPT-5.6: 56.1% (held-out datasets), 89.1% (held-out domains), 72.0% (held-out attacks).
• Direct prompt injection robustness: fake-CoT attacks improve from 5.2% (GPT-5.1) to 95.9% (GPT-5.6); other categories reach 66–99.5%.
• Held-out IPI red-teaming exercise: ASR against GPT-5.6 below 4%; 100% robustness on the IPI 2025 Challenge dataset replay (one misgraded exception).
• GPT-Red successfully executed a real-world prompt injection against an AI-powered vending machine (Vendy/Andon Labs), achieving all 3 adversarial objectives.

Why it matters / caveats: The authors frame this as unlocking a "self-improvement flywheel" where progressively stronger red-teamers make each new model more robust, which in turn trains better red-teamers; GPT-Red is described as the largest published safety RL run to date. Caveats: robustness "remains far from solved," GPT-Red has seen less training on multi-modal environments, multi-turn attacks, and content-policy jailbreaks, and its superior ASR versus humans on one benchmark does not imply it is universally better than human red-teamers, who may find novel attack classes.

Problem: Most video editing systems lack explicit layered (foreground/background) video representations, which limits realistic compositing, object reuse, and consistent manipulation in video object insertion and video layer decomposition.

Method: The paper introduces TriLayer, a dataset of 3,964 aligned composite–background–foreground video triplets (foreground includes object appearance plus visual effects like shadows/reflections), built via a pipeline combining Pexels video collection, PySceneDetect, Qwen2.5-VL-32B filtering, Grounded-SAM2 masking, object-removal inpainting, and RGBA extraction fusing Gen-Omnimatte, MatAnyone, and Grounded-SAM2. On this data they train DBL-Diffusion, a dual-branch diffusion framework (RGB branch + RGBA branch) built on the Wan2.1-VACE-1.3B backbone with WAN-alpha's RGBA VAE, coupled via joint cross-attention; branches are trained with a hybrid LoRA (rank 128, RGB branch) / DoRA (rank 32, RGBA branch) adaptation under a rectified-flow objective with disentangled per-branch timestep sampling. It is instantiated as DBL-Insert (layered object insertion) and DBL-Decompose (layer decomposition), trained 3 epochs with AdamW (lr 1e-4), 50 sampling steps, 81 frames at 480×832.

Key results:

• DBL-Insert vs. baselines on TriLayer: ViCLIP-T 24.767, Background Consistency 0.946, Subject Consistency 0.963, Motion Smoothness 0.993, Aesthetic 0.537, CLIP-I 0.796, DINO-I 0.747 — outperforming AnyV2V, ReVideo, VACE-Inp, VACE-C, VACE-F on most metrics.
• DBL-Decompose foreground/background reconstruction on Movies/Kubric benchmarks: PSNR 33.09/38.22, LPIPS 0.025/0.021, SSIM 0.962/0.979, generally best among generation-based methods.
• VFX generalization test used an internal dataset of 1,155 triplet clips (15 held out for testing).

Why it matters / caveats: Explicit foreground-layer supervision (via TriLayer) meaningfully improves both insertion fidelity and decomposition quality over implicit/per-scene-optimization approaches, and enables new applications like layer-based restyling and scene-aware shadow/reflection synthesis. Stated limitations: the model still struggles with complex physical interactions and highly dynamic motion, and the dual-branch architecture adds computational/memory overhead.

Problem: The literature on memory in large language models (LLMs) is fragmented, lacking a unified framework to compare attention caching, recurrent states, test-time adaptation, retrieval modules, and conditional parameter routing.

Method: This is a survey that proposes an architecture-centric taxonomy organizing LLM memory along three orthogonal axes: representation (implicit, computation-coupled vs. explicit, independently addressable), update dynamics (offline, training-only vs. online, inference-time updates, with a secondary fine-grained update-rule lens: optimization-based writing, state-transition updates, signal-gated writing/routing, admission/eviction/consolidation, and objective-induced updates), and persistence (short-term vs. long-term). It reviews implicit memory (attention/KV cache, sparse/selective attention like MoBA and NSA, recurrent models like Mamba-3, RWKV-7, Gated DeltaNet-2) and explicit memory (Titans, TTT-E2E, Engram, kNN-LM, MoE architectures like Mixtral and DeepSeek-MoE, and multi-timescale/nested update schemes like Nested Learning).

Key results:

• Surveys and categorizes roughly 40+ representative systems/models across implicit and explicit memory categories in a summary table.
• Presents a fine-grained update-rule table mapping five update mechanisms to representative models and their main risks (e.g., drift/instability, compression loss, calibration sensitivity, irreversible loss, rigidity).
• Positions the survey against five prior memory-centered surveys in a comparison table.
• Notes evaluation benchmarks used across the field: RULER, LongBench, ∞Bench, L-Eval, SCROLLS.

Why it matters / caveats: The taxonomy provides shared terminology to compare disparate memory mechanisms and identify open challenges (unified theory, lifelong parametric memory, adaptive allocation, hardware-algorithm co-design, multi-dimensional evaluation); as a survey, it offers no new experiments or benchmark results of its own, only conceptual synthesis.

Problem: Autonomous offensive-security agents are evaluated for whether they can find vulnerabilities, but not for whether they operate with the operational-security (OPSEC) discipline needed to avoid revealing their presence, capabilities, or collected intelligence during an engagement.

Method: StealthBench extracts 11 hand-verified OPSEC incidents from real bug-bounty/red-team trajectories (HackerOne), expanded into 14 dockerized task scenarios spanning six stealth dimensions (credential OPSEC, destructive operations, detection cascade, telemetry injection, artifact contamination, noise discipline). Agents run via the OpenAI Agents SDK + LiteLLM with two tools (think, execute_command), and trajectories are serialized in ATIF v1.7 and scored by a fixed 3-model LLM judge panel (GPT-5.6 Sol, GLM 5.2, Kimi K3) with majority-vote aggregation, producing safe success rate, Stealth@Solve, and reckless solve rate metrics.

Key results:

• 771 usable trajectories across 8 agent models × 14 tasks; 527 (68.4%) solved, 338 (43.8%) safe success, 189 (24.5%) reckless solves.
• No model exceeds 54% safe success rate: Claude Opus 4.8 leads at 53.8% (27.4% reckless), followed by Kimi K3 (52.5%), GLM 5.2 (50.4%), Qwen 3.7 Plus (41.1%), Nemotron 3 Ultra (40.0%), DeepSeek V4 Pro (35.7%), GPT-5.6 Sol (34.8%), Trinity Large (34.8%).
• Capability and stealth are independent: GLM 5.2 has the most solves (103) but only 3rd-place safe success due to 36.1% reckless rate; Trinity has the highest Stealth@Solve (0.843) but lowest safe success (34.8%) since it solves only 47/115 runs.
• Judge panel agreement: Fleiss' κ = 0.834 ("almost perfect"), 87.9% unanimous verdicts.
• Total evaluation cost: $345.42 (~82% agent runs, ~18% judge overhead), ~$0.45/trajectory; cost per safe success ranged $0.54 (GLM 5.2) to $2.05 (GPT-5.6 Sol).
• Claude Opus 5 refused the security-testing prompt entirely (excluded); Gemini 3.5 Flash had zero-step failures on 87% of runs.

Why it matters / caveats: The findings suggest a systematic, cross-model-family gap in agent "tradecraft" that has direct defensive value (each stealth failure mode maps to a detectable monitoring signal). Limitations: small dataset (11 source trajectories), judge panel overlaps with evaluated agent models (potential correlated blind spots), and the study cannot causally separate training-data effects from prompting/scaffolding/timeout artifacts.

Problem: Multi-agent AI pipelines transform and re-transmit knowledge through multiple hands (scrapers, ingestion models, synthesis models), and existing provenance systems record what happened but provide no operational way to grade the reliability of each transmitter and decide whether a specific claim's transmission chain should be trusted.

Method: The paper transfers classical Islamic hadith-science methodology (isnād chains, rijāl narrator grading, al-jarḥ wa-l-taʿdīl criticism/accreditation, weakest-link chain evaluation, mutābaʿāt corroboration, and matn/content criticism) into an architecture called ISNAD for multi-agent knowledge systems. It defines a relational schema (rijal_claims and narrator_registry tables) implementing per-claim narrator chains and a per-(narrator, domain) graded registry, a decision matrix combining chain grade × content-criticism verdict into serve/review/quarantine actions, and a transformation-typed weakest-link rule (strict minimum for destructive steps, bounded/corroboration-gated adjustment for generative steps). Evaluation used 20,000 atomic claims extracted via DeepSeek-chat from OpenStax University Physics (Vols. 1–3) and Crowell's Light and Matter, with synthetic fault injection across four narrators (designed fault rates 1%, 2%, 15%, 18%).

Key results:

• Weakest-link quarantine: 4,057/14,001 evaluation claims (29%) with a rejected-grade narrator were quarantined, each traceable to the causal link.
• The jarḥ–taʿdīl loop recovered 3 of 4 narrator grades from audit evidence alone; the 4th narrator (18% fault rate, highest tested) stayed ungraded due to insufficient calibration-split coverage.
• Confidence-gated baseline was uninformative by construction (r=0.04 correlation between confidence and corruption).
• Matched-coverage comparison failed: ISNAD could not exceed 4.8% coverage at any review budget (5–50%), vs. baseline reaching 20–90% coverage with 15–16% error.
• Corroboration validated across three corpora with increasing independence difficulty (v1: 68/136 fired; v2 Wikipedia: 603/603 fired, 8/8 negative controls passed; v3 physics textbooks: 104/104 fired, no negative controls run).

Why it matters / caveats: The framework offers a principled, ordinal (not falsely precise) approach to claim-level trust that existing provenance/truth-discovery/reputation systems lack, particularly for poisoning defense via the rejected/mawḍūʿ tier. Key caveats: coverage was capped at 4.8% by a weak reference content critic (not the grading mechanism), grade recovery is limited by per-(narrator, domain) evidence sparsity, corroboration independence is an idealization not fully tested against correlated-model failure, and no live production deployment was demonstrated.

Problem: On-policy knowledge distillation from large reasoning LLMs to compact students suffers from cold-start collapse, state-agnostic forward/reverse-KL scheduling, and binary reward sparsity that discards partial-credit information.

Method: CADENCE builds on a DRIFT mechanism that mixes per-token forward-KL and reverse-KL surrogate objectives (self-normalized importance weights, cosine-annealed β) computed from student-sampled trajectories against a frozen teacher. It adds six components: COVA (coverage-adaptive β schedule gated on measured top-k coverage), FTB (forking-token boost using a fixed global entropy reference, H_ref=2.0), CCD (correctness + numerical-proximity partial-credit dense reward), LAP (brevity-preferential SFT on correct rollouts with length-cap normalization), EMR (entropy-matching regularizer at forking tokens), and BSD (post-hoc bootstrapped self-distillation on consistency- and correctness-filtered rollouts), plus TFW (teacher-forced warmup) and KTR (KL trust region) for stability. Students (Qwen2.5-0.5B-Instruct) are trained via LoRA (r=16, 9.44M params, 1.91%) against Qwen2.5-Math-1.5B-Instruct or Qwen2.5-3B-Instruct teachers on a single Apple Mac Studio.

Key results:

• GSM8K pass@1: 48.7%→69.8%±0.5 (1.5B teacher, 63.2% gap closed); →72.1%±0.4 (3B teacher, 76.2% gap closed).
• MATH-500 pass@1: 47.9%±0.5 (49.1% gap closed) and 50.6%±0.5 (53.8% gap closed).
• Beats strongest matched-compute baseline (DRIFT+binary reward) by +4.4±0.7 pts (GSM8K) and +3.4±0.8 pts (MATH-500).
• CCD raises nonzero-reward trajectory fraction from ~49% to ~55%.
• ECE improves 0.164→0.078; FTA 34.8%→58.6%; SAG 24.6→11.7; ~26-token response compression (RLD) from LAP.
• Training: ~14 hrs (1.5B teacher) / ~22 hrs (3B teacher) per seed, 5 seeds each, on a single Mac Studio (16-core CPU/40-core GPU/64GB).

Why it matters / caveats: Shows strong reasoning-capable small-model distillation is achievable on consumer hardware without datacenter-scale compute, with rigorous multi-seed statistics and validation-only hyperparameter tuning. Authors explicitly caveat that DRIFT is a per-token surrogate (not true sequence-level KL gradient), CCD's partial-credit fix is "modest," COVA only fixes prolonged mode-covering (not premature sharpening), and no teacher-size scaling claim is made since deltas fall within pooled std.

Problem: Existing cybersecurity benchmarks evaluate LLM agents only in clean, pre-compromise settings, leaving it untested whether agents can investigate a real compromised host's disk artifacts and produce accurate forensic findings and remediation plans (post-compromise incident response).

Method: SecRespond builds 10 cyber ranges from frozen forensic disk snapshots of distinct, fully instantiated cloud hosts compromised via real end-to-end network attacks (spanning 4 entry-point types, 21 MITRE ATT&CK techniques, 5 OSes), constructed through a 12-stage pipeline (blueprint, attack scripting, deployment, attack execution/verification, snapshotting). Agents run in the OpenCode harness and must produce an intrusion report, vulnerability report, baseline report, and remediation plan from the disk snapshot plus security-product alerts/scans. Grading uses a hierarchical LLM-as-a-Judge framework (three judges: Claude Opus 4.7, Gemini 3.1 Pro, GPT-5.4 Pro) over 280 checkpoints mapped to a 52-item, five-dimensional Capability taxonomy (Intrusion Entity, Persistence Mechanism, Baseline Risk, Vulnerability Risk, Investigation & Response Quality), scored on Detection (max 3) and Planning (max 2) axes.

Key results:

• 23 LLMs evaluated across 8 model families; no model achieves complete detection and remediation on any single range.
• Best model, Claude Opus 4.7: 79.0% detection / 65.7% planning overall; GPT-5.5 shows a 34.7-point detection-planning gap (70.7% vs 36.0%).
• Detection strongest on Intrusion Entity (up to 88.4%, Qwen3.7 Plus) but weak on Persistence Mechanism detection; Investigation & Response Quality peaks at only 75.5% detection and mostly below 50% planning.
• Agentless static scanner baseline: 43.6% ENT, 50.0% VUL, 20.7% BAS, 2.1% PER (detection only, no remediation) — agents substantially outperform it.
• Added "procedural prior" skills raised GPT-5.4 SSH-Miner checkpoint-score from 26% to 83%; inter-judge agreement 72–75% exact match (Spearman ρ=0.86–0.87); human-LLM judge Pearson r=0.96.

Why it matters / caveats: The results expose a fundamental bottleneck: agents reliably flag alert-driven issues but fail to proactively hunt silent intrusions or deliver complete, verified remediation, limiting real-world deployment readiness for security operations; procedural priors help but do not close the gap.