Wednesday, August 26, 2026

Human-in-the-loop oversight is the standard prescription for managing AI agent risk, but this position paper from Hugging Face and Data & Society argues that current agent design both impedes effective oversight and actively erodes the cognitive capacities it depends on. The proposed remedy is "cognitive scaffolding": treating overseers' attention, situational awareness, and domain skill as first-class design constraints, on par with agent capability.

• Agents produce dense, fast-moving streams of chain-of-thought, tool calls, plans, and inter-module exchanges that exceed what a reviewer can track, pushing users into repeated approval prompts and approval fatigue, while vendor oversight frameworks from Anthropic, Salesforce, and AWS specify human roles without accounting for how attention behaves under sustained engagement.
• Drawing on Bainbridge's 1983 "irony of automation", the authors compile evidence that extended AI use causes deskilling, reduced vigilance, and automation and anchoring bias, citing an EEG study showing significantly decreased brain connectivity in LLM-assisted essay writers and a multicentre study of endoscopist deskilling after AI-assisted colonoscopy, with the sharpest effects on novices and experts working slightly outside their expertise.
• Degraded oversight creates an alignment feedback loop: tired overseers approve fluent rationales quickly, those approvals become RLHF and evaluation signal, and systems can drift toward confident summaries and skimmable plans that further disincentivize scrutiny, making the human rater an exploitable part of the reward channel.
• The solution inventory splits into developer-side affordances (pre-commitment before seeing agent output, delay-and-choice, reasoning probes, action gating, bounded autonomy, batch diff review, and behavioral monitoring via review-time, override-rate, and evidence-seeking signatures plus known-answer canaries) and deployer-side protocols (unassisted skill-maintenance exercises, critical-evaluation training, enforced breaks, rotations, and separating the overseer from whoever benefits from approvals).
• As a position paper it presents no new experiments, the inventory is explicitly non-exhaustive with overlapping categories, and the authors concede early evidence that users disprefer systems that reduce overreliance, leaving a real tension between satisfaction and oversight quality.

arXiv:2608.23642 PDF

Multi-agent systems built for scientific discovery usually run agents as fixed tools inside a scripted pipeline with a central coordinator; the Station instead drops a handful of heterogeneous LLM agents into an open-world environment with only a research goal, letting them pick directions, run experiments, message each other, and publish into a shared internal literature that later agents read and cite. Applied to 12 construction problems from the AlphaEvolve catalogue plus two case studies, this produced results novel relative to prior literature on five problems, along with theorems and explicit algebraic constructions explaining why the numerical results work.

• Each Station instance runs six agents (two each of GPT-5.5, Claude Opus 4.8, and Gemini 3.1 Pro) for roughly 1,000–2,000 ticks (one to two weeks), with rooms for code execution, private mail, public forums, a Stack-Exchange-style Question Room, and an Archive Room where papers that pass automated review accumulate across agent generations; agents have limited lifetimes and are automatically replaced, and they get coding assistants and periodic "holidays" with open-ended prompts.
• Headline novel results: a new infinite family of finite-field Kakeya sets in F_p^3 for p ≡ 3 (mod 4) of size (2p³+7p²+3)/8 (saving (p−3)/4 points over AlphaEvolve's family) plus a 53-point Kakeya set in F_3^5 beating the prior 63; three exact 604-point kissing configurations in dimension 11 (two apparently new isometry classes, versus AlphaEvolve's 593); a discretized Kakeya needle area of 0.107067 at n=128 (6.74% below AlphaEvolve); a sign-uncertainty upper bound of 0.3089 (from 0.321591); and a new lower bound of 0.380552 for Erdős's minimum-overlap constant that closes ~82% of the published gap, even though the task asked for an upper bound.
• Agents repeatedly went beyond the score: they proved the classical D_11 norm-four construction caps at 582 points before pivoting to a new core, proved the double-root Laguerre family can't beat 0.315305 and then left it, proved exact optima C_T(3)=5/18 and C_T(4)=1/4 for the needle problem, showed the non-tangential Hardy–Littlewood constant equals 2 for 1/3 ≤ α < 1, and in the prime-number-theorem task produced a certified-for-all-x score of 0.980681 while rejecting higher but hackable sampled scores.
• The two extra case studies yielded two proved novel infinite families for Book Ramsey numbers (resolving 28 previously open cases among n ≤ 200 together with an expert-derived third family) and an independent, web-free reconstruction of the degree-seven Jacobian Conjecture counterexample within a day; more than half of the findings involved cross-model collaboration or building on earlier agents' internal papers, and all raw dialogues, proofs, and verification code are released.
• Limitations are real: the Station underperformed AlphaEvolve on peak and flat autoconvolution, which reward large-scale heuristic optimization of irregular objects rather than theory-guided search; it found no competitive uniform-in-n needle construction, its Kakeya formulas in dimensions 4 and 5 are weaker than known results, and adjacent kissing runs stopped at 840 in d=12 (one below the frontier) and merely matched 1154 in d=13, so the approach favors problems where structure can guide the search and interpretable outputs are valued.

arXiv:2608.23691 PDF

Masked diffusion LLMs promise faster generation than autoregressive models by denoising many tokens per forward pass, but nobody had measured how they behave under real concurrent serving load before building schedulers for them. This paper characterizes LLaDA-8B-Instruct with a D2F LoRA adapter on a single H200, and finds that dLLM serving is bottlenecked by CPU-side dispatch rather than GPU compute, so parallelism has to live at the level of each denoising step instead of each request.

• Request difficulty is discrete, not continuous: across 100 GSM8K requests, denoising-step counts land on exactly 11 fixed levels (178 + 29k), a direct consequence of D2F's block-addition checkpoint rule, and step count predicts end-to-end latency almost perfectly (r = 0.9997), yet none of four cheap early signals (confidence fraction, mean confidence, entropy, prompt length) can predict the level at admission time (best R² = 0.150, far below the authors' 0.5 usefulness floor).
• Profiling a single request shows only 24.4% of the 10.28 s wall-clock is GPU kernel time; the other 75.6% is host-side overhead in the per-block control loop (mask construction, threshold checks, synchronization), which runs once per step regardless of batch size, so batching helps mainly by amortizing that fixed cost rather than by improving GPU utilization.
• Sharing one forward pass per denoising step across a synchronized batch scales throughput near-linearly, reaching 1.939 req/s at batch size 16, a 16.0× gain over per-request dispatch (0.121 req/s), while capturing the forward call with CUDA Graphs cuts its dispatch time by 48.6% but would only remove about 28.5% of total dispatch overhead, since the rest lives in Python control flow outside the forward call.
• Short generation budgets hide serving variance: at 128 tokens every GSM8K request is truncated and CV is 0.067, but at the ~320-token natural completion length (512-token budget) CV rises to 0.283 with 76% accuracy, and HumanEval is a harder serving workload still (CV 0.343–0.346, max-to-min latency ratio ~4×); block size {16–128} barely affects latency (within-request CV under 0.01), a ~36× smaller spread than across requests on both tasks.
• Limitations are substantial: the batch-timeout stability rule T_min = S − 1/λ and the latency-optimal utilization of ρ ≈ 0.70 come from a Monte Carlo over only n = 8 measured batch service times (a later 32-batch run shifted estimated capacity by 24%), quality under batching is argued structurally but not measured beyond single-request 74–76% accuracy, the tier constants are tied to one threshold setting, and the per-request-dispatch baseline is weaker than a slot-based or vLLM-style shared-pass design, which the authors leave as future work.

arXiv:2608.23807 PDF

Universal multimodal embedding models still lag on fine-grained relevance once broad cross-modal alignment is in place, and most open-source options trade off scale against generality. WeMM-Embedding is a family of 2B/4B/9B models built on Qwen3.5 backbones that first trains on several hundred million heterogeneous pairs, then refines on a curated corpus roughly one tenth the size using hard negatives, reranker-derived rankings, and cross-scale distillation from the 9B teacher.

• Every task is cast as a source–target pair with an optional instruction, hard-negative set, and graded relevance score; inputs are encoded with a trailing <embedding> token under causal attention (allowing multiple embedding tokens per sequence, e.g. video-only and video-plus-ASR from one pass), with Matryoshka training over nested dimensions and a duplicate-aware mask that drops near-identical in-batch negatives.
• Stage 2 draws on Semantic-ID-guided resampling (a three-level residual k-means quantizer over intermediate-checkpoint embeddings) to downweight overrepresented semantics, MLLM-based quality filtering and caption correction, and a bidirectional KL distillation of batch-wise teacher similarity distributions, which the authors say contributes most to the compact variants' gains.
• On MMEB-v2 (78 datasets) the 2B model scores 77.9, edging past Qwen3-VL-Embedding-8B (77.8), while the 9B reaches 80.6, first on the leaderboard ahead of proprietary entries such as Octen-VL-Large (80.1) and DME-Large (80.2); on MMEB-v3 the 9B scores 59.5 V3-All, and on a 12-benchmark cross-modal retrieval suite the 2B averages 79.8 versus 79.5 for Gemini Embedding 2.
• Ablations show task-consistent batching is the single biggest Stage-1 factor (−3.4 points when replaced with mixed sampling), Stage-2 strategies cumulatively add 2.2 points for the 2B model, and 256-dimensional embeddings retain 98.7% of 2048-dimensional performance on image and video tasks, with visual-document and retrieval tasks degrading fastest under truncation.
• The models do not accept audio (scored as zero on the 11 MMEB-v3 audio tasks), reranker supervision only helped on a limited subset of tasks so was applied selectively, the 9B relies on merging multiple Stage-2 variants rather than a teacher, and the 26-task in-house benchmark and 14 A/B tests are reported only against Qwen3-VL-Embedding-2B with no released details.

arXiv:2608.24053 PDF

Sampled-token on-policy distillation (OPD) gives dense token-level guidance but has an implicit reward whose sign depends only on the teacher-student probability ratio, so it can penalize tokens in correct trajectories and reward tokens in incorrect ones. OPDVR fixes this with a single ReLU gate: on correct trajectories the reward is max(0, log(π_T/π_θ)), on incorrect ones it is -max(0, log(π_θ/π_T)), which turns OPD into a proper verifiable-reward RL method with no added hyperparameters.

• The gate acts as a conditional mask that zeroes exactly the "conflicting" tokens (student more confident than teacher on a correct trajectory, teacher more confident on an incorrect one); the verifier sets the update direction while the teacher's log-ratio still sets the magnitude, and Appendix A shows this removes precisely the component of the OPD gradient that is anti-aligned with the RLVR gradient.
• Because the reformulation exposes a verifier reward, the sign of a GRPO group-relative advantage can replace the binary correctness label, yielding GRPD (Group Relative Policy Distillation) that plugs into GRPO/DAPO/PPO-style pipelines unchanged.
• In same-architecture distillation (Qwen3-4B student from a GRPO-trained Qwen3-4B teacher on DeepMath), OPDVR reaches 49.1 average avg@16 across six benchmarks versus 47.8 for sampled-token OPD, and 36.9 on AIME24, above the teacher's 36.0; cross-architecture (Qwen3-1.7B-Base from Qwen3-4B-Base-RL on DAPO-Math-17k) it scores 22.8 vs 20.9, with a +5.5 point gain on AMC.
• GRPD beats both GRPO (44.8) and OPD (48.4) with 49.4 average, including +6.5 on AIME24 and +10.9 on AIME25 over GRPO, while an inverse-gated ablation falls below vanilla OPD on all six benchmarks (44.6 avg), and the gate consistently masks roughly 40-50% of tokens throughout training.
• Limitations: evaluation covers only math reasoning with Qwen3 models and a single teacher per setting, the same-architecture MATH500 result slightly trails OPD (84.7 vs 85.5), and the gains, while consistent, are modest at 1-2 average points with no reported variance across seeds.

arXiv:2608.24696 PDF

Self-improving LLM agents that edit their own code must freeze some driver component to stay stable, capping realized meta-depth at roughly two. Meta^n inverts this: a single fixed meta-operation Ω is applied recursively to its own outputs, reading the solver stack's execution traces plus the code that produced them and emitting a new layer (a strategic pre-process plus a library of callable helpers), so depth is set by convergence rather than fixed in advance.

• Each depth-d layer wraps the solver below it; Ω sees the previous depth's traces and the full code stack [C_2, …, C_{d-1}], which lets it attribute regressions to specific prior directives and roll them back (for example, on LawBench a depth-3 "Exhaustive Legal Analysis" directive dropped the score from 0.807 to 0.773 and depth 4 restored it to 0.833 while keeping the useful helper), and an evolutionary archive searches over layer chains with per-task best selection.
• Across eight benchmark families and two backbones (Gemma 4 31B-IT, GPT-5.2), the agentic variant leads OpenEvolve and Gödel Agent on every family on at least one estimator; on CO-Bench under GPT-5.2 archive-best reaches 0.870 vs. 0.702 for OpenEvolve, and on ARC-AGI-2 it is the only system above zero (dev 0.331 vs. 0.003 and 0.054), while prompt-rewrite benchmarks like Symptom2Disease show only a few points of lead within seed noise.
• Removing recursion (a depth-1 baseline with orchestration unchanged) costs −0.131 on Gemma CO-Bench, −0.080 on GPT-5.2 CO-Bench, and −0.158 on GPT-5.2 AlphaEvolve Math; ablating further shows that the plain inter-layer context string accounts for ~72% of the recursion gain, the code-library channel ~15%, and the search machinery ~13%.
• Distinct layer roles emerge without any prompt prescribing them: depth 2 emits generic primitives (simulated_annealing propagates to 15 of 36 CO-Bench winners), depth 3 specializes and interferes (41% of chain-task pairs regress), and rollback appears only from depth 3 onward, with depth-≥4 candidates still winning 31% of CO-Bench tasks even though mean per-depth score peaks at depth 3.
• Limitations include using the same model at every layer (leaving the stronger-Ω-over-weaker-base case untested), 4–10× higher token cost in agentic mode, the Gödel Agent baseline needing a corrected per-task configuration to score at all, and two benchmarks where the method adds little: AlgoTune, where extra context over-constrains an already-optimized kernel, and SWE-Bench, where Ω never activates because the seed is already strong.

arXiv:2608.24735 PDF

Outcome-supervised search agents learn when and how to retrieve from a terminal reward alone, which can neither localize where a long trajectory went wrong nor redirect it before an early error compounds. CAFE (Coupled Agent–Feedback Evolution) makes corrective feedback a learned, in-trajectory intervention: one shared-parameter model alternates between a search-agent role that learns when to emit a <request_feedback> action and a critic role that learns to answer it, with the two capabilities updated in alternation so the critic keeps tracking the agent's shifting failure distribution.

• Training is bootstrapped from the base agent's own failed rollouts: a teacher (Kimi-K2.5) marks the earliest erroneous turn, the flawed prefix is kept, a feedback request plus teacher-written correction and continuation is inserted, and only repaired trajectories that reach the correct answer are used for SFT, so the model learns to request and use feedback at states its own policy actually visits.
• Online, GRPO is augmented with a comparative feedback estimate (CFE) that adds the prompt-level success gap between feedback-requesting and feedback-skipping rollouts to the return of requesting rollouts (with a penalty for repeat requests), while feedback-aware advantage shaping subtracts from pre-request tokens and adds to post-feedback tokens so a rescued success credits the recovery rather than the prefix that went off course.
• Offline, rollout-derived preference optimization (RDPO) mines prefix-matched pairs of successful and failed feedback-requesting rollouts for the same prompt and DPO-trains the shared checkpoint to prefer the successful feedback, alternating with online RL in five rounds of 100 RL steps each; RDPO beats a positive-only SFT variant on the same mined data.
• On Qwen2.5-7B-Instruct across seven SearchQA benchmarks, CAFE averages 52.5 EM / 60.7 F1, 2.1 EM and 1.3 F1 above the strongest RL baseline IGPO, improves over plain GRPO on every benchmark including all six out-of-domain sets (gains concentrate on multi-hop: 7.4 EM over Search-R1 versus 1.3 EM on single-hop), and lowers the answer-level hallucination rate from 29.9% for the base model and 17.6% after GRPO to 12.6%; on 2Wiki, agent-only optimization with a frozen critic plateaus at 83.6 (mean of EM and F1) while alternating updates reach 86.6, and cross-play shows each agent performs best with the critic from its own iteration rather than the strongest critic overall.
• Caveats: training uses 2Wiki as the sole in-domain set with 7B and 3B backbones only, the bootstrap depends on a strong external teacher, CFE on its own adds only about 1 EM (most of the online gain comes from advantage shaping), Gemini-2.5-Flash still edges CAFE on average F1 (60.9 versus 60.7), and the harder BrowseComp-Plus result is reported only in the appendix without numbers in the main text.

arXiv:2608.24794 PDF

Norm control in LLM pretraining — weight decay, explicit norm constraints like Hyperball — reshapes loss curves, raising the question of whether it is an independent knob or just another way to set the learning rate. The paper argues the latter: learning rate and parameter norm affect loss almost entirely through their ratio, the effective learning rate ELR = η_k / ‖W_k‖_F, so runs with very different LR and norm schedules produce nearly identical loss trajectories whenever their ELR schedules match.

• The core experiment prescribes a common warmup–stable–decay ELR schedule and realizes it with four different LR shapes (WSD, linear-up, linear-down, sinusoidal) by enforcing a compensating parameter-norm schedule at every step; on Llama-124M and Qwen3-MoE-586M trained with AdamW, the loss curves collapse with mean discrepancies of 1.8–4.1 × 10⁻³, well below the 1.1–1.6 × 10⁻² variation seen from merely changing the initialization or data-order seed.
• Across 26 matched comparisons spanning dense, MoE, and Kimi Delta Attention models from 100M to 1B parameters, FineWeb/C4/OpenWebText, and AdamW/Muon/Signum, the median collapse error is 2.5 × 10⁻³ and every case stays under 5 × 10⁻³, with similar precision for ViTs on ImageNet.
• Collapse is precise but conditional: removing QK-Norm raises the error from 2.3 to 5.2 × 10⁻³, additionally fixing the RMSNorm gains pushes it to 1.84 × 10⁻² (counterintuitively, since fixed gains make the network more scale-invariant), and rapidly oscillating LR–norm realizations of the same ELR degrade it from 2.8 to 7.5 × 10⁻³, so the phenomenon cannot be explained by static scale symmetry and its mechanism remains open.
• Practical norm control works the same way: adapting only the LR of a no-weight-decay run to match the ELR of a λ=0.1 AdamW run recovers its loss to 4.8 × 10⁻³, and matching a weight-decayed Muon run to a Hyperball-constrained one gives 1.2 × 10⁻³ after a brief onset transient; swapping LR for ELR in the functional scaling law of Li et al. also lets a fit on non-Hyperball runs transfer to unseen Hyperball runs (RMSE 0.021 vs 0.251, roughly 12× lower).
• The ELR view explains "delayed acceleration" — weight decay initially loses to the unregularized baseline but wins late because it prevents norm growth from prematurely shrinking the ELR — and a hand-designed norm schedule that grows the norm faster late in training beats the weight-decay baseline; the authors caution that matched loss trajectories do not imply matched parameters, representations, or downstream performance.

arXiv:2608.24814 PDF

Open video data at pre-training scale is scarce compared to image-text corpora, so LAION-BVD mines CommonCrawl for platform-specific video URLs and turns the downloaded videos into clip-level video, audio, and image training data with synthetic captions.

• The pipeline collects 1.3B video URLs from CommonCrawl, downloads 80M videos totaling 10 million hours, then uses content-aware scene detection to cut them into clips, each paired with synthetically generated video and audio captions.
• Models trained on the clip-caption pairs reach competitive results on standard video-text and audio-text benchmarks, with performance improving consistently as training data or model size scales.
• As a side product, scene-changing frames extracted from the videos serve as an image-text source with a visual distribution distinct from typical web image datasets, and models trained on them achieve strong image-text retrieval performance.
• The dataset is fully released, expanding open access to multimodal video at a scale not previously available to the research community.
• The abstract reports no concrete benchmark scores or baseline comparisons, all captions are synthetic rather than human-written, and the reliance on platform-specific URLs raises the usual questions about link rot, licensing, and content filtering.

arXiv:2608.24845 PDF

Long-horizon LLM agents accumulate experience but lose track of unresolved goals as interaction histories grow, so stored skills get invoked against a stale or noisy picture of the task. Recuris couples a compact, verified Working Memory that tracks goal status with an Experiential Memory of reusable skills, using the current state rather than the full history to decide when a skill is needed, and turning the resulting structured traces into component-level repairs of the memory layer across tasks.

• Within a task, skill retrieval fires at execution events (e.g. a drafted state-changing tool call is intercepted, the matching skill is injected, and the call is redrafted), while a checker set commits a goal as done only when the tool receipt supports it, so verbal confirmation never counts as completion.
• Across tasks, a fixed Claude Code-based Meta-Agent reads the structured trace, attributes each failure to one of four memory components (skills, working-memory spec, invocation policy, checkers), patches only those, and admits the candidate only if it fixes the source task without regressing a held-out dev set; the base LLM is never touched.
• On τ²-Retail, a memory evolved once on mid-sized doubao-seed-2-0-pro lifts GPT-5.6 Sol by +17.8 (58.3→76.1) and Claude Opus 5 by +15.6 to 87.9%, and on SkillFlow lifts Qwen3.6-27B from 42.2 to 58.7; gains land in 35 of 37 model–benchmark pairs and widen with task length, reaching +32.2 on the longest quartile.
• Ablations show the working state carries the effect (WM-only +23.9 vs EM-only +2.0 on Retail), and injecting the whole skill library and letting the model choose scores 18 points below state-grounded invocation while costing 46% more per success; structured traces also raise fault-localization accuracy from 13.0% to 64.8%.
• Limitations: τ²-Airline (50 tasks) intervals all include zero, Terminal-Bench 2.1 has no shared structure so cross-task evolution admitted no patch in 13 runs, evolution is non-monotone (one lineage gave back most of its gain in round four), and the per-benchmark memory is hand-built once on a single deployment model.

arXiv:2608.24876 PDF