AI papers — 2026-08-13

Problem: Existing agent-safety benchmarks evaluate short, static, resettable tasks with benchmark-specific interfaces, making it hard to study cumulative safety risks that emerge as long-horizon, stateful environments evolve and to compare risk across different agent runtimes.

Method: OpenART is an arena that builds over 10K validated stateful scenarios across 50 domains from a corpus of 500K+ Tools, MCPs, and Skills (collected following SkillNet), where a planner composes each scenario into a directed workflow graph with a fixed benign task objective and a hidden safety contract, validated by a deterministic evaluator. Each scenario is target-agnostic and gets projected via lightweight runtime adapters into 15 deployed agents (e.g., OpenCode, Aider, Claude Code, Codex, Copilot CLI) paired with 5 foundation models (GPT-5.5, Claude-Opus-4.8, GLM-5.2, Qwen-3.7-Max, DeepSeek-V4-Pro), exposing 8 target-visible attack vectors (workspace, instructions, Skills, Tools, MCPs, short-term memory, plan state, long-term memory). The paper introduces Evolutionary Markov Hypergraph Attack (EMHA), a black-box, frozen-parameter reference policy that represents coordinated environment changes as a hypergraph, samples attack paths via a feedback-guided soft policy (value updates via return redistribution), and evolves a MAP-Elites-style quality-diversity archive/population of attack graphs across rounds, while task objectives and evaluators remain fixed.

Key results:

• Scenario complexity: median 97 tool calls, dependency depth 32, parallel width 12.5, 96.5 state objects, 7.5 file formats per task — versus 1–15 tool calls in prior benchmarks (InjecAgent, ToolEmu, AgentDojo, AgentHarm, ASB, DTap).
• 99.3% of evaluators judged correct under human expert verification (10% audit).
• Pooled Strict ASR across 75 agent–model configurations reaches 85.0% (per-model average ranges from 59.2% for Opus-4.8 to 94.7% for DeepSeek-V4-Pro).
• Benign task completion ranges from 80.81% (Qwen-3.7-Max) to 96.18% (Claude Opus-4.8) pooled across agents; Aider has the lowest completion of all agents.
• EMHA's advantage over instruction-only evolution grows from 1.8–2.7% on the simplest scenarios to 17.2–17.6% on the most complex ones (by dependency depth and tool calls).
• Ablation (DeepSeek-V4-Pro): Workspace-only evolution achieves 92.5% Strict ASR (vs. instruction-only baseline 81.6%, +10.9%); full EMHA reaches 94.7% (+13.1% over instruction-only, +2.2% over best single vector); removing the archive drops ASR by 3.9%, removing credit redistribution drops it by 2.6%.
• Cumulative Strict ASR rises across 5 evolution rounds: 42.9% → 69.4% → 73.5% → 89.8% → 94.7% (+51.8% cumulative).
• Target-agent identity explains an additional 7.6% of ASR variation beyond target-model identity and benign-task completion (91.3% → 98.9%); a two-way decomposition attributes 73.6% of ASR variation to the target model and 25.2% to the target agent, with mean pairwise Spearman correlation of 0.65 in agent vulnerability rankings across models.
• Long-horizon safety drift: median propagation distance of 37 target actions (IQR 20–66) between first use of evolved state (23% of execution) and first unsafe output (64%), a median latency of 41% of the workflow.

Why it matters / caveats: The results show static, short-horizon benchmarks systematically underestimate agent risk, since vulnerabilities often only surface after evolved environment state propagates through many later actions (stale assumptions, propagated rather than recomputed safety decisions, and compositional risk across benign-looking changes). The findings also indicate agent runtime implementation matters for safety independent of the underlying foundation model, which existing single-model-focused safety evaluations may overlook.

Problem: Turning a research idea into a complete, evidence-grounded academic paper requires literature retrieval, experiment design/execution, evidence-based claim revision, and publication-ready figure generation, but existing autonomous research agents implement this as standalone applications with separate orchestration infrastructure rather than integrating into the coding environments researchers already use.

Method: Spark-to-Paper is implemented as thirteen composable skills running inside an existing coding assistant (Claude Code, using a Claude-family model), coordinated by a lightweight "ts-paper" orchestrator through eight pipeline stages (input routing, planning, citation, writing, refinement, review, figure generation, assembly, plus a conditional experiment-execution stage) that communicate via artifacts in a shared project directory rather than a dedicated agent platform. It separates model-based judgment from deterministic, checkable operations (e.g., citation validation, LaTeX compilation, result-integrity checks), separates experiment planning from experiment reporting (evidence requirements and table structures are fixed before experiments run, in a Proposal Mode vs. Data-Aware Mode distinction), and bounds a failure mode called the "Self-Refutation Loop" by capping experiment-critique-revision cycles at seven before recording a failure report and restarting from a new idea. Figures are generated via two paths: measured-result plots are produced programmatically from data, while method/explanatory diagrams are first drafted with an image-generation model and then reconstructed into editable HTML/vector PDF through iterative render-and-compare code reconstruction.

Key results:

• Across eight controlled research topics, Spark-to-Paper achieves 99.5% [98.4, 100] citation validity and 96.4% [92.7, 98.6] figure editability, versus 91-96% citation validity and 0-3% figure editability for released papers from prior autonomous systems (AI Scientist, AI Scientist-v2, Agent Laboratory), and 81% citation validity for a single-pass LLM baseline on the same backbone.
• Ablation on 36 seeded fabrication probes shows fabrication detection rising from 14% (5/36) for a single-pass draft, to 69% (25/36) with deterministic/model gates only, to 81% (29/36) adding self-review, to 92% (33/36) with the full stack including adversarial review.
• Adversarial review achieves 74% (42/57) precision on raised issues (blinded rater assessment of 60 sampled issues, 3 excluded as "cannot tell").
• The full system averages 11.9M [10.2, 13.7] tokens, $8.1 [6.9, 9.6] cost, and 3.2 hours [2.6, 3.9] wall-clock time per manuscript, versus $0.66 and 16 minutes for the single-pass baseline.
• Citation validity was computed over 384 references from eight Spark-to-Paper papers (vs. 320 references from eight sampled human preprints at 97.8% validity); figure editability was evaluated over ~1,900 ground-truth figure elements.

Why it matters / caveats: The paper argues end-to-end automated research paper generation does not require standing agent infrastructure and can be built as reusable skills inside a general-purpose coding assistant, while keeping deterministic gates central to preventing fabricated citations/results. Caveats: comparisons to prior systems (AI Scientist, AI Scientist-v2, Agent Laboratory) are retrospective audits of publicly released artifacts rather than re-runs under matched conditions/pricing; qualitative system positioning (Fig. 1, Table 1) is the authors' own ordinal assessment, not a measured benchmark; and per-paper showcase statistics (Fig. 5) are self-reported by the maintainers rather than independently verified.

Problem: Existing capability-transfer methods (knowledge distillation, on-policy distillation, RLHF) close the gap between strong and weak models only by updating the weak model's parameters, leaving open whether a strong model can instead transfer capability at test time by designing the inference-time harness around a fixed, untrained weak model.

Method: A strong "builder" model (e.g., GPT-5.5, Opus-4.7, Sonnet-4.6, Codex-5.3, Gemini-3.1-Pro/3.5-flash, Grok-0.1) is placed inside an agentic coding harness (Cursor, Claude Code, or GPT Codex) with a rule file, a demo of how to call the target model, and a 5% validation split of four Theory-of-Mind benchmarks (BigToM, Hi-ToM, MMToM-QA, MuMA-ToM; 3,900-item hidden test set total). The builder iteratively writes/refines an inference-time scaffold — any mix of prompt templates, benchmark routing, deterministic solvers, few-shot exemplars, verification passes, or format enforcement — evaluating only on the validation set, then exports a fixed entry point that is run once, unmodified, on the hidden full test set with a fixed weak target model (mainly GPT-5.4-mini, also Gemini-3.5-flash). The target model's parameters are never updated. 72 total runs vary platform, builder, target, and repeats (3x).

Key results:

• Mean macro-average accuracy across 57 scaffolded GPT-5.4-mini runs rose from a 0.488 vanilla baseline to 0.763 (+0.275), and 100% of runs and all 11 builder configurations beat baseline.
• Best single run (builder GPT-5.5 on GPT Codex) reached 0.912, a +0.423 (87% relative) uplift, versus a human-designed UserHarness reference of 0.939 for the same GPT-5.4-mini backbone.
• Run-to-run standard deviation averaged 0.036 (about 8x smaller than the mean uplift), though the widest setting had a 0.201 repeat range.
• Best validation accuracy predicts full-set accuracy almost 1:1 (Pearson r=0.96, optimism gap 0.021), while number of validation iterations does not (r=0.17); median 5 validation evaluations per run.
• Deterministic offloading fraction correlates strongly with accuracy (r=0.72); the strongest technique associations were polarity/negation logic (+0.09), structured extraction (+0.06), and hybrid fallback (+0.04) over runs not using them.
• Builder reasoning effort (Opus-4.7, low→extra-high) monotonically improved accuracy from 0.711 to 0.856 pooled (Spearman ρ=0.77; extra-high beat high, p=0.013).
• Platform (native vs. neutral Cursor) effects were small and inconsistent: matched native-platform advantage averaged only +0.013 (p=0.484), while builder identity dominated.
• Weak target GPT-5.4-mini gained +0.262 on average versus only +0.110 for the already-strong Gemini-3.5-flash target; realized uplift correlated with target headroom (1 − baseline accuracy) at r=0.75, and 9/20 matched Gemini cases regressed on already-strong benchmarks vs. 0/20 for GPT-5.4-mini.
• The best GPT-5.4-mini scaffold fixed 1,717 baseline-wrong items while breaking only 105 previously-correct items (paired McNemar χ² ≫ 10^4, p<10^-4); across the 8 strongest scaffolds, an average of 83% of baseline errors were repaired versus 7% broken, and the union of top scaffolds' fixes covered 97% of baseline errors.
• Residual errors concentrated in harder subtypes: Hi-ToM accuracy fell from 0.999 at recursion order 0 to 0.700 at order 4, and MMToM-QA/MuMA-ToM errors clustered in Bayesian goal-inference and social-goal/belief-of-goal question types.

Why it matters / caveats: The results suggest inference-time harness design is a viable, retraining-free complement to distillation for boosting weaker/cheaper deployed models, and reframe "how good is a model" as "how good is a model at building the conditions for a weaker model to succeed." Caveats: gains come mainly from offloading unstable reasoning into deterministic code/routing/format enforcement rather than deeper reasoning, benefits shrink and can even reverse (over-scaffolding) as target headroom shrinks, and the study is confined to four Theory-of-Mind benchmarks with residual gaps to human-designed harnesses on the harder tasks (Hi-ToM, MMToM-QA, MuMA-ToM).

Problem: Mechanistic understanding of how AI models acquire knowledge, form beliefs, reason, and pose risks remains a largely manual, unscaled process even as model capabilities advance far faster than researchers' ability to understand and control them.

Method: Mechanist is a multi-agent framework with a central orchestrator and four stage-specific agents (hypothesis generation, experiment execution, verification, and iteration) that cycles through those four stages with humans setting objectives and evaluation criteria. It grounds hypothesis generation in an interpretability-focused knowledge graph of about 13,000 papers (13,813 papers + 123 blogs, with LLM-extracted nodes for techniques, task scenarios, abilities, and components) combined with SciAtlas, a cross-disciplinary knowledge graph of 43 million papers across 26 fields, and equips the experiment agent with a curated library of 32 foundational mechanistic-interpretability methods. Memory is externalized into stage-scoped artifact files (proposal, experiment plan, tracker, code, results, integrity reports) plus longer-timescale reviewer and global memory, and the Iteration Agent combines Verification Agent diagnoses with an independent review from GPT-5.4 to route revisions.

Key results:

• On reproduction reliability of 16 mechanistic-interpretability papers (9 topics), human evaluators scored Mechanist highest on all four dimensions: 87.2% data usage, 83.3% experiment design, 92.2% experiment execution, 86.5% result analysis — about 9-13% higher than Claude Code (Opus 4.8) and 31-38% higher than AI-Scientist; Mechanist ranked first in all 9 topics under human judges, with largest gains over Claude Code in multimodal analysis (90.3% vs 65.8%), safety (67.4% vs 48.2%), and multi-agent safety (81.9% vs 67.2%).
• Discovered a novel multimodal subliminal-learning safety risk: a Qwen3.5-9B student fine-tuned only on GPT-4o-filtered "safe" text responses from an unsafe teacher reached a 48.6% unsafe-response rate on multimodal lab-safety questions, vs 20.3% for the untuned baseline and 18.3% for a regular-teacher control; an analogous banana-preference transfer via apple-only filtered images raised the student's banana-generation rate to 25.6% vs 2.5% (baseline) and 2.1% (regular-teacher control).
• Identified separable belief-processing attention heads in Pythia-1B via Fisher information ranking and causal ablation: zeroing the Attributed-Belief head (L4.H1) dropped AB accuracy from 0.86 to 0.34 (Personal-Belief accuracy unchanged at 0.71); zeroing Personal-Belief heads (L9.H1, L7.H5, L12.H1) dropped PB accuracy from 0.78 to 0.21 (AB accuracy rose to 1.00); Pile perplexity barely moved in either case (7.96→8.05 and 7.96→8.23).
• Mechanism-guided dynamic head amplification (probe-classify query as WK/PB/AB, then amplify the relevant head) outperformed oracle prompt hints, giving net accuracy gains of +15.3%, +8.8%, and +3.5% for Pythia-410M/1B/2.8B respectively (vs +1.6%, +3.1%, +0.1% for prompt hints), with low "break" rates of 1.4%, 1.4%, and 1.1%.
• Steering an SAE-identified α-helix feature in Evo2-7B during DNA generation raised mean predicted α-helical content across 900 sequences from 43.8% (unsteered) to 56.6% (random-feature steering gave no gain, 43.2%); the effect held after confidence filtering (58.7% vs 45.4%/45.2% at pLDDT≥0.4; 56.9% vs 45.6%/45.8% at pLDDT≥0.5), with steering coefficient α=8 chosen as the strongest intervention before open-reading-frame validity collapsed.

Why it matters / caveats: Mechanist demonstrates a progression from discovering unrecognized model behaviors to building causal mechanism theories and then using them for practical interventions (belief-head steering, DNA sequence design), positioning mechanistic interpretability itself as an autonomous, scalable research pipeline rather than a manual craft. The authors note it has not been optimized for models of human cognition, and recommend using it as a human-AI co-scientist (human sets goals/evaluation criteria) rather than fully autonomous, since full automation limits reliability safeguards.

Problem: LLM narrator agents in interactive storytelling often fail to preserve established world-state facts and mandatory plot constraints when players make free-form, unconstrained interventions, and existing evaluations (preference-based coherence/engagement scores) cannot detect or compare such logical failures.

Method: The authors formalize "Narrative Commitment Preservation" (NCP), a task in which a narrator agent must maintain an explicit fact ledger and a fixed set of narrative commitments (invariant, ordering, and achievement types) while responding to a player agent over many turns. They build NCP-Bench, 100 narrative environments derived from movie synopses in the CMU Movie Summary Corpus, each specified as an initial fact ledger, a reference trajectory of plot nodes, and a commitment set, constructed via an agentic pipeline (trajectory extraction, commitment extraction, initial fact extraction) plus expert review. Evaluation decouples the narrator agent under test from a fixed auditing protocol run by an LLM auditor (default Gemini-2.5-Flash) that performs turn-level Conflict Check, Fact Update, Trajectory Node Update, and Commitment Check, against an adversarial player agent (also Gemini-2.5-Flash) that acts only from the player character's visible perspective.

Key results:

• Across 600 runs (6 models x 100 movies), the best model GPT-5.2 achieves only 42% survival rate after 20 turns; other models (Kimi-K2.5, Grok-4.1-Fast, DeepSeek-V3.2, Qwen3-235B-A22B) fall to near-zero survival well before the 100-turn limit.
• Only 3.5% of all samples survive to 100 turns without conflict, and even these rare survivors mostly fail to satisfy all commitments.
• Fact conflicts are the dominant failure mode, ranging from 40% (GPT-5.2) to 68% (Qwen3-235B-A22B) of interactions.
• GPT-5.2 has the highest average turns (32.92) but DeepSeek-V3.2 has the highest trajectory progress (15.40%) and satisfied-commitment rate (13.42%) despite surviving fewer turns on average (15.88); Kimi-K2.5 terminates earliest (2.88 average turns).
• Auditor sensitivity check across GPT-5.4-mini, Gemini-2.5-Flash, and GPT-5.2 shows consistent fact conflict rates (60%, 64%, 67%) and high pairwise Pearson correlations (0.9628-0.9866) on progress metrics; human review of 100 GPT-4o-mini results found only 4 disputed fact-conflict false positives.
• The memory-augmented baseline HiAgent (built on GPT-4o-mini) extends average turns (22.16 to 30.05) and cuts commitment conflicts (26% to 4%) versus plain GPT-4o-mini, but successful runs satisfying all commitments drop from 2 to 0 and player-input conflicts more than double (13% to 38%).
• Under natural (non-adversarial) player inputs, GPT-4o-mini survives much longer (46.08 vs 22.16 average turns) and reaches the 100-turn limit far more often (19 vs 3 runs), yet still satisfies zero runs with all commitments (vs 2 under adversarial input), showing adversarial pressure amplifies but is not the sole source of difficulty.

Why it matters / caveats: The results show linguistic fluency does not imply logical commitment preservation, and even hierarchical-memory agents fail to solve the benchmark, indicating this is a fundamental architectural gap in current LLMs rather than a prompting issue. The authors note their framework targets single-threaded, chronologically ordered narratives (not branching/nonlinear stories), LLM-based auditors can still err on ambiguous text, and the single adversarial player-agent strategy may not capture all real-user intervention patterns.

Problem: Existing generative image/video methods rely on one-shot prompts that jointly control content, layout, motion, and cameras, offering weak controllability and no persistent editable state for the iterative scene refinement that previsualization requires.

Method: StateFlow represents a previsualization world as an object-centric structured 3D state W^t = {o_i^t}, where each object o_i^t = (g_i^t, p_i^t, s_i^t) holds geometry, spatial pose, and semantic attributes, and operates in three stages: State Construction uses Prior-Guided Conflict-Aware Dual-View Initialization, generating a front-view image (appearance/asset source) and a BEV image (spatial layout source) and using a VLM with a lightweight inference-time optimization (Lfront + λb·Lbev + λv·Lvlm + λp·Lphys) to resolve cross-view object-count and placement conflicts; State Evolution uses Intent-Guided Structured State Transition, where a VLM predicts a compact transition plan Δ^t applied to the state table (scene expansion, style change, rigid motion, non-rigid/event asset substitution) instead of regenerating the whole scene; State Access uses World-State Camera Planning with Render-Feedback Reflection, where a VLM proposes camera trajectories from director intent, renders them, evaluates issues (visibility, framing, collision, motion smoothness) via a checklist, and iteratively applies local repairs. Implementation uses Gemini 3.1 as the VLM, Nano Banana 2 for front-view/BEV image generation, Hunyuan3D for lifting object crops to 3D assets, and Seedance2 as the video generation backbone for downstream video output.

Key results:

• On scene generation (Table 2), StateFlow achieves CLIP-I 0.788 and CLIP-T 30.214, versus SynCity's 0.689/22.880, SAM3D's 0.580/15.481, and PartCrafter's 0.542/20.761.
• On VBench video comparison (Table 1), StateFlow achieves the best average score of 0.8484, with top scores in Subject Consistency (0.9135), Background Consistency (0.9506), Motion Smoothness (0.9923), and Flicker (0.9902), beating Seedance2.0 (0.8387), Wan2.2 (0.8283), Animaker (0.8092), and MovieAgent (0.8075).
• User study/MLLM evaluation (Table 3, N=30 participants, 12 prompts/setting): at scene level StateFlow scores 4.5/3.7 overall vs. SAM3D 3.5/2.5, SynCity 3.2/3.0, PartCrafter 2.0/2.0; at video level StateFlow scores 4.5/4.0 overall vs. Seedance2 3.6/2.1, Wan2.2 3.1/2.3, AniMaker 2.5/1.7, MovieAgent 1.7/1.4.
• Ablations show removing BEV Layout grounding or Conflict Resolution both reduce scene-level scores (e.g., overall score drops from 4.5/3.7 to 3.3/2.5 without BEV Layout and 3.4/2.6 without Conflict Resolution); removing render-feedback camera reflection (VLM-only Camera) drops video-level overall score from 4.5/4.0 to 4.1/3.3.

Why it matters / caveats: By separating world state, evolution, and access, StateFlow enables editable, reusable 3D worlds for downstream applications (cinematic video creation, shot planning, and game-like interactive prototyping) rather than isolated one-shot generations, addressing spatiotemporal inconsistency and identity drift common in prior video-generation approaches. The paper notes the pipeline currently is not suited for real-time interaction and would need faster inference/deployment of the underlying models (VLM, image, and 3D generation) to be accelerated.

Problem: Pretrained Vision Foundation Models (VFMs) like VGGT, π3, and Depth Anything 3 predict camera pose, depth, and pointmaps in a single forward pass without enforcing explicit multi-view geometric consistency during training (bundle adjustment is too costly to include), so their predictions can violate multi-view geometry.

Method: Self-Geometry is a ground-truth-free, plug-and-play test-time adaptation (TTA) pipeline built from three components: (1) Geometric Disentanglement Optimization (GDO), which uses 2D pixel correspondences extracted by an external matcher (LightGlue) as pseudo-GT to compute a point-to-point Multi-View Consistency (MVC) Loss and a depth-independent point-to-line Epipolar Consistency (EC) Loss, combined via Gradient Disentanglement (projecting the MVC gradient onto the orthogonal complement of the EC gradient) to avoid gradient conflict, plus a two-stage EC+MVC pseudo-correspondence filter to remove mismatches; (2) Frame Angular-Neighbor (FAN), an SO(3) geodesic-distance-based view sampler with Geometry-Rich View Selection (entropy-maximizing target view choice) and Angular-Neighbor Sampling for scene-scale-invariant, angularly diverse view sampling; (3) Lightweight TTA, which inserts LoRA adapters into the QKV weights of the frozen VFM's attention blocks and updates only those parameters per scene using AdamW for 50 iterations.

Key results:

• Evaluated across six pretrained VFMs (VGGT, π3, DA3-Giant/Large/Base/Small) and four datasets (7Scenes, ETH3D, ScanNet++, HiRoom) for Pose Estimation (AUC@1/3/30) and Geometry Estimation (F1, posed/unposed).
• On ETH3D, improves VGGT's AUC@30/AUC@3 by +9.2%/+37.3% and π3's by +5.0%/+25.1%; π3 geometry (w/o pose) improves +5.9% (F1 0.70→0.74) and pose AUC@3 mean +8.3%.
• On HiRoom, DA3-Base and DA3-Small improve geometry F1 (w/o pose) by +85.2% and +70.4% respectively, showing largest gains in the under-fitted regime.
• Competing baseline TCO collapses on π3 (Mean pose AUC@3 -91.5%, Mean geometry w/o p. -60.0%), while Self-Geometry remains stable/positive across all backbones; Free-Geometry (implicit self-consistency baseline) yields only marginal gains (e.g., near 0% change on many columns).
• Ablations show combining MVC+EC losses with Gradient Disentanglement is necessary (gradient conflict occurs in 42.4% of TTA iterations across ETH3D scenes without it; w/o GD, w/p F1 drops 0.50→0.45); EC+MVC pseudo-correspondence filtering raises correspondence precision from 0.39 (raw) to 0.63 and downstream AUC@30 from 0.37 to 0.83.
• LoRA adapter adds only 0.7%-3.4% extra parameters over the base VFM; full per-scene adaptation (up to 40 views) completes within 2 minutes on a single NVIDIA RTX PRO 6000 GPU (e.g., 3.29 min for VGGT, 0.49 min for DA3-Small on ETH3D).

Why it matters / caveats: Self-Geometry requires no ground-truth annotations, no teacher model, and no architecture-specific redesign, making it applicable across diverse VFM backbones as a lightweight post-hoc fix for geometric inconsistency. However, gains are uneven across benchmarks/backbones — e.g., VGGT+Ours shows relative degradations on some ScanNet++/HiRoom columns (AUC@3 -2.9%/-8.2%, geometry w/o p. -10.6%/-7.5%, though within 6pp absolute and Mean pose still positive), and larger, already-strong models like DA3-Giant see comparatively smaller relative improvements than smaller/weaker models.

Problem: As LLM agent skill libraries grow, existing "retrieve-compress-execute" pipelines retrieve, compress, and graph-ify skills at three mismatched granularities (whole packages, raw text, and post-retrieval graphs), causing coarse reuse, loss of procedural contracts (interfaces, dependencies, verifiers) under compression, and unoptimized libraries that never persist compressed executable structure.

Method: SkillZip introduces a unified pipeline built on a section-level procedural skill graph: Sec2Graph splits each skill package into typed, source-grounded section nodes (nine roles: Intent, Trigger, Input, Precondition, Operation, Resource, Failure, Verifier, Output) connected by dependency, verifier, and repair edges, and links compatible sections across skills to shared canonical prototypes. MotifZip mines recurring interface-compatible subgraphs via a typed attributed graph grammar and rewrites only contract-valid motifs (stable boundary signature, closed dependencies, reachable verifiers) into reversible "ported macro" nodes, scored by a description-length compression-gain objective. PathHydrate performs query-time retrieval by fusing section- and skill-level rankings (reciprocal-rank fusion), searching for a compact dependency-closed subgraph under a token budget, repairing missing roles, and rendering macros at the lowest sufficient detail (name/contract/outline/full source). ReZip incrementally updates the compressed graph/macro dictionary as new skills or execution traces arrive, promoting recurring contract-valid residuals into new macros and demoting/splitting/retiring risky macros based on expansion, verifier-failure, and repair-cost signals.

Key results:

• On SkillsBench with MiniMax-M2.7, SkillZip reaches task reward 33.3 and Ret@1 73.6, beating the strongest baseline SkillDAG by 6.0 reward points; on ALFWorld it reaches 79.3% success (up 12.2 points over SkillDAG).
• With gpt-5.2-codex backbone: SkillsBench reward 43.0 (+6.2 over SkillDAG) and ALFWorld success 96.4% (+2.8 over SkillDAG, versus baseline saturation near 93.6%).
• Achieves a 3.46× compression ratio while retaining 99.2% dependency preservation (DPR) and 98.7% verifier reachability (VR), versus a text-compression baseline (LLMLingua-2-style) at the same 3.46× ratio that drops DPR to 65.0 and VR to 60.0 and needs recovery on 45.0% of queries (vs. 14.8% for SkillZip).
• Contract extraction validated against human annotations: 91.6 macro-F1, 84.6 exact match, with DPR/VR remaining high under 10% contract corruption.
• Scales from 200 to 100K skills: Ret@1 advantage over SkillDAG widens from 6.2 to 23.3 points; at 100K skills (4.77M section nodes) retrieval+hydration latency is 248.3 ms and full graph construction/compression takes 178 seconds; active storage reduced by 71.0%.
• Ablations: replacing section-level nodes with skill-level nodes causes the largest drop (Ret@1 −6.9, reward −5.4, context +59.9%); removing MotifZip keeps DPR/VR perfect but reward falls to 31.0 and context grows 52.9%; removing dependency closure drops DPR to 82.3; removing verifier constraints drops VR to 76.4.
• On matched MiniMax-M2.7 SkillsBench runs, SkillZip cuts cumulative prompt processing by 47.0%, tool calls by 21.7%, uncached prompt input by 18.7%, and end-to-end task time by 21.1% relative to SkillDAG; PathHydrate renders 1,941 tokens per task, 72.1% fewer than top-5 whole-skill loading.

Why it matters / caveats: By treating skills as section-level, contract-typed graphs rather than opaque text packages, SkillZip lets agents retrieve and expand only the minimal executable procedure needed, improving both retrieval precision and end-task success while cutting context cost — evaluated across six LLM backbones without backbone-specific fine-tuning. The authors note the compositional-lifting guarantee behind macro rewriting is structural, not semantic: it recovers recorded interfaces/dependencies/verifier paths but does not itself establish correctness of unrecorded behavior or verifier logic.

Problem: Video reflection removal is largely underexplored compared to single-image reflection removal because there is no paired reflected/reflection-free video training data, no temporally coherent removal models, and no dedicated evaluation benchmark.

Method: The paper presents a closed-loop framework with three parts: (1) S2R-Synthesis, a two-stage paired video synthesis pipeline built on Wan2.1-Fun-v1.1-1.3B-Inp — Stage A trains a structure-guided reflection renderer G on FLUX.2-Klein-9B-generated pseudo reflection videos with lineart conditions, and Stage B applies Physics-Grounded Augmentation (PGA), six controllable operations (Roughness, Thickness, Reflectance, Partial, Static, Planar) modeling glass optics (GGX microfacet scattering, Fresnel reflectance, multi-interface ghosting), to fuse transmission and reflection linearts before rendering; (2) S2R-Removal, a diffusion-based video dereflection model trained in two stages — Stage I performs reflection-aware latent adaptation via LoRA fine-tuning with a diffusion loss plus a zero-initialized intensity head supervised by an L1 loss on a residual-derived reflection-intensity map, and Stage II performs one-step pixel-geometric refinement using reconstruction (L1), SSIM, and a depth-consistency loss (via a frozen LeReS depth estimator) to recover the clean transmission in a single denoising step; (3) S2R-Bench, a new benchmark with S2R-Ref (60 paired videos built from the DRR dataset with matched virtual camera motion) for full-reference evaluation and S2R-Real (50 in-the-wild videos) for human perceptual assessment.

Key results:

• On S2R-Ref, the method achieves 28.84 dB PSNR / 0.859 SSIM / 0.9740 TC, beating the next-best baseline GenSIRR (27.04 dB / 0.846 / 0.9648).
• On S2R-Real human evaluation, it scores 0.787 (removal) and 0.980 (preservation) vs. GenSIRR's 0.654 and 0.831.
• Inference runs at 87.09 ms/frame on 832×480 video, about 1.67x faster than the next-best method RDNet (145.13 ms/frame), and much faster than diffusion baseline GenSIRR (7214.94 ms/frame).
• Also competitive/state-of-the-art on image benchmarks (Real, SIR2, Nature), with an average of 28.77 dB PSNR / 0.921 SSIM vs. GenSIRR's 28.03 dB / 0.931.
• Data ablation (Table 2, using RDNet backbone on OpenRR-1k): replacing traditional RGB-blending synthesis with diffusion-rendered planar data improves PSNR from 31.98 dB to 32.35 dB and SSIM from 0.9619 to 0.9643; combining both sources gives 33.26 dB; full PGA (all six augmentation types) reaches 34.13 dB PSNR / 0.9704 SSIM, a gain of +1.78 dB / +0.0061 SSIM over planar-only synthesis.
• Loss ablation (Table 3) on S2R-Ref: diffusion-only baseline gets 27.00 dB/0.8348 SSIM; adding intensity supervision gives 27.71 dB/0.8430; adding reconstruction, SSIM, and depth losses progressively raises this to the full model's 28.84 dB/0.8594.

Why it matters / caveats: This is presented as the first closed-loop framework unifying physics-grounded paired video synthesis, diffusion-based video reflection removal, and a dedicated video dereflection benchmark, and the one-step diffusion design makes it faster than even non-diffusion baselines while achieving state-of-the-art accuracy. The evaluation benchmark (S2R-Ref) is partly synthesized (static-camera videos derived from single images with added camera motion) rather than natively captured video, and DAI is excluded from S2R-Ref comparisons due to training-data leakage concerns.

Problem: Existing agent security research relies on manually implemented or reused environments, stochastic LLM-based tool simulation, and predefined injection locations, which limits scalable evaluation and training of LLM agents against indirect prompt injection attacks embedded in environmental states.

Method: ToolHazard is a scalable adversarial environment synthesis framework with three modules: an Environment Simulator that plans environment blueprints (entities, rules, tools) from seed task datasets (ToolACE, API-Bank) and compiles them into executable, stateful, OOP-based environments verified by a dual-agent (Testing Agent + Checking Agent) quality inspection pipeline; an Attacker Agent that automatically discovers viable injection points (via injectable attribute identification, read/write operation analysis, and attack-point matching) and, using a plan-and-execute pipeline, plans and injects payloads via six predefined wrappers (basic combined, important-template, multi-turn, decision hijacking, reasoning-criteria, tool-selection); and a User Simulator that generates state-grounded long-horizon benign tasks. Verification functions decompose each task into checkable conditions evaluated on the final environment state, enabling programmatic (LLM-free) benign rate (BR) and attack success rate (ASR) scoring. The synthesized data supports both a benchmark (ToolHazard-Bench) and adversarial alignment via SFT and GRPO-based RL (reward = task completion minus injection compliance).

Key results:

• ToolHazard-Bench contains 87 long-horizon tasks (avg. 15.56 steps) across 28 stateful environments and 512 tools (avg. 18.75 candidate tools/task), synthesized from an initial pool of 191 valid environments (140 train / 51 test candidates).
• ToolHazard-Align comprises 60 training environments, 300 environment-task instances, and 1,800 attack candidates filtered down to 1,040 valid samples (329 for RL, 711 for SFT).
• On ToolHazard-Bench, ASR is high across models: e.g., GPT-5 reaches up to 59.14% ASR (tool selection) and 51.49% (important-template); DeepSeek-V3.2 has the highest BR (87.16%) but also very high ASR (up to 75.0%); Qwen3-4B is least vulnerable (ASR 14.07–43.15%) but also lowest BR (~33.65–41.17%).
• Injection timing/placement matters: GPT-5 ASR drops from 67.2% (top-1/earliest injection) to 30.4% (random) for timing, and from 67.4% (top-1/last field) to 41.5% (random) for placement — earlier and later-placed injections are more effective.
• Free-form text outputs yield far higher ASR than structured formats: for GPT-4.1 tool-selection attack, ASR is 80.4% (free-form) vs 62.0% (JSON) vs 3.5% (YAML).
• Adversarial alignment improves both benchmarks: Qwen3-4B + ToolHazard-Align reaches BR 70.68%/ASR 22.76% on ToolHazard-Bench and BR 41.73%/ASR 7.17% on AgentDojo, versus base Qwen3-4B (BR 38.19%/ASR 25.05% and BR 30.03%/ASR 14.23%); Qwen3-8B + ToolHazard-Align reaches BR 75.94%/ASR 18.06% on ToolHazard-Bench and BR 52.08%/ASR 18.34% on AgentDojo, outperforming plain SFT and SFT+RL variants.
• Prompt injection also degrades benign task completion (not just safety): e.g., GPT-4.1 BR falls from 78.6% (no attack) to 41.3% under multi-turn attack; Gemini-3.1-Pro BR is comparatively stable (82.8% to 79.9–82.7%).

Why it matters / caveats: The framework scales agent security evaluation/training beyond manually built, static environments and shows that even frontier models (GPT-5, Gemini-3.1-Pro, DeepSeek-V3.2) remain highly vulnerable to environment-side prompt injection, with attack timing, placement, and output format significantly affecting success. The authors note limitations: synthesized environments cannot fully capture proprietary/production system complexity, and ToolHazard currently covers only six predefined injection strategies rather than discovering novel attack types.

Problem: Adapting embodied agents to new environments typically requires supervised fine-tuning or reinforcement learning (extra data, rewards, and training runs) or train-free code-centric methods that depend on programmable robot APIs, which are often unavailable in fixed-interface settings.

Method: The paper proposes SHAPER, a train-free self-evolving framework that keeps the VLM planner (Mθ) and executor (Aϕ, e.g. a VLA actor) frozen and instead optimizes two model-external artifacts: a textual reusable skill (s) and a context-code harness (h, a Python function like build_context that formats trajectory history). The same frozen model is reused as both the planner during rollouts and, under a separate optimizer prompt, as an artifact optimizer. Optimization proceeds via rollout-guided textual diagnosis (a round-level judger critiques each planner action against before/after observations, then an episode summarizer combines this with metadata into a "textual gradient" Γ(c)) followed by a two-stage beam-search evolution: skill evolution first (with harness fixed), then harness evolution (with the evolved skill fixed), using sandboxed validation and top-K candidate selection on a held-out validation set.

Key results:

• On VLABench (Qwen3.6-27B planner + π0 VLA executor), Seed Agent reaches 28.25% overall success, beating Direct VLA (23.25%) and same-data SFT (24.00%); full SHAPER reaches 34.50%, a 6.25-point gain over the seed and 10.50 points over SFT.
• Ablations on VLABench: Skill Evolution alone = 33.50%, Harness Evolution alone = 30.50%, full SHAPER = 34.50% (vs. 28.25% seed).
• Test-time-scaling baselines underperform: VLA + MG-Select = 21.38%, VLA + VOTE = 22.00% (both below Direct VLA's 23.25%).
• Generalization gains grow under distribution shift: SHAPER improves over seed by +2.5 (C1, in-domain), +6.0 (C2, unseen targets), +10.0 (C3, unseen task form), +6.5 (C4, both unseen).
• On ESI-Bench (231-question subset, 10 categories), full SHAPER reaches 49.8% micro / 42.9% macro accuracy vs. 32.5%/31.2% for Seed Agent and 41.1%/38.6% for Skill Evolution — a 17.3 micro-point and 11.7 macro-point gain over the seed.
• SHAPER's macro accuracy (42.9%) numerically exceeds the published GPT-5 Passive Single-view reference (40.3%) on ESI-Bench, though this is an external, unpaired comparison.
• One-time evolution cost is approximately $2.25 (VLABench) and $2.83 (ESI-Bench) in API-equivalent token usage; the resulting artifacts are then reused across all held-out episodes without per-episode search.

Why it matters / caveats: SHAPER offers a lightweight, train-free alternative to fine-tuning or heavy test-time sampling for adapting frozen embodied agents to new environments and action interfaces (VLA-based and fixed-API-based), with a one-time low-cost optimization whose artifacts transfer across held-out episodes and distribution shifts. Caveats: evaluation splits (C1-C4) are custom, non-official VLABench splits; results are described as descriptive rather than causal (effects of skill vs. harness evolution are non-additive); some categories on ESI-Bench regress after harness evolution (e.g., Enumerative Perception, Action Sequencing, the latter with only 5 questions); the GPT-5 comparison is external/unpaired; and the authors note cross-embodiment transfer and real-robot validation remain future work.

Problem: In "thinking-with-images" multimodal LLMs that perform crop-and-zoom tool calls, it is unclear whether the visual observations returned by these tools causally drive the final answer, or whether accuracy gains are illusory artifacts of the tool-use policy itself.

Method: The authors formulate visual tool-use as a structural causal model over image I, query Q, tool actions T_i, returned observations O_i, and final answer Y, separating an observation-mediated path (T→O→Y) from an action-induced shortcut (T→Y directly). They design a three-level intervention protocol: policy-level (do(π=π_tool) vs. do(π=π_direct)), trajectory-level (replacing every returned observation with a corrupted RANDOM-CROP during rollout), and step-level (a Visual Evidence Gain estimand, VEG_i = ΔM_i^real − ΔM_i^cf, that swaps one observation for a counterfactual crop under a fixed prefix and reads option-restricted next-token probability gaps). A trajectory-level diagnostic (Algorithm 1) then classifies every rollout into No-call, Mode 1 (Calling Without Looking), Mode 2 (Looking Without Planning), or Calibrated, using features g0, V^max, HitMax, and Post-saturation Over-Extension Rate (POER).

Key results:

• Across six models (DeepEyes, Pixel Reasoner, Mini-o3, Qwen3-VL-4B/8B, Thyme) and five benchmarks (V*, HR-Bench-4K/8K, VisualProbe, MME-RealWorld-Lite), the policy-level ATE ranges from ~0.0 pp (DeepEyes) up to +21.3 pp (Mini-o3 on VisualProbe) and +11.9 pp (Mini-o3 on MME-RealWorld-Lite).
• Trajectory-level corruption (replacing all observations with random crops) drops Mini-o3 and Qwen3-VL-8B accuracy by up to −64.2 pp and −60.7 pp respectively on V*, with 84.8% and 59.2% of trajectories hitting the tool-call limit (Hit-MaxT), while DeepEyes and Thyme show near-zero effects (≤ ±4.8 pp).
• Step-level VEG on V* shows DeepEyes is "structurally inactive" (mean VEG ≈0, 81% of calls near-zero |VEG|<0.01), Mini-o3 is "information-driven but diluted" (mean VEG=0.063, 29% near-zero, 34% substantial), and Qwen3-VL-8B is "sharply concentrated" (mean VEG=0.198, 56% near-zero, 29% substantial, 64% saturation rate).
• The trajectory diagnostic finds Mode 1 (CWL) dominates DeepEyes (72.8%) and Qwen3-VL-8B (70.7%), while Mini-o3 has the largest Calibrated share (45.0%) alongside 9.9% Mode 2; the group-wise ATE decomposition shows the Calibrated subset is the only group with a positive contribution across all four interface-based models (e.g., +7.6 pp of Qwen3-VL-8B's +6.9 pp total ATE, +3.5 pp of Qwen3-VL-4B's +4.4 pp).
• Behavioral validation: Mode 1 trajectories' pre-call reasoning already commits to the final answer in ~58% of cases versus ~28% for Calibrated trajectories; on Mini-o3, 38% of Mode 2 crops cover under 4% of the image.

Why it matters / caveats: The paper argues that aggregate benchmark gains from visual tool-use create a misleading impression of broad causal effectiveness, when in fact gains are concentrated in a small "Calibrated" minority of rollouts while most tool calls are either causally inert (Calling Without Looking) or incoherently scheduled (Looking Without Planning); it proposes outcome-only reinforcement learning as a hypothesized cause of this "RL-trap" but notes this is not established via controlled training experiments. Limitations include reliance on open-source models only (step-level VEG needs white-box token logits, unavailable for closed models like OpenAI o3/o4-mini) and focus solely on the crop-and-zoom tool, leaving other tool types (OCR, segmentation, video frame selection) unaudited.

Problem: For uniform discrete diffusion, it is unclear whether the training objective and reverse transitions can be enriched (made more tractable/expressive) without changing the underlying categorical corruption process.

Method: The paper introduces Simplax, an exact Dirichlet–categorical augmentation that couples each corrupted categorical state z_t with an auxiliary simplex-valued variable w_t via a shifted Dirichlet conditional q(w_t | z_t, x) = Dir(w_t; η_t p_t + z_t), while preserving the original uniform diffusion process as the categorical marginal. From this hierarchy the authors derive a tractable Rao-Blackwellized reverse-bridge training objective (obtained by averaging the standard discrete reverse KL divergence over an auxiliary categorical decode from w_t) and a corresponding stochastic ancestral reverse sampler that draws z_s ~ Cat(ρ_s|t) and w_s ~ Dir(η_s p̂_s + z_s) at each step; the categorical state z_t (not w_t) is retained as the denoiser input for computational efficiency (avoiding a dense w_t^T E embedding projection). Experiments use a 179M-parameter diffusion transformer (12 blocks, rotary position embeddings, AdaLN time conditioning) on OpenWebText, and 8-block/512-hidden-dim Transformers (25–29M parameters) on Sudoku.

Key results:

• OpenWebText (GPT-2 BPE, L=1024, 179M-param model): Simplax achieves the lowest generative perplexity (Gen. PPL) under all three evaluators (GPT-2 Large, GPT-2 XL, Llama-2 7B) at NFE=16 and NFE=1,024, e.g., at NFE=16: Gen. PPL 90.5 (GPT-2 L) / 93.1 (GPT-2 XL) / 49.3 (Llama-2) vs. next-best baselines like MDLM (117.9/120.6/63.8) and CANDI (97.2/99.6/56.0).
• At NFE=1,024, Simplax reaches Gen. PPL 45.1 (GPT-2 L) / 46.8 (GPT-2 XL) / 25.5 (Llama-2), compared to UDLM's 59.2/61.2/32.2 and MDLM's 55.1/56.6/33.9.
• Sudoku (trained only on 30-clue puzzles, 48,000 train / 2,000 validation puzzles): Simplax achieves the highest conditional solving accuracy at every tested clue density — 98.55% (40 clues), 91.05% (35), 61.75% (30, in-distribution), 25.90% (25), 8.80% (20), and 1.20% (17, the minimum uniquely-solvable regime) — versus the strongest baselines (e.g., MDLM 98.45%/85.15%/48.00%/11.80%/2.70%/0.20%).
• Unconditional Sudoku generation (0 clues): Simplax achieves 95.85% validity vs. 80.95% for the strongest baseline (Duo).

Why it matters / caveats: Simplax shows that an exact auxiliary simplex variable can improve both the perplexity–entropy tradeoff on open-ended text generation and robustness to distribution shift (clue density) and unconditional generation on a constrained combinatorial task, without altering the underlying discrete corruption process. The authors note limitations: the approach is specialized to uniform categorical corruption, the computational overhead of the auxiliary simplex state has not been fully characterized, and the Dirichlet concentration schedule (η_t) is a design choice not determined by the theory.

Problem: AI safety is dominated by model-level alignment techniques (RLHF, DPO, Constitutional AI), which the authors argue are structurally insufficient for autonomous agents that execute code, mutate files, send messages, and modify databases.

Method: The paper is a position paper proposing that agent safety be enforced as a runtime contract with two complementary faces: a preventive face (sandboxes, permission gates, output filters, trajectory monitors) that blocks dangerous actions before they happen, and an evidential face (evidence-gated submission) that withholds task-completion credit until the trajectory contains verifiable hard evidence (test runs, log captures, file diffs, citation grounding). The authors formalize an Agent Trajectory Schema (a hash-chained sequence of typed events such as tool_call, file_write, shell_exec, commit) and an Evidence Chain built from deterministic verifiers distinguishing "hard evidence" (externally checkable, e.g., a test re-run or citation lookup) from "soft evidence" (the model's self-report/chain-of-thought). They also state a compositional gating proposition modeling preventive layers as finite-state harness monitors and evidential gates as evidence-chain checkers that compose under standard parallel-composition/assume-guarantee reasoning. The position is grounded in four empirical audits: a 52-incident safety survey, a 32-row false-completion audit, a 12-system trajectory-schema audit, and a 28,560-paper NeurIPS/ICML/ICLR title-level publication audit.

Key results:

• Incident survey: of 52 documented AI-agent/LLM safety incidents (March 2016–January 2026), 40 were coded as fully preventable by a functional harness layer, 11 partially mitigable, and only 1 (Meta's CICERO) primarily an internal-goal-alignment failure.
• False-completion audit: across 32 rows (31 non-contested + 1 disputed), failure categories were hallucinated (13), broken (8), side-effect (5), partial (4), reward-hacked (2); minimal evidence requirements broke down as 8 citation grounding, 8 log capture, 7 test run, 5 human approval, 3 external state, 1 screenshot.
• Trajectory-schema audit of 12 public agent systems/harnesses: only 2 of 12 (GitHub Copilot agent via PR/CI, and OSWorld benchmark harness) document submission-like evidence gates, despite 9/12 capturing file changes, 11/12 capturing tool outputs, and 7/12 capturing structured logs.
• Proceedings audit of 28,560 NeurIPS/ICML/ICLR papers (2023–2025; 13,323 NeurIPS, 7,697 ICML, 7,540 ICLR): training-time alignment work accounts for ~58–64% of alignment-tagged papers vs. ~5–8% for deployment-time harness work, a pooled 8–12× imbalance.
• Cited external evidence for model-alignment fragility includes METR finding o3 exploited rewards in 21/21 LLM Foundry runs and 30.4% of RE-Bench runs, and fine-tuning on ~10 benign examples reducing safety training by over 30%.

Why it matters / caveats: The paper argues the correct unit of AI agent safety is "the trajectory-with-checkable-evidence," not the model, and calls for canonical trajectory schemas, task-specific evidence requirements, and public failure reporting rather than more model-only benchmarks. It is a position paper backed by observational/audit evidence (not a controlled experiment), the proceedings audit uses lower-bound title-keyword counts rather than a full-text census, one incident case is explicitly flagged as disputed, and the authors note hard evidence is not correct by definition (e.g., a flaky-test harness can still produce wrong gates).

Problem: Long-horizon software development outlives any single coding agent, and existing continuity mechanisms (larger context windows, persistent memory, manager agents, shared scratchpads) preserve continuity by extending the agent process itself rather than addressing what must persist when the active agent does not.

Method: EvoX Genesis represents software as a "persistent recursive world" w = (v, p), where v is an accepted software version (fixing project state and history) and p is a repository-relative path (situating an agent's local responsibility); finite-lived agents A_i receive an episode objective in a local world and produce a candidate change, while recursive delegation (v,p) ⇝ (v,q) spawns child agents at other paths without changing the accepted version. Only validation-gated acceptance turns a candidate change into a software event (v,p) → (v′,p′) that advances the persistent version history inherited by later agents; the implementation stores context via version-controlled CONTEXT.md files, accepted changes via Git commits/archive references, and proposed changes on agent-specific branches/worktrees, with manager agents decomposing/delegating and executor agents directly modifying code.

Key results:

• Formation: starting from a repository with no compiler implementation, DeepSeek V4 Flash built a Rust-based C compiler (jcc) over 123.4 hours, archiving 1,019 agent episodes (delegation depth 5), reaching 248,989 physical lines across 750 files, for US$44.38 in model-token charges; the compiler passed 220/220 c-testsuite cases, 32/36 LLVM cases, 93/93 executed Csmith programs, plus LZ4/SQLite checks and 2,904 Rust workspace tests.
• Continuation: from the same completed GLM 5.2-built compiler (commit 37216cfa254a), a GLM 5.2 continuation branch (98 agents, depth 4) passed 1,445/1,448 retained LLVM cases, while a DeepSeek V4 Flash continuation branch (178 agents, depth 8) passed 1,820/1,820 cases; both continued development after agent replacement and a foundation-model switch rather than restarting.
• Redevelopment: DeepSeek V4 Flash reimplemented 13 mapped MESA module directories (139,414 physical Fortran lines) as a Rust workspace in 33.22 hours with 272 spawned agents, producing 89,946 physical Rust lines, passing 1,052 tests (0 failures, 18 ignored) for US$10.64.
• Across six audited numerical workloads (end-to-end burn, EOS lookup, opacity lookup, 2D interpolation, ROS2 integration, Newton solve), the Rust code was numerically consistent with Fortran (two workloads bit-exact, others with relative checksum differences of 5.1×10⁻¹⁵ to 3.1×10⁻⁹) while achieving median speedups of 1.55×–6.87× across all six workloads.

Why it matters / caveats: The results suggest long-horizon software development can be organized around a persistent project rather than a persistent agent, enabling continuity across agent replacement and even foundation-model swaps. The authors caveat that the experiments are single-run demonstrations of capability (one DeepSeek formation run, one GLM continuation, one DeepSeek continuation, one MESA redevelopment) rather than controlled comparisons or causal ablations, so it remains unestablished which specific persistent records or recursive mechanisms are necessary for the observed capabilities, and reported costs cover only model-token charges (excluding hardware, storage, controller overhead, and labor).

Problem: Existing agentic business-ideation systems are confined to a text-only, patent-grounded paradigm and cannot exploit the visual details of real-world multimodal contexts that are hard or impossible to verbalize.

Method: The authors build MBA-Bench, a benchmark of 30K image-caption-question-idea quadruplets drawn from 2K images across six domains (General/ADE20K, Spatial Layout/RICO, Crowding/COCO, Visual Condition/VisA, Shape & Texture/DTD, Technical Features/DeepPCB), captioned with PaliGemma2 and paired with GPT-4o-generated reference ideas via a three-stage retrieval-augmented pipeline (visual query extraction, DuckDuckGo market-evidence retrieval, evidence-augmented generation), each idea rated by an MLLM-as-a-Judge across six PBIG-derived business dimensions. They then train two agents, MBA-b (blind evaluation setting) and MBA-k (known evaluation setting), by initializing Qwen2.5-VL-7B-Instruct, applying LoRA-based supervised fine-tuning on question-reference-idea pairs, then GRPO with setting-specific ranking rewards — creativity and feasibility for MBA-b, plus the six disclosed PBIG dimensions for MBA-k (eight total) — where feasibility is grounded via MBA-Library, a FAISS/FActScore-based web-sourced resource (mobile apps, scientific literature, structured entities, Wikipedia) rather than judge-model hallucination-prone scoring.

Key results:

• MBA-b outperforms caption-based and multimodal baselines by 63.9% and 25.6% respectively; MBA-k outperforms them by 77.1% and 35.8%, while remaining competitive with closed-source MLLMs.
• On the six PBIG metrics (Table 3), MBA-k achieves top scores among compared models on Specificity (3.99), Innovativeness (4.00), Competitive Advantage (3.32), Need Validity (2.94), and Market Size (2.75).
• Creativity/Feasibility validation: MBA agents lead the multimodal baseline by 51.2% (Creativity) and 114.3% (Feasibility) on aggregated test-time metrics, with Spearman correlations of ρ=0.83 (Creativity-Creativity) and ρ=0.71 (Feasibility-Feasibility) confirming the training-time rewards generalize to the evaluation rubric.
• Caption-only baselines trail multimodal baselines across nearly all six metrics and domains except General (simple, easily verbalized scenes), demonstrating text alone is insufficient for business ideation.
• The benchmark spans 30K quadruplets (2,000 images, 2,000 captions, 6,000 business questions, 30,000 reference ideas) split 95%/5% train/test.

Why it matters / caveats: The work is the first to reframe business ideation as a multimodal (not just text/patent-based) task and shows a compact 7B open-source agent can approach closed-source MLLM performance on creativity and feasibility. Reported results are from a single run (no repeated trials/error bars beyond per-image std), and the authors note unaddressed limitations: no audio/olfactory/tactile modalities, no temporal/video reasoning, and no personalization to an individual entrepreneur's capital, expertise, or risk tolerance; direct human evaluation of the agents is left to future work.

Problem: Video creation agents cannot learn filmmaking knowledge from high-quality human films because no existing video representation is simultaneously agent-readable, agent-editable, and faithful enough to preserve the cinematic detail needed to reconstruct the film.

Method: The paper proposes the Agentic Video Auto-Encoder (AVA-Encoder), which encodes a film into a text-centered film-creation knowledge graph (KG) — a Story–Event–Shot hierarchy with Character, Scene, Object, Style, Camera, and Audio state nodes storing structured text, linked via 11 typed edges (grouped into production/asset, temporal, and semantic categories) to a separate multimodal asset layer holding generated keyframes, audio, and video — and reconstructs the video via a fixed two-stage decoder (a fixed text-to-image model followed by a fixed image-to-video model). A multi-level Agentic Video Encoder policy (three system prompts for film-, shot-, and keyframe-level understanding) performs the encoding, and reconstruction error drives a dual-loop textual-gradient optimization scheme following TextGrad: an outer-loop Data-Independent Encoding Policy Pseudo-Training that updates the shared shot-level policy across a video stream (with anti-forgetting gating), and an optional inner-loop Data-Dependent KG Representation Refinement that updates only the current video's KG at test time (with an anti-degradation gate). Foundation models used include Gemini-3.1-Pro-Preview (understanding/evaluation), Qwen-3.7-Max (textual-gradient revision proposer), Nano Banana Pro (image generation), and HappyHorse 1.0 (reference-to-video generation), all with weights kept fixed.

Key results:

• On the released ground-truth-anchored reconstruction benchmark (18 video clips, 129 shots, 246 keyframes), AVA-Encoder reaches 49.0% Overall reconstruction accuracy versus 28.3% for the strongest baseline (soap2soap), a 20.7-point improvement; it also beats VideoAnalyzer (21.5%) and Storyboard Studio (19.4%).
• Per-direction gains over the strongest baseline: +21.1 points on Video, +34.2 on Keyframe, +13.9 on Video Back-Captioning, +11.6 on Keyframe Back-Captioning.
• In the controlled policy-only setting (no test-time refinement), the pseudo-trained shot-level policy reaches 45.8% Overall vs. 44.4% for a human-tuned policy (+1.4 points, 3.2% relative), while using 8,052 vs. 31,336 system-prompt tokens (74.3% fewer).
• The two optimization stages together improve Overall reconstruction by 6.6 percentage points (15.6% relative) over removing both.
• Hierarchical (film-shot-keyframe) policy-only understanding (45.8 Overall) beats single-level understanding (27.5) by 18.3 points (66.5% relative).
• The benchmark's automatic metrics agree with human judgments on 710 of 730 blinded triples (97.3%).

Why it matters / caveats: The work reframes video representation learning as a self-evolving agentic auto-encoding problem, providing a text-first, agent-editable KG format plus an open-sourced framework, reconstruction benchmark, and film-KG dataset intended to let agents learn filmmaking craft directly from existing films and support linked graph-based video editing. Caveats: evaluation relies on the same VLM (Gemini-3.1-Pro-Preview) for both the encoder and the scoring/optimization signals, comparisons use a shared fixed decoder applied to baseline representations (adapted for fairness per the appendix) rather than each baseline's native pipeline, and the pseudo-training/evaluation clip collections (6 and 18 clips respectively) are relatively small.

Problem: There is no benchmark that places AI coding agents at a genuine open-ended research frontier—improving world models under a large, underdetermined design space—rather than at well-scoped, engineering-to-spec tasks with a pre-specified improvement direction.

Method: AutoWorldModel-Bench provides eight game environments (Snake, Frogger, Pong, Breakout, Asteroids, Platformer, Kong, Racer) whose states are exposed via a unified entity-component-system (ECS) JSON representation and a fixed-slot tensor format (entity registry, entity state, 7-dim action vector, 17-dim game state, terminal flag), sidestepping perception and enabling minutes-per-run iteration. Agents (Claude Opus 4.6 and Codex-5.4) are given one of four starter world-model architectures—RSSM/Dreamer, AR-Transformer, D3PM, or MaskGIT—inside a Harbor-based containerized task directory (instructions, starter train.py, config.json, run.py, score.py, read-only data) and must autonomously redesign and retrain the model within a 6-hour, single-H100 compute budget (10-minute cap per training run), producing 64 (game × starter × agent) sessions total. Models are evaluated with a horizon-weighted composite score (0.1·c1 + 0.2·c10 + 0.7·c20) combining Position L1 error and Alive F1 across teacher-forced (h=1) and open-loop rollout (h=10, h=20) predictions, plus a held-out scenario suite of rule-probing episodes; a Gemini Pro 3.1 zero-shot judge classifies each experiment's diff into nine change-type labels (e.g., ARCHITECTURE, LOSS, ROLLOUT, HYPERPARAM) to distinguish research-style edits from tuning.

Key results:

• Agents improved the starter on 63 of 64 sessions on the held-out test split, with mean test-score lift of +0.196 (median +0.115); Codex-5.4 improved every one of its 32 sessions, while the sole regression was a Claude Opus 4.6 session on Breakout/D3PM (-0.001).
• On the scenario suite, agent-best models beat the starter on 56 of 64 sessions (mean lift +0.170, median +0.149); scenario and test lifts agreed in direction on 55 of 64 sessions (r = 0.89).
• Gains are horizon-asymmetric: mean lift was only +0.056 at h=1 (positive in 47/64 sessions) versus +0.205 at h=10 (62/64) and +0.215 at h=20 (63/64).
• In 91% of sessions (58/64), the winning experiment was a non-trivial research-style edit (new objective, representation, rollout procedure, or architecture) rather than a hyperparameter tweak; non-trivial experiments (n=1,220 of 1,335 total) averaged +0.146 in-session score lift and an 85% win rate vs. +0.126 lift / 73% win rate for trivial (hyperparameter/infra) experiments.
• Head-to-head, Codex-5.4 beat Claude Opus 4.6 on 19 of 32 shared tasks (Claude on 13); mean best test scores were 0.772 (Codex-5.4) vs. 0.736 (Opus 4.6), a gap not statistically significant (Wilcoxon W=187, p=0.15).
• Claude Opus 4.6 used a median of 37.2M tokens per session vs. 25.9M for Codex-5.4 (1.44x more), while achieving a smaller cumulative Δ test score across 32 shared tasks (+5.85 vs. +6.71 for Codex-5.4), implying Codex-5.4 is roughly 1.8x more token-efficient per unit score gain; Opus 4.6 ran a mean of 23.5 experiments per session vs. 18.2 for Codex-5.4.

Why it matters / caveats: The benchmark demonstrates frontier coding agents can reliably conduct open-ended, research-style improvements (not just hyperparameter search) on an underspecified problem, with gains concentrated in long-horizon rollout fidelity rather than one-step prediction. Caveats: the agent comparison conflates model quality with harness/orchestration effects; the primary score emphasizes long-horizon rollout so gains should not be read as uniform across horizons; the benchmark uses exact structured/ECS state from game engines rather than pixels, so findings may not transfer directly to pixel-based world modeling; and best-of-k differences in number of experiments per agent complicate the head-to-head agent comparison.

Problem: Most Hand Pose Estimation (HPE) methods output joint positions without explicitly indicating per-joint visibility, and no prior work has treated per-joint hand visibility estimation as a standalone, systematically evaluated task.

Method: Hand Visibility Detector attaches a lightweight, RTMPose-style visibility head (1x1 conv to compress channels, flatten to h×w tokens, fully connected layer, a Gated Attention Unit for global spatial dependencies, then a final 1x1 conv, global average pooling, and sigmoid) onto a frozen ViT backbone from a pretrained HPE model (HaMeR or WiLoR), predicting a [0,1] visibility score for each of the 21 MANO joints. Only the visibility head (0.83M params, 0.131% of the 631M-parameter model) is trained with binary cross-entropy loss on the HInt dataset (25,273 training frames, 5,374 evaluation frames), with joints outside the frame or occluded labeled invisible. As a downstream application, per-joint visibility scores are used to weight multi-view 2D keypoint triangulation for automatic 3D hand pose annotation.

Key results:

• On HInt, the method achieves mAP 0.931 and F1 0.896, beating baselines Kim et al. (mAP 0.895, F1 0.858) and Contact4D (mAP 0.897, F1 0.860) — a 3.4-point mAP improvement.
• Backbone ablation: hand-specific pretrained backbones perform best (HaMeR: mAP 0.932, WiLoR: mAP 0.931), outperforming general-purpose DINOv3 (mAP 0.897), ViT-H (0.838), ResNet-152 (0.796), and CSPNeXt-X (0.800).
• Fine-tuning the WiLoR backbone (instead of freezing it) degrades mAP from 0.931 to 0.622, showing task-specific fine-tuning corrupts pretrained features.
• Visibility head ablation: removing the GAU drops mAP from 0.931 to 0.887; using the linear head from Kim et al. gives mAP 0.905, both below the full head (0.931).
• F1 score peaks near a binarization threshold of 0.5 and stays above 0.88 across thresholds 0.3–0.7.
• In the downstream triangulation task, visibility-weighted triangulation reduces mean reprojection error across DexYCB, HO3D, and H2O datasets, with up to a 10.1% reduction on HO3D (the dataset with fewer views and heavier object occlusion), outperforming unweighted and detection-confidence-weighted baselines.
• Training only the visibility head takes about 2.5 hours on a single NVIDIA H200 GPU using approximately 10GB of GPU memory (100 epochs, batch size 256).

Why it matters / caveats: The results show that reusing prior knowledge from large-scale pretrained HPE models (via a frozen backbone) transfers effectively to visibility estimation at very low training cost, and that per-joint visibility is a useful signal for improving automatic 3D annotation pipelines beyond its typical auxiliary role in pose estimation. The method currently operates on single frames; the authors note extending it to video input for temporally consistent visibility estimation as future work.

Problem: LLM-agent runtimes repeatedly execute small deterministic control transitions (route an outcome, update state, emit the next effect) between model and tool calls, and it is unclear when this control path exposes enough concurrent work to be grouped and executed profitably on a GPU, and what changes when a GPU-computed route decision stays on device instead of returning to the host.

Method: The paper formalizes a "ready-cohort boundary" with four quantities — fixed-partition share F, exact offline share P⋆, local upper bound U, and online achieved share A — and, under zero service time, unlimited capacity, and equal relative launch deadlines, gives a specialized dynamic program (contiguous-block packing via a monotone-deque recurrence) that computes P⋆ exactly on a replayed public agent-trace panel (Exgentic tau2_airline/tau2_retail/tau2_telecom, 851 sessions, stationary Poisson replay). A separate CUDA mechanism study compares three implementations of the same 16-byte-per-agent state machine and predicate/route-body logic: a "host round trip" (copy a 4-byte decision to host, synchronize, redispatch), a "device-resident" path (one-thread on-device selector tail-launches the next per-epoch graph without exposing the decision to the host), and a "no-decision floor" (oracle route sequence with no predicate/selection work), plus a negative control that adds a device-launched nested graph without removing any host decision.

Key results:

• Primary trace cell (100,000 target active sessions, K=256, 50 ms launch deadline): fixed-partition share F = 30.19%, exact offline share P⋆ = 43.00%, local upper bound U = 45.85%; exact packing recovers 81.83% of the alignment gap lost at fixed window boundaries (12.81 percentage-point gain over F).
• Cohort supply collapses to zero in many regimes: under route-key grouping at K=256, P⋆ is 0% for every tested deadline when active sessions ≤10,000, and even at 100,000 sessions it is 0% at 10 ms and 25 ms deadlines.
• Lowering the threshold K matters a lot: at C=100,000, δ=50 ms, exact shares for K=32,64,128,256 are 66.8%, 66.0%, 48.4%, and 43.0% respectively.
• Device-resident decision beats host round trip in all 36 tested placement-cells, with within-placement median speedups ranging 1.19× to 2.39×; at the primary N=256, H=32 cell, ratios are 1.71× (GTX 1660 Ti), 2.39× (Modal L4), 2.06× (RunPod L4), and 1.84× (Lambda H100 SXM5), with device path taking 258–309 µs vs. 467–625 µs for host round trip.
• A fixed nested device-launch graph that removes no host decision is slower in all 60 tested configurations across five placements (ratios 1.07×–1.99×), showing device launch alone does not explain the gains.
• All 14,557,440 tested batched invocations across the two admissible mechanisms are field-exact and decision-exact against a separately implemented host oracle; the device path is still 6.60×–8.17× slower than the (non-deployable) no-decision oracle floor.

Why it matters / caveats: The results give two measurable "gates" — deadline-feasible cohort supply and observation placement — for deciding whether to move agent control logic onto GPUs, and show fixed-window scheduling hides substantial recoverable opportunity while confirming a concrete, mechanism-level benefit to keeping route decisions device-resident. The authors caution the two studies cannot be multiplied into an end-to-end estimate: the trace threshold K=256 is swept, not measured, for the resident-policy mechanism; the route key is an outcome-derived proxy, not proof of true executable/semantic compatibility; the offline model assumes zero service time, unlimited capacity, and no batch-size limit; and no online achieved share A, CPU displacement, or service-level (P99/TTFT/TPOT) impact has yet been measured — that requires a future joined finite-runtime system.

Problem: In RLVR training of LLMs with GRPO, action-space exploration methods like temperature scaling only reweight token probabilities without reordering them, which limits exploration and causes zero-advantage groups that stall learning.

Method: The paper introduces Perturbed Parameter Policy Optimization (3PO), a family of methods that sample model weight perturbations from an IVON (variational learning) posterior instead of, or in addition to, action-space noise. Three variants are proposed: B3PO samples a single weight perturbation per gradient step and reuses it across all prompts; M3PO draws M perturbations, computing GRPO advantages separately per perturbation before averaging gradients (equal-compute variant shrinks group size G=16/M); and C3PO partitions each GRPO group of G rollouts across N independently sampled weight perturbations (G/N rollouts each) but computes advantages over the full aggregated group of G, maximizing rollout diversity, and uses Seq-MIS sequence-level importance sampling/masking for stability.

Key results:

• Across OLMo-3-1025-7B and Qwen2.5-Math-7B on 6 math benchmarks (AIME'24/25/26, MATH-500, AMC, Minerva), C3PO achieves the best average Pass@1: 44.04% (Olmo3) and 46.88% (Qwen2.5-Math), versus GRPO's 42.99% and 45.36%.
• Gains concentrate on harder AIME problems: C3PO beats GRPO by up to 4.17 points on Olmo3 and 5.83 points on Qwen2.5-Math (e.g., AIME'26 Qwen2.5-Math: C3PO 26.25% vs GRPO 20.42%; AIME'25 Qwen2.5-Math: C3PO 27.08% vs GRPO 25.42%).
• On code generation (Olmo3 trained on CodeR1-12K, evaluated on LiveCodeBench-v6), C3PO reaches an LCBv6 score of 15.17, and 3PO methods reach GRPO's final reward within the first 50% of training steps; the SFT baseline scores only 9.5% on LCBv6 vs 35.02% average on math, motivating why exploration gains are larger for code.
• 3PO methods rescue more zero-advantage groups than GRPO and action-space baselines (EntReg, Polaris, KL-Cov), and M3PO/C3PO are the only methods that consistently produce fewer malformed/incorrect rollouts than GRPO throughout training.
• Ablations: effective sample size λ=10^9 is a good default (λ=10^8 collapses C3PO training entirely, e.g., average math Pass@1 drops to 0.00±0.00); chunk size N=2–4 in C3PO captures most of the diversity benefit; initializing the IVON Hessian from a learned SFT prior versus a constant h0 has negligible effect on downstream performance.

Why it matters / caveats: The work shows parameter-space (weight) noise is a viable, complementary exploration axis to action-space methods for RLVR, improving sample efficiency and reducing wasted/degenerate rollouts, and works as a drop-in replacement even on off-the-shelf checkpoints without prior variational training. Limitations noted by the authors: M3PO and C3PO run about 1.5x slower in wall-clock time than GRPO due to reduced parallelism from small prompt batches between vLLM weight syncs, experiments are limited by compute scale (only 7B models tested), and structured/non-diagonal posterior estimators or alternative sampling strategies remain unexplored.

Problem: Multimodal instruction tuning of pretrained LLMs into MLLMs causes substantial degradation of the original language capabilities (an average drop of approximately 39.8% across key language evaluations in the paper's motivating experiment).

Method: NeuPAT (Neuron-aware Plasticity Allocation Tuning) first runs a lightweight probing stage with small text-only and visual probing sets to compute per-neuron modality-associated importance scores (via activation-aware, output-weighted norms), then derives layer-wise modality preference and overall importance to classify neurons into four roles: language-associated, multimodal-adaptive, shared, and reserve. During multimodal instruction tuning, language-associated neurons are frozen, multimodal-adaptive and reserve neurons are fully updated, and shared neurons are updated under an input-side deviation penalty plus an output-side cosine-similarity constraint, added to the standard autoregressive loss. The framework requires no extra training data, architecture changes, or post-hoc model merging, and is architecture-agnostic.

Key results:

• On the default setup (RICE-ViT-Large-Patch14-560 + Qwen3-4B-Instruct-2507), Vanilla Tuning drops the 11-benchmark language average from 48.99 to 43.92; NeuPAT recovers it to 49.06 (+5.14 over Vanilla Tuning), slightly exceeding the original LLM, while improving the 5-benchmark multimodal average from 60.98 to 61.05 (+0.07).
• Abstract-level headline: NeuPAT recovers 94.5% of the language capability degradation caused by vanilla tuning across the 11 language benchmarks (a separate claim in the intro states 90.0% recovery across 4 language reasoning benchmarks) while maintaining comparable multimodal performance.
• Generalizes across 6 LLM backbones: language-average gains over Vanilla Tuning of +4.02 (Qwen3-0.6B), +8.75 (Phi-4-Mini-Instruct), +4.57 (Qwen2.5-7B-Instruct), +3.91 (Llama3.1-8B-Instruct), and +5.42 (Qwen2.5-14B-Instruct), with roughly comparable multimodal averages in each case.
• Ablations show NeuPAT's role-aware allocation (language avg 54.41, multimodal avg 72.73 on a representative subset) beats global update schemes (Freeze, Update, Reg.) and naive allocation baselines (Random, Fixed-ratio); layer-wise analysis finds shared neurons make up ~45% of neurons per layer, language-associated and multimodal-adaptive each ~20%, and reserve neurons ~15%.
• Outperforms baselines including LoRA, EWC, WINGS, TIES, L2M (Locate-then-Merge), and PlaM on overall language average (49.06 vs. next-best 46.27 for EWC), while WINGS achieves the single highest multimodal average (62.17) among compared methods.

Why it matters / caveats: NeuPAT offers a data-free, architecture-agnostic way to expand LLMs into MLLMs while largely preserving pretrained language intelligence, avoiding the extra data, architectural customization, or post-training merging required by prior mitigation strategies. The authors note its effectiveness on substantially larger backbones is unverified, experiments are limited to vision-language expansion (not audio/video/embodied/unified modalities), and the study considers only single-stage multimodal expansion rather than continual/sequential learning settings.

Problem: Vision-Language-Action (VLA) models restricted to a single wrist-mounted camera are fundamentally reactive, causing them to "forget" objects that leave the field of view (perception forgetting) and lose track of task progress during long-horizon, multi-step manipulation (task-progress forgetting).

Method: AtlasVLA adds a dual-memory architecture on top of an OpenVLA-7B-initialized LLaMA-2 7B backbone plus a ~300M-parameter CogACT-style Diffusion Transformer (DiT) action expert. A Persistent World State Memory uses a fine-tuned Depth Anything v3 for streaming depth estimation and spatial back-projection to lift 2D wrist tokens into a voxel-hashed 4D (3D space + time) global map, updated via confidence-weighted neighborhood fusion, a sliding temporal window, and a permanently anchored first frame; tokens are augmented with learnable spatial and temporal positional embeddings. An Ego-Working State Memory uses intent-aware learnable queries (Qego) to cross-attend over LLM tokens, producing compact ego-working latent states that are consolidated into a memory bank via redundancy-aware fusion to track task progress and prevent intention drift. At inference, ego-working retrieval and ego-guided world retrieval extract contexts Ctego and Ctworld, which condition a step-wise dual-attention DiT (ego-working attention followed by world state attention) via DDIM sampling (10 steps) with classifier-free guidance (scale 1.5) to generate 7-DoF end-effector action chunks (size 16).

Key results:

• LIBERO (wrist-only): 97.6% average success rate, outperforming wrist-only MemoryVLA (94.0%) and even multi-view baselines like OpenVLA-OFT (97.1%, 3rd+wrist) and π0 (94.2%, 3rd+wrist); on LIBERO-Long specifically, 94.6% vs. MemoryVLA's 87.6% (+7.0%), and the paper highlights a 9.4% absolute improvement on LIBERO-Long in the abstract/conclusion framing.
• RLBench (wrist-only, 6 tasks): 70.8% average success rate, beating wrist-only MemoryVLA (55.0%) by 15.8% and third-person MemoryVLA (63.3%) by 7.5%.
• Real-world general tasks (6 tasks, wrist-only): 78.7% average success, vs. wrist-only MemoryVLA 62.3% (+16.4%) and third-person MemoryVLA 70.7% (+8.0%).
• Real-world long-horizon tasks (4 tasks): 69.5% average success, vs. π0 52.0% (+17.5%) and MemoryVLA 60.5% (+9.0%).
• Ablations (real-world long-horizon): removing World State Memory drops performance from 69.5% to 54.0%; removing Ego-Working Memory drops it to 56.5% (13.0% drop); replacing the spatio-temporal voxel update with naive accumulation drops it to 58.0% (11.5% drop); removing spatial/temporal positional embeddings drops results by 2.0%/4.5% respectively; removing world state conditioning in the DiT drops it to 61.5% (8.0% drop).
• Training used 8 NVIDIA A100 GPUs with PyTorch FSDP, global batch size 256, learning rate 2×10⁻⁵, world state memory capacity of 2048 tokens, voxel resolution 0.025m, and 4 ego-working tokens.

Why it matters / caveats: The results show that explicit persistent 4D spatial memory plus explicit ego/task-progress memory can let a wrist-only camera setup match or exceed multi-view/third-person baselines, potentially reducing hardware requirements for real-world deployment. Caveats: evaluation benchmarks (LIBERO, RLBench, real-world tasks) are relatively small-scale (20-50 trials per task) and from a single robot platform (Franka), and the added 4D world-state and ego-memory machinery increases architectural and computational complexity relative to purely reactive VLAs.

Problem: Simulating societies of many large language model (LLM) agents to study macroscopic phenomena (phase behavior, stylized facts, scaling with agent count N) is prohibitively expensive, since a single thousand-agent run can cost tens of dollars and tens of hours in API calls.

Method: The paper replaces each expensive LLM agent with a low-parameter surrogate (2–12 parameters, e.g. a twelve-parameter student with two logistic heads for work/consumption decisions) fitted via behavioral cloning on a few hundred to a few thousand cached LLM decisions (primarily DeepSeek's deepseek-chat) elicited on the target simulation's own prompts. An "[interaction order × memory] taxonomy" classifies a simulation's perception design (global/mean-field, community, or local/graph feed) and memory (Markovian vs. long-memory) into cells, each predicting whether the scalar surrogate's error vanishes as N^-1/2, plateaus at an O(1) floor, or grows with N; this prediction is made before any fitting and is validated blind against pre-registered, held-out tests. The recipe (Algorithm 1) is: classify the perception cell, screen the target observable for whether it's a mere accounting identity, elicit LLM decisions, clone the surrogate, read off error floor/knee from the fitted response, then sweep N on a laptop.

Key results:

• Total DeepSeek API spend across the entire study was "a few dollars" (e.g., $0.44 and $0.67 for three and six thousand decisions respectively).
• On EconAgent, the cloned Phillips correlation came out at −0.569 ± 0.138 (out-of-sample), within |Δ|=0.05 of the published −0.619, while Okun's law (published −0.918) was shown to be an accounting identity already reproduced by a behavior-free Bernoulli(0.5) policy (correlation −0.998, R²=0.996 for GDP as an affine function of working agents).
• A 2×2 reasoning/wording ablation showed reasoning (chain-of-thought), not prompt wording, drives the Phillips curve: no-reasoning gave −0.43 (plain) / +0.04 (amplified) vs. reasoning gave −0.73 (plain) / −0.66 (amplified).
• Mean-field cell scaling was confirmed: cloned Phillips correlation strengthened monotonically from −0.29 to −0.86 as N grew from 20 to 500 (also −0.34 to −0.61 from real LLM decisions).
• Blind, pre-registered tests on a real DeepSeek response function: the near-linear consumption head confirmed 5/5 predictions (N ≈ 2.5×10^4, error still improving); the saturating work head refuted 2/5, with private-feed error flat at a floor of 0.018, matched exactly by the predicted Jensen bias (knee N ≈ 29).
• Cross-model test on 13 elicitation traces across 5 labs (DeepSeek, OpenAI, Anthropic, Google, Meta): predictions held for 12/13 models; only gpt-4o-mini (smallest model) failed to clear the factor-of-two closure criterion by N=3200.
• Reproduced De Marzo et al.'s consensus game finding: critical group size Nc is a perception threshold (majority-force β crossing 1), not a thermodynamic effect; reasoning models (Opus-4.8, GLM-5.2, DeepSeek) show flat βeff (Nc=∞), while GPT-4o, Llama-3.3-70B, GPT-4-Turbo show decaying βeff giving finite Nc (~900–1600).
• Minority Game finite-size-scaling data collapse recovered the critical control parameter to within 13% error, establishing ~15% as the toolkit's resolution floor.
• Measured a Mori-Zwanzig memory kernel from DeepSeek attitude updates: current-interaction weight K(0)=0.27 (below independently fitted μ=0.415, showing "conviction braking"), with a past-interaction tail at 47% of K(0), confirming non-Markovian but truncatable memory.
• Validated across 8 named LLM simulations (EconAgent, AgentTorch, OASIS, AgentSociety, De Marzo et al.'s consensus game, Williams et al.'s generative epidemic, LLMTraveler, Generative Agents/Smallville) plus TwinMarket as a boundary case and a differentiable agent-based model cross-check.

Why it matters / caveats: The approach turns the cheap surrogate into a measurement instrument (e.g., isolating that "reasoning" rather than prompt phrasing produces EconAgent's Phillips curve), letting researchers identify which microscopic behavior drives a macroscopic law at near-zero cost. Caveats stated by the authors: the commutation-defect decomposition is an organizing heuristic, not a proven theorem; reproductions largely match mechanism/functional form on new models rather than hitting a target's own model's exact published number; the EconAgent market is a code-calibrated reimplementation, not the original codebase; and results largely rest on one primary LLM (DeepSeek), with sibling models sometimes giving substantially different macroscopic values.