AI Paper Digest

Friday, November 6, 2026

447 papers cs.AI · cs.LG · cs.CL ← 2026-11-05

Aug Sep Oct Nov

Highlights

The Harness Is the Model: Agent Scaffolding Changes a Fixed LLM's Compliance with Banking Conduct Rules, Unevenly Across Models

Highlight Agents Mehmet Murat Huyut Banks validate language models in isolation but deploy them inside harnesses that control what the model sees, which tools it calls, and who checks its actions. The authors run four open-weight models in five harnesses, ranging from a single structured decision to tool loops with policy search, long customer memory, or a same-model compliance reviewer, across 156 pre-registered cases in a simulated retail bank governed by paraphrased EU rules, scoring all 3,120 episodes deterministically from tool traces. Pooled results moved little (87.3% to 92.1% correct), but for one model the harness alone shifted results by 11.5 percentage points, moving it from first to last place, while the same-model reviewer cut violations from 9.6% to 6.4% without more over-refusals. Rules requiring date arithmetic failed everywhere, and 26% of violations came with a customer message denying the action the agent had just executed, so the authors argue validation should target the model-harness pair and read action logs rather than transcripts.

Banks validate language models, but what they actually deploy is a model wrapped in a harness, the code that controls what the model sees, which tools it can call and who checks its actions. The study holds the model fixed and varies only the harness, then measures compliance with banking conduct rules modelled on EU consumer-credit, payments, investor-protection, data-protection and anti-money-laundering law, scoring each episode from the tools the agent actually executed.

  • Four open-weight models (deepseek-v4-flash, deepseek-v4.1-flash, qwen3.8-flash-next, gemma-4-31b) each ran five harnesses on 156 pre-registered cases in a simulated bank, for 3,120 two-turn episodes: a single structured-decision pipeline, a ReAct tool loop, a loop where the policy is reachable only through search, a loop with a long benign customer memory, and a loop with a same-model compliance reviewer.
  • Pooled across models, the harnesses differ little (87.3% to 92.1% of cases handled correctly), but within one model the gap is large: qwen3.8-flash-next swings 11.5 points (Cochran's Q = 25.1, p < 0.001) and goes from most to least compliant model, while deepseek-v4.1-flash shows no harness effect, although the formal model × harness interaction test is only suggestive (p = 0.07).
  • The same-model reviewer cut violations from 9.6% to 6.4% (p < 0.001) without increasing over-refusals (1.6% vs. 1.4%), contrary to the authors' pre-registered prediction, at a cost of about 1.8× the input tokens.
  • Rules that require date arithmetic, such as the 14-day credit withdrawal window and the 13-month limit on unauthorised-payment claims, failed in every harness, with withdrawal cases only 67–71% correct, and the reviewer did not help on the withdrawal window, presumably because it makes the same date error as the agent.
  • In an exploratory analysis using two LLM judges plus a blind human check, 26% of violations (41% in the pipeline harness) came with a customer message denying the action the agent had just executed, so a transcript-only review would miss them; the caveats are a synthetic bank, moderate-size models with reasoning turned off, and a scripted follow-up turn that may invite these denials.

arXiv:2611.06116 PDF

Loop Before You Leap: What Recurrent Depth Can and Cannot Buy in Data-Limited Pretraining

Highlight Large Language Models Daichi Hotta, Yohei Kobashi, Takeshi Kojima, Yusuke Iwasawa, Yutaka Matsuo In the BabyLM Challenge, multimodal models trained on a small data budget have often scored below text-only models, and the authors test whether looped Transformers, which reuse layers for extra computation without more parameters, close that gap under a 100-million-word budget. In a pre-registered text-only comparison, a 12-layer stack repeated four times beats a standard 48-layer Transformer by 5.4 BLiMP points at matched inference compute. Adding images, represented as a single frozen DINOv2 feature vector, lowers BLiMP accuracy by about 3.8 points in both architectures, and recurrence does not mitigate it. Control experiments suggest the drop comes mainly from changes in the language data and how it is presented rather than from the images themselves.

Multimodal models in the BabyLM Challenge often score below text-only baselines on grammar benchmarks, and the paper tests whether looped Transformers can close that gap. Looping reuses the same layers several times, so it adds sequential computation without adding parameters or training data. The answer splits in two: looping clearly beats making a standard model deeper, but it does not shrink the multimodal penalty, and most of that penalty appears to come from changes in the language data.

  • Setup: A 12-layer LLaMA-style decoder is run 4 times with shared weights, and the text embeddings are added back in after every pass; it is compared against standard models with 12 layers (same ~97M parameters), 24 layers, and 48 layers (same inference compute), all trained on a 100M-word budget with three seeds each, where each image enters as a single frozen DINOv2 feature vector placed before the caption and caption words count toward the word budget.
  • Looping vs. adding depth: In a comparison registered before the results were seen, the looped model beats the compute-matched 48-layer model by 5.4 BLiMP points in text-only training (76.16 vs. 70.80) and by 3.7 points in multimodal training, and standard models score lower on BLiMP the deeper they get even though their training loss keeps falling; against the parameter-matched 12-layer model the gain is only ~0.95 points, which is not significant (p≈0.12).
  • No help with the multimodal drop: Multimodal training lowers BLiMP by ~3.8 points in both the standard and looped models, and the difference between those two drops is −0.01 points (95% CI [−1.44, 1.41]); changing the connector or re-injecting the image vector across loops does not show a clear benefit either.
  • Where the drop comes from: A looped-model control trained on the same multimodal language data and batches but with no images scores 5.71 points below the text-only model, and adding the image vector back recovers only 1.85 points on average, with a wide CI of [−1.67, 5.37]; this points mainly to the change in text composition (for example, CHILDES child-directed speech rises from 28.4% to 56.8% of the retained text) and to the different batching, even though shuffling the image features raises caption loss by ~1.5 nats per token, so the models do use the visual input.
  • Limitations: Only three seeds were run per condition; the matched no-image control exists only for the looped model, so the components cannot be compared across architectures; recurrence is confounded with text re-injection; and a single global image vector may be too coarse to show what visual grounding could do for grammar.

arXiv:2611.06206 PDF

Mass Producing Training Data with Surprising Side Effects

Highlight Safety & Alignment Yaowen Ye, Jacob Steinhardt, Sarah Schwettmann, Cassidy Laidlaw Training data can change language-model behavior far outside its domain, as when insecure code induces broad misalignment, but only a few dozen hand-found examples of such datasets exist. The authors automatically generate datasets with surprising side effects (DSSEs) that elicit a target behavior, read like ordinary post-training data, and would surprise a human auditor, scoring each property with LLM judges and searching via evolution, reinforcement learning, and subliminal learning. The pipeline yields 6,575 such datasets across 8 behaviors, many of which generalize across model families and sizes. The automated metrics track ML researchers' judgments, and frontier models predict side effects better than humans, giving a testbed for anticipating training side effects before deployment.

Fine-tuning data can change a language model's behavior far outside the training domain. Insecure code data can make a model broadly misaligned, and outdated bird names can give it a 19th-century persona. So far only a few dozen such cases exist, each built by hand or found by accident. The authors propose generating these datasets with surprising side effects (DSSEs) automatically and at scale, so generalization can be studied systematically.

  • A DSSE is scored on three objectives, each judged by an LLM: it should elicit a target behavior, read like ordinary post-training data, and surprise a human auditor who reads it.
  • High-scoring datasets are found with three search methods (evolutionary search, reinforcement learning and subliminal-learning-style generation), then re-scored and filtered with held-out metrics.
  • The pipeline produces 6,575 DSSEs across 8 target behaviors, and many of them carry their side effects across different model families and sizes.
  • The automated metrics agree with ML researchers' judgments, and frontier models predict side effects better than humans, which suggests side effects could be screened for before training.
  • The collection is meant as a testbed for generalization research, but it is limited to 8 behaviors and relies heavily on LLM judges, so how widely the findings apply is still open.

arXiv:2611.06324 PDF

A Night at the LLM Zoo: Data Conditioned Flow Matching for Generating Pretrained LLM Weights

Highlight Large Language Models Scott Biggs, Bedionita Soro, Saumya Gupta, Bruno Andreis, Sung Ju Hwang Weight-space learning, which treats trained model weights as data, lacks a well-curated population of language models to study. The authors train a model zoo of GPT-2 models at 51M, 124M, and 355M parameters, 100 per size, systematically varying the training mixture of web text, books, math, code, and French, and show that variation across the zoo is structured by mixture composition. They then train a mixture-conditioned flow-matching model over compressed weights that generates complete pretrained LLM weights for held-out data mixtures whose perplexity and benchmark scores are close to those of the trained models. All code and artifacts are released.

Weight-space learning has mostly stayed with small vision models and LoRA adapters, partly because no controlled population of full pretrained LLMs existed to study. The authors build one: 300 GPT-2 models whose only difference is the mix of pretraining data. They then train a flow-matching generator that takes a data mixture as input and outputs complete model weights, including for mixtures it never saw.

  • Zoo design: Each tier has 100 models, at 51M, 124M and 355M parameters. Every model starts from a shared trunk and branches off for the final 15% of training on its own blend of web text, books, math, code and French. The 85 distinct mixtures per tier are 20 "anchors" (the five single-domain mixtures, each trained four times with different seeds) plus 80 random mixtures in between.
  • Weights track the data mix: After removing the drift every model inherits from the shared trunk, models trained on the same mixture have cosine similarity 0.80–0.89, while models trained on different single-domain mixtures are near-orthogonal. Among the 20 anchors, mixture identity explains η² = 0.87–0.94 of the variance in the weights. Models trained on different mixtures also disagree on the next token about twice as often as same-mixture replicates.
  • Generator: A rectified flow with an MLP velocity network and a learned mixture embedding generates 50-dimensional Gram-PCA codes, using classifier-free guidance. The codes are decoded into full GPT-2 weights, which are evaluated with no further training. Five Euler integration steps already come close to the 50-step results.
  • Results on held-out mixtures: Generated models change perplexity by 4.05–5.11%, compared with 5.75–6.01% for a nearest-neighbour retrieval baseline that is blinded to the same neighbourhood. For reference, seed noise alone gives about 1% and the rank-50 compression alone gives 1.8–2.5%. Conditioning on the mixture yields a CRPS skill of about 0.6 over a mixture-blind baseline, and the flow's likelihood picks out the correct mixture among all 85 candidates for 94–97% of held-out models. On HellaSwag, generated models score on par with the real ones.
  • Limitations:
  • Generation fails at the single-domain mixtures, with median CRPS skill below 0.15.
  • Generated models respond only 42–54% as strongly as real models to changes in domain weight.
  • The lead over retrieval shrinks at 355M, where the flow wins only 43 of 85 mixtures.
  • The PCA basis is fitted on all models, including the held-out ones.
  • At these scales, HellaSwag accuracy sits within a few points of chance.

arXiv:2611.07103 PDF

Test-Time Self-Play: Scaling without a Verifier

Highlight Reasoning Akira Yoshiyama, Akmal Ashirmatov, Jonas H\"ubotter, Ido Hakimi, Andreas Krause Most test-time scaling methods, which spend extra compute at deployment to solve hard problems, depend on a verifier that scores candidate solutions, and a strong verifier is often unavailable. Test-Time Self-Play (TTSP) instead scales test-time compute through asymmetric self-play. On a difficulty-calibrated subset of LiveCodeBench v6, it is the best method at every verifier strength tested, and its lead grows as the verifier weakens. With no verifier at all, it delivers a 35% absolute improvement in mean@8. The gains disappear only when the base model almost never produces the correct answer.

Language models often have the knowledge to solve a hard problem but rarely produce the correct answer, and most test-time scaling methods need a reliable verifier to pick or refine candidates. Test-Time Self-Play (TTSP) removes that dependency: a proposer generates synthetic practice problems tied to the target, and a solver trains on them using only code-execution feedback, so the target problem's verifier is never consulted during training.

  • Two LoRA adapters share a frozen Qwen3-8B backbone, and both are trained with GRPO; one is a proposer and the other a solver. The proposer writes a reference program first, then builds the problem statement and held-out tests from that program, and executing the program supplies the ground-truth outputs.
  • The proposer gets a triangular reward that peaks when the solver gets about half of its attempts right, which keeps problems at the edge of what the solver can do. A replay buffer reuses earlier problems whose current solve rate falls between 0.1 and 0.8.
  • On HardLCBv6, a difficulty-filtered subset of LiveCodeBench v6 released after the model's knowledge cutoff, TTSP beats rejection sampling, functional majority voting (FMV) and the prompt-optimization method ACE at every one of seven verifier strengths. Its performance stays roughly flat as the verifier weakens while the baselines decline, and with no verifier it gains 35 points (absolute) in mean@8.
  • Most of the gain comes within the first ~10 training steps. TTSP degrades gracefully when the correct answer is not the base model's most common output, whereas FMV only wins when it is and collapses when the correct answer ranks third or lower.
  • The main limitation is coverage: on VeryHardLCBv6, where the base model solves under 10% of 512 samples, the gain is roughly zero, and with strong verifiers it is slightly negative. The method also spends a separate adaptation budget on each target problem, and because its training signal is self-generated it risks the proposer gaming its reward and the solver's outputs losing diversity.

arXiv:2611.07367 PDF

WeLM-Image: A Unified Image Generation Model towards Visual Intelligence

Highlight HF pick · 20▲Vision Canmiao Fu, Chen Li, Guohui Zhang, Hao Lu, Hongyang Wei, Huadong Wu et al. WeLM-Image is a single image foundation model for text-to-image generation, instruction-guided editing and multi-reference synthesis, built for single-GPU deployment in WeChat. It processes text, reference images and target latents as one sequence. Its Mixture-of-Transformers (MoT) backbone shares attention but keeps separate parameters for understanding and generation, each path with Mixture-of-Experts (MoE) layers, for 31.7B stored and about 5.4B active generation parameters. Generation and editing are optimized separately with rubric-based rewards and then merged through distillation. The 1536-resolution model ranks first among evaluated open-source models on PRISM-Bench, Qwen-Image-Bench and UnicBench, and a distilled Turbo variant generates a 1024×1024 image in about 5 seconds on one H20 GPU.

WeLM-Image is a single image model from Tencent's WeChat Vision team. It handles text-to-image generation, instruction-guided editing and multi-reference composition, and is built to run on one GPU in large consumer apps. It does this by placing text, reference images and target latents in one interleaved sequence. A dual-path Mixture-of-Transformers backbone gives understanding and generation separate weights but lets them attend to each other.

  • Architecture: Each path of the 27-layer MoT–MoE backbone has its own Mixture-of-Experts layers, with 64 routed and 2 shared experts per path. Understanding tokens use top-6 routing and generation tokens use top-20, giving 31.7B stored parameters but only ~5.4B active per target latent token. A text-compatible 3D RoPE keeps the pretrained language model's positions exactly unchanged.
  • Data and training: A raw pool of ~5B images is filtered to 0.6B and organized with a knowledge-grounded visual vocabulary plus large-scale visual clustering, which balances long-tail concepts and editing tasks. After pretraining up to native 1.5K resolution, generation and editing are tuned in separate RL branches (rubric-based and checklist-based rewards). The two resulting policies are then merged by noise-aware on-policy distillation.
  • Results: The 1536-resolution model ranks first among the evaluated open-source models on PRISM-Bench, Qwen-Image-Bench and UnicBench, as well as the in-house WeGenEditBench. Its custom WeLM-Image-VAE (83.75M parameters) gets the best PSNR on all three reconstruction sets tested (for example 34.89 on COCO-512) and the lowest FID (12.21) and highest IS (97.96) among the 16-channel tokenizers in a downstream LightningDiT-XL/2 test.
  • Efficiency: MeanFlow few-step distillation produces WeLM-Image-Turbo, which makes a 1024×1024 image in 4.98 s on one NVIDIA H20 using eight steps without classifier-free guidance. That is an 11.4× speedup over the 50-step base model, and editing with one to four input images takes 6.78–13.17 s.
  • Caveats: The headline rankings compare only against open-source models, and one of the editing benchmarks is in-house. The supplied text also gives no per-benchmark scores, so the size of the lead can't be judged from it.

arXiv:2611.07392 PDF

When Bigger Becomes Brittle: Why Compression Hurts More as Language Models Scale

Highlight Large Language Models Gautam Gupta, Dikshant Kukreja, Unique Kumar, Avni Mittal, Deepanshu Dabas, Kshitij Sah et al. Benchmark scores after quantization or pruning show only the loss that reaches the output, not how much damage the rest of the network quietly compensated for. Focusing on in-context retrieval, which relies on a small set of identifiable attention heads, the authors exactly decompose the loss from ablating those heads into a part restored by other components and a part that reaches the output. For damage of comparable size, smaller models restore most of the loss while larger models retain most of it, and compressing these heads produces the same pattern. As a result, compression that is nearly harmless in small models can be costly in large ones.

Compression is usually judged by benchmark scores, but those scores mix two things: the damage done inside the network and the partial compensation ("self-repair") the rest of the model provides. The authors separate them for in-context retrieval on indirect-object identification (IOI) prompts. They use an exact accounting identity that splits the loss from damaged retrieval heads into what other components restore and what reaches the output, and find that larger models restore much less.

  • The identity is H = D − R − B − N, where D is the logit contribution lost from the targeted retrieval heads, H is the harm that reaches the output, R is copy-suppression release, B is the net backup response from all other heads and MLPs, and N is a final-normalization term. It is applied to zero-ablation, 4-bit per-channel weight quantization, and structural head pruning across GPT-2 XL, Llama 3.1 8B, six Pythia models (410M to 12B), and OPT.
  • At a matched deficit of 0.5 logits, Pythia-410M repairs about 0.55 logits and ends slightly above its clean margin, while Pythia-12B keeps about 0.38 logits as output harm. Under 4-bit quantization of the retrieval heads, the share of the deficit that reaches the output rises from 0.55 at 410M to 0.91 at 12B.
  • Both repair channels weaken with scale: standing copy suppression falls from about 25% of the clean logit difference at 410M to about 5% at 12B, leaving less to release, and the net attention backup offsets about 80% of the remaining deficit at 410M versus about 9% at 12B.
  • Backup heads still protect the larger models: holding the selected backup heads at their clean outputs adds about 0.30 logits of harm at 12B, even though their net attention response is only 0.07 logits. The authors suggest, but do not test, that opposing changes spread across many heads cancel out in the net sum.
  • The study covers only templated IOI retrieval and uses simulated quantization with dequantized fp32 weights rather than deployment kernels. Copy-suppression heads are excluded from compression, pruning results are non-monotonic for random masks, and the link between intermediate-layer "overshoot" and suppression is correlational only.

arXiv:2611.07891 PDF

EDGAR: Efficient Diffusion-Driven Gaussian Avatar Refinement via Synthetic Failure

Highlight HF pick · 7▲Vision Kwan Yun, Minhyeok Bang, Colette Suhjung Koo, Junyong Noh Gaussian-splatting head avatars built from monocular video or images often show blurring, stretching, and temporal flicker because geometry and texture are under-constrained. EDGAR is a one-step conditional diffusion refiner that removes these artifacts while preserving identity. It injects identity features from the self-supervised Sapiens model and uses a Mixture-of-Experts (MoE) design to handle different kinds and severities of degradation, and it is trained on EDGAR-SET, a hybrid dataset of real and synthetic renderings that imitate typical avatar failures. The refined multi-view frames then serve as pseudo-targets to re-optimize the avatar itself, so the refiner is not needed at render time. Across three avatar reconstruction methods, this improves perceptual and reconstruction metrics over both the raw outputs and an SDEdit-style baseline, including at large head turns and with open-mouth expressions.

Gaussian head avatars built from a single video or a few images tend to show blur, stretched textures and floating artifacts in views and expressions the capture didn't cover. EDGAR trains a reference-conditioned, one-step diffusion refiner on synthetic examples of these failures, then uses its refined multi-view renderings as targets to re-optimize the avatar, so rendering needs no diffusion pass per frame.

  • The training set, EDGAR-SET, holds about 400K triplets of degraded render, ground truth and reference image across about 1,600 identities, built from NeRSemble/RGBAvatar avatars trained with 1–4 views and synthetic CAFCA/3DGS avatars trained with 5 or more views; roughly half the pairs are dropped by an LPIPS filter so that only recoverable artifacts remain.
  • The refiner is built on SD-Turbo: features of the reference image from the self-supervised Sapiens model enter through zero-initialized cross-attention fusion blocks, a six-expert MoE router handles different kinds and severities of degradation, and a POSTER V2 expression loss helps preserve facial motion.
  • On RGBAvatar and GaussianAvatars, EDGAR leads on all four metrics (CLIP, L1, LPIPS, PSNR) at every input count, for example lifting RGBAvatar with 8 videos from 20.51 to 22.99 dB PSNR; on CAP4D results are mixed, with EDGAR best on CLIP and L1 while the unrefined baseline keeps the best LPIPS and an SDEdit-style baseline the best PSNR.
  • Identity is mostly preserved in cross-identity reenactment (CSIM 0.517 vs. 0.551 for the base avatar, against 0.318 for SDEdit), refinement takes a one-time 5–17 minutes per avatar with rendering speed within 2% of the original, and users preferred EDGAR over raw CAP4D 96.67% of the time overall.
  • Limitations: severe structural errors and artifacts in unobserved regions are left in place, temporal flicker gets worse for GaussianAvatars (warping error 4.93 to 5.94 ×10⁻³), cross-view consistency for single-video RGBAvatar drops, and the MoE contributes only marginal gains in the ablations.

arXiv:2611.07909 PDF

Learning Dynamics of On-Policy Distillation

Highlight Large Language Models Guan Zhe Hong, Sumeet Ramesh Motwani, Liang Chen, Yangchen Pan, Junchi Yu, Jialin Yu et al. On-policy distillation (OPD) trains a student language model on its own outputs with dense supervision from a teacher, so each update changes the data that produces the next update. The authors analyze this feedback loop in two stages: how the teacher's signal becomes parameter updates, and how those updates change predictions across prefixes and reshape later rollouts. The analysis explains why students can respond weakly despite large disagreement with the teacher, and why training can degenerate when updates that improve local agreement also make unsuccessful continuations more likely. They also find that offline distillation first can prepare a student so that OPD yields large accuracy gains, even though the offline phase barely improves held-out accuracy on its own.

On-policy distillation (OPD) trains a student on its own rollouts against a teacher's next-token distributions, so every update also changes which prefixes the student will be trained on next. The authors use a tangent-kernel framework to split this feedback loop into two stages: conversion, where teacher–student disagreement becomes parameter updates, and broadcast, where those updates shift predictions and the rollout distribution at other prefixes.

  • The teacher's per-prefix disagreement signal (the "request field") converts into policy motion with a gain that factors into accessibility × coherence. Accessibility is how responsive the student's tangent map is to the request, and coherence is how well per-prefix gradients add up rather than cancel. Broadcast is split into routing (changes in which prefixes get visited) and drift (changes in predictions at a fixed prefix).
  • Larger same-family teachers (DeepSeek-7B/14B) stall even though they score higher on benchmarks, while RL-trained siblings (JustRL-1.5B, AceReason-Nemotron-7B) transfer well. At 7B, the healthy teacher's requests have 2.75–3.24× higher coherence and 2.27–2.62× higher collective gain. At 1.5B, the healthy run's kernel reorients toward the teacher's requests and its leading eigenvalue strength grows to 2.31× by step 200, while the stalled run's shrinks to 0.67×.
  • Degeneration has a clear mechanism. When JustRL-1.5B teaches Qwen2.5-1.5B-Instruct, the student is routed into long, high-entropy rollouts where the teacher itself is unconfident: loss rises 0.58 → 0.85 over steps 1–20, driven mainly by routing. The student then spends later training fitting that unreliable supervision, and its MATH accuracy drops within 100 steps. By step 100 its probability of committing to an answer falls from 0.74 to 0.07, and the "continue" branch reaches a correct answer only 8% of the time.
  • Offline distillation on teacher solutions before OPD barely moves immediate accuracy but changes what OPD can achieve. At 1.5B, one to four preparation passes leave strict MATH-500 pass@1 at 45.7–47.1%, yet raise the 100-step OPD endpoint from 45.9% to 56.2%. Across Qwen-2.5 and Llama-3.1 students, the prepared OPD runs beat compute-matched offline training on pooled AIME 2024/2025 pass@k up to k=32 and on per-problem solve rates.
  • The experiments cover only mathematical reasoning and a small set of model families. Routing and drift are estimated over 20-step windows rather than per step, and the continuation-advantage term is only approximated with probe rollouts.

arXiv:2611.08016 PDF

NPCBench: A Clinical Apprenticeship Benchmark for Multimodal Care-Pathway Reasoning in Nasopharyngeal Carcinoma

Highlight HF pick · 1▲Multimodal Pengkai Wang, Wei-Wei Zhang, Yan Li, Min Tang, Zhitian Hou, Zeyu Liu et al. NPCBench evaluates medical AI on nasopharyngeal carcinoma the way specialists are trained, moving from guideline knowledge through case planning, longitudinal review, and consultation. It has 4,777 items and a 100-patient care-pathway cohort with 417 scored diagnostic and care tasks. Across 30 models, the authors find a composition gap: strong scores on individual tasks do not mean a model gets the diagnostic and care answers jointly right for the same patient. Among 21 multimodal models, strict care-pathway success reaches at most 23%.

Medical AI benchmarks usually score isolated exam questions or single images, so they can't tell whether a model gets the diagnosis and every care decision right for the same patient across a course of treatment. NPCBench tests this for nasopharyngeal carcinoma with a ladder modeled on specialist training. It runs from guideline recall through pathology and MRI evidence grounding to longitudinal revision and linked CarePath patient episodes, plus rubric-scored open-ended consultations.

  • The benchmark contains 4,777 component and consultation items and a 100-patient CarePath cohort with 417 scored tasks (100 pathology, 100 MRI T-stage, 217 care decisions); its Strict metric counts a patient as correct only if pathology, T-stage, and every care answer are all correct.
  • Across 30 models (21 multimodal), knowledge doesn't carry over cleanly to planning: guideline recall exceeds 92%, but the best case-planning accuracy is 71.9%, and removing multiple-choice options lowers guideline accuracy by 7.0–15.5 points.
  • Imaging is the weakest link: the best T- and N-stage accuracies (43.5% and 42.8%) barely beat majority-class baselines (37.5% and 40.0%), and on the 18-structure anatomical panel, full tumor-invasion correctness and evidence-grounded T-staging both stay below 5%.
  • The headline composition gap appears in CarePath, where Gemini-3.1-Pro-Preview reaches 89.9% Care accuracy but only 11.0% Strict success and the best Strict score is 23.0% (Claude-Sonnet-4.6); in consultations, top scorer GPT-5.1 (58.4) still triggers major-error criteria in 14.6% of responses.
  • Limitations include mostly single-center retrospective data, assigned rather than patient-matched pathology in 75 of 100 CarePath episodes, scores that are sensitive to class imbalance, and a consultation judge (GPT-OSS-120B) that agrees with physicians only 70.5% of the time (51.8% sensitivity) on the expanded audit.

arXiv:2611.08369 PDF

Applications 89

Autonomous agents for electricity-system planning

Yoon Pyo Lee, Samrendra Roy, Jay Phil Yoo, Kazuma Kobayashi, Souvik Chakraborty, Syed Bahauddin Alam cross-listed LLM agents run electricity-system planning end to end. They propose investment bounds, storage settings, and feeder interventions, interpret the results of automatically executed investment-and-dispatch optimization and feeder checks, and decide how to redesign and when to stop. Across forty carbon-constrained trajectories covering ten scenarios in five electricity systems and four countries, with single- and multi-agent setups, all forty produced plans that pass the physical and carbon-budget checks. By comparison, 28 of 40 matched reference designs exceed the new scenario ceilings.

arXiv:2611.05911 PDF

Confucius4-R2T2: A Stable-Prefix Streaming ASR Model for Real Real-Time Transcription

Daniel Huang, Qi He, Shaoxiong Duan, Yingjie Li, Qiao Cheng, Yitao Duan Streaming speech recognition (ASR) increasingly feeds machines such as translators and voice agents that act on each token immediately, so revising earlier output wastes work or triggers wrong actions. Confucius4-R2T2 is a streaming ASR model that never modifies earlier output, built by post-training Qwen3-ASR-1.7B on 1,500 hours of Chinese and English audio with the audio encoder frozen. Training uses labels based on a new concept, the Longest Stable Prefix (LSP), which the authors prove is monotone, consistent with the full-audio output, and maximal, letting a full-context model become a stable streaming one without architectural changes. The model approaches the base model's full-context accuracy while emitting stable text with low lag, gains extend beyond the training languages, and weights and code are open-sourced.

arXiv:2611.06043 PDF

Template Gap Reconstruction for Shell Output Simulation with Small Language Models

Jarrod Ragsdale, Rajendra Boppana cross-listed Small language models can simulate shell output without executing commands, but generating the full output forces them to predict both the recurring structure of a utility's output and the content that varies between runs. Template gap reconstruction (TGR) supplies reusable output literals with placeholder slots, and the model generates only the gaps. A template selector picks a template from a bank built from 18.7 million outputs, or picks an empty template to fall back to full-output decoding. For short gap sequences, TGR reaches an output edit similarity of 0.964 versus 0.812 for full-output decoding. It also cuts generated tokens by 26.3–38.3%.

arXiv:2611.06731 PDF

KG-AST for Cheaper CI/CD: Budgeted Test Selection and AI Bug Review

Henry Yeung cross-listed Continuous integration (CI) pipelines and AI code reviewers spend the same budget on every commit, even though few commits introduce bugs. KG-AST scores each commit's risk from git history and code-graph features so that heavy tests and AI review go to the riskiest commits first, and it gives the AI reviewer only a graph slice around the change. Across 155 open-source projects in 11 languages, a single cross-language model ranks commits so that testing the riskiest 20% covers 49-64% of bug-introducing commits, compared with 20% for random selection and 40-55% for testing the largest changes first. An AI reviewer finds 26% of later-fixed defects from the diff alone and 32% with graph context, and a static call-graph test selector runs about 8% of the test suite while including the relevant fix test in 85% of cases.

arXiv:2611.06950 PDF

Machine Learning for Live-Birth Prediction After IVF/ICSI From Structured Clinical Data: A Systematic Review, Meta-Analysis, and Critical Appraisal

Abdul Raheem Shahzad, Muhammad Zaheer Khan, Umar Ajaib, Asad Ur Rehman, Juan Deng, Ming Zhang Machine-learning models that predict live birth after in vitro fertilisation (IVF) or intracytoplasmic sperm injection (ICSI) report performance ranging from near chance to near perfect. A systematic review and meta-analysis of 48 studies found pooled area under the curve (AUC) of 0.814 for internally validated models versus 0.756 for externally validated ones, and the best machine-learning models beat logistic regression on the same data by only 0.056 AUC. 47 of 48 studies were at high or unclear risk of bias, only four checked calibration slope, and no model has evidence of clinical impact. The gains that survive validation came from tying predictions to specific clinical decision points and from local calibration, not from deeper architectures.

arXiv:2611.07124 PDF

Energy Measurement and Optimization of TinyML in Resource-Constrained Embedded Systems: A Systematic Mapping Study

Clariele Almeida, Renan Beserra, Rafael Moura, Danilo Ara\'ujo, Bruno Nogueira, S\'ergio Chevtchenko et al. Tiny Machine Learning (TinyML) runs models on microcontrollers and sensors under tight energy budgets, but studies vary widely in the models, measurement methods, and metrics they use. This systematic mapping study catalogs the models used, how energy is measured and reported, the factors that drive consumption (architecture, hardware, communication, numerical precision, inputs), and a taxonomy of optimizations covering model compression, hardware-aware design, system and communication tuning, and data processing. It finds that limited standardization of platforms, measurement procedures, and reporting hampers reproducibility and comparison across the field.

arXiv:2611.07264 PDF

Rigorously Certified Neural-Network Computation of Nonlinear Water Waves at Near-Machine Precision

Michal Shavit, Yongji Wang, Tristan Buckmaster cross-listed The authors build a pipeline that goes from neural-network discovery to mathematically certified solutions of strongly nonlinear partial differential equations, using periodic gravity-capillary water waves as the test case. Physics-informed neural networks learn the wave profile, wave speed and, in continuation experiments, surface tension directly from the governing equations with no training data. Staged training brings residuals to near machine precision and recovers high-amplitude Stokes waves, Crapper waves and Wilton ripples from a single formulation, and continuation in surface tension turns up new high-amplitude candidate solutions. One candidate is certified with interval arithmetic that accounts for roundoff, truncation and aliasing errors, and the argument is machine-checked in Lean. A large language model helped write the certification and formalization, but the result's validity does not depend on it.

arXiv:2611.07395 PDF

IMUDINO: Self-distilled Foundation Model for Inertial Sensing

Zhoutong Ye, Chengwen Zhang, Zixuan Wang, Xufeng Jian, Zhe He, Qingyang Wan et al. Existing foundation models (FMs) for inertial measurement unit (IMU) data tend to cover a single subfield, sometimes trail supervised methods, require fixed input lengths and sampling rates, and generalize poorly to new sensor placements. IMUDINO adapts the DINO self-supervised learning recipe to inertial data, using semantics-preserving motion transformations that simulate changes in motion patterns and sensor setups. It uses a plain transformer encoder with frequency-aware positional encoding, so it handles variable input lengths and sampling rates natively. The authors describe it as the first inertial FM to be competitive across human activity recognition, health, motion capture and odometry, with features that generalize across users, sensor setups and, for odometry, robot embodiments.

arXiv:2611.07437 PDF

The Popular Get More Popular: Auditing Brand Bias in Generative Search

Giorgio Monaco, Jacopo Lenti, Francesco Pierri cross-listed Generative search engines condense product recommendations into a few direct answers, so any built-in preference for particular brands has outsized commercial effects. The audit looks at two biases: favoring market-dominant brands, and favoring brands already stored in the model's parametric memory. Across major engines, top-quintile brands are cited 1.4x to 2.8x more often than the average brand among 1,176 market players, and web retrieval does not remove this bias. In controlled experiments with identical product attributes, replacing real brand names with unfamiliar ones lowers recommendation rank, while fact-preserving content rewrites barely help. The authors conclude that these engines create a rich-get-richer barrier that ordinary content optimization cannot overcome.

arXiv:2611.07614 PDF

Redacting Personal Data: A Speed and Accuracy Comparison of Regex, Presidio and Hybrid Designs

Sai Yashwant, Manoj Kumar Gondimalla, Arjun Sharma, Shubham Text sent to LLM APIs often contains personally identifiable information (PII), and teams rarely know how much latency redaction adds or how much PII slips through. The authors compare four redaction designs on 100 synthetic resumes: pure regular expressions (regex), Microsoft Presidio running on spaCy, a hybrid in which Presidio finds only names, and a fast hybrid that calls spaCy's named-entity component directly. Regex took 0.20 ms but caught only 88.9% of PII because it misses names it does not already know. The other three caught 100% of PII and kept all business terms, and the fast hybrid did so at a 13.48 ms median. Even the slowest option adds only 0.41% to a typical LLM call, so the authors recommend the fast hybrid, with regex as a backup layer.

arXiv:2611.07633 PDF

What the Middleman Delivers: Answer Behavior, Tool Permissions, and Billed Usage in LLM API Relays

Xiaodong Wu, Zhimin Zhao, Qi Li, Chaklam Cheong, Xiangman Li, Jianbing Ni cross-listed Third-party API relays resell access to LLMs at lower prices, and users have to trust them on model quality, instruction compliance, and billing. The authors tested 20 relays offering GPT-6 Astra and Claude Opus 5. Comparing answers with official responses flagged behavioral differences at 7 of 10 low-price relays, though several flags changed on retesting. No content injection was found in 3,332 screened responses, but four relays returned tool calls even when instructions disabled them. For identical requests, five relays reported 4,200 to 60,000 more input tokens than the official API, and where balances could be checked, charges followed those inflated counts. The authors conclude that advertised model and price are not enough to judge a relay and that evaluations need repeated measurements.

arXiv:2611.07650 PDF

PharmAgents2: Towards Autonomous End-to-End Drug Discovery

Haichuan Tan, Bowen Gao, Tao Huang, Jiaxin Tan, Xin Hong, Baoguo Yao et al. PharmAgents2 is an autonomous multi-agent system for end-to-end drug discovery. It combines Paper2Skill, which extracts decision knowledge from the literature, with Self-Scaling Discovery, which runs parallel agents across targets, hypotheses, and strategies. On the new PharmAgents-Bench v0.1, with 121 questions and three end-to-end tasks, it outperforms baselines in most decision categories and gets the top process scores on all end-to-end tasks. In three real-world studies, human-run experiments confirmed its findings, including a novel inhibitor scaffold for LpxH acting at a previously unreported allosteric site, active covalent compounds for JAK1, and a new binding target for a known bioactive molecule.

arXiv:2611.07653 PDF

EnergyBench: a live, gate-aligned benchmark of day-ahead forecasts for European power markets

Evgenii Genov, Ander Martinez Alonso, Christoph Bergmeir Energy forecasting models are usually compared on backtests and fixed datasets, which can leak future information or end up in foundation-model pretraining data. EnergyBench instead runs every model live each day at 11:30 CET, thirty minutes before the European day-ahead market gate closes. Each model forecasts the next day's price, wind, solar and load on a 15-minute grid for six bidding zones, using one frozen information set that includes three numerical weather prediction models. Models are ranked with a Bradley-Terry rating on the Elo scale. Over the first 32 days, adding weather covariates cut the error of time-series foundation models by 37-51%, and these models used zero-shot matched or beat a trained LightGBM. Model size mattered far less, median ensembles ranked highest, and grid operators' own forecasts stayed ahead on wind and solar.

arXiv:2611.07784 PDF

tok: a textual concrete syntax of BPMN and DMN for humans and AI agents

Marek Deja cross-listed tok is a plain-text notation for BPMN (Business Process Model and Notation) process models and DMN (Decision Model and Notation) decisions, with a single engine that validates documents against both standards, compiles them to XML with an automatic diagram, and serves LLM applications through the Model Context Protocol (MCP). A tok model uses 2.2 times fewer tokens than the smallest BPMN XML across 893 files from 37 tools, and the checker catches 98.2% of 1,411 injected faults, compared with 85.8% for XML Schema plus bpmnlint. Four LLMs that had never seen tok wrote valid tok from a one-page reference for 85.7% to 100% of 87 process descriptions, and as agents with a lean skill and one checker tool they reached 97.6% to 100% validity. A skill that makes the model read the reference through a tool cost 1.7 to 2.8 times as many tokens as the lean skill.

arXiv:2611.07945 PDF

Leakage- and Label-Aware Benchmarking of Class-Imbalance Strategies for Multimodal Chest X-Ray and EHR Classification

Dang-Khoa Bui, Quang-Huy Tran, Minh-Khoi Nguyen-Bui, Duc-Tuan Ngo, Thanh-Trong Tran, Tuan-Khoi Nguyen et al. The authors audit a benchmark of class-imbalance strategies for multimodal chest X-ray (CXR) and electronic health record (EHR) diagnosis built on 29,083 MIMIC-CXR radiographs from 10,479 patients. Under the benchmark's record-level splits, a lookup table that copies the label of a development-set radiograph with the same EHR vector nearly matched the best model, and on unseen patients every model fell to the level of predicting every case positive. The labels turn out to be keyword matches on a single admission's diagnosis codes copied to all of a patient's radiographs, so about a third of images carry labels from the wrong admission. With patient-separated splits and corrected labels, no imbalance strategy improved macro F2 by more than 0.01 and tuned tree ensembles showed no consistent edge over logistic regression. Only diagnostic history and image embeddings beat the all-positive baseline, and the authors provide a leakage-aware protocol and checklist.

arXiv:2611.07950 PDF

Create Your Own Work Stack: Deploying Self-hosted AI and Tooling in a Tech Startup

Saad Ahmed Bazaz, Talha Amjad, Abdurrehman Subhani, Sohaib Ahmed Bazaz, Abdullah Aamir A small software company reports on replacing part of its commercial coding-agent spending (Claude and Codex, about $325 per month across more than 25.93 billion tokens) with self-hosted open-source models. Local models were too slow and too weak to replace commercial agents outright, so the team moved to a hybrid setup. Commercial agents kept complex tasks, while local models handled coordination work such as context transfer, documentation sync, retrieval of internal information, and integration with self-hosted tools like Outline, Plane, and ERPNext. The authors estimate this shifts 27-36% of commercial AI workload to local inference, and they note that their first deployment failed to get adopted because of user-experience friction until they switched to a centrally configured setup.

arXiv:2611.08116 PDF

Accepted but Wrong: Silent Failures of LLM Code Repairs after API Migrations

Xiaobo Chen, Genliang Zhu, Ziyuan Wang, Chu Wang cross-listed After a runtime or API migration, an LLM-repaired function can run cleanly and still return wrong results, slipping past release checks that use typical inputs. A preregistered study of 73 tasks covering 60 documented changes in CPython, Node.js and SQLite executes every candidate repair on the real runtimes against withheld contracts. Gating releases on all assertions over typical inputs let through 0.410 of wrong repairs, while adding one edge-case input written from the release note cut this to 0.065, and three inputs from a frontier model that never saw the program reached 0.070. Against 233 hard distractors that mimic the legacy output on typical inputs, 0.15–0.17 of wrong programs still passed. Across three open-weight model families the edge input reduced wrong releases without lowering correct completions, and self-written tests helped less.

arXiv:2611.08269 PDF

The Gold Rush in AI4Math, II: What are signatures of AI-assisted Proofs?

Yuanchuan Guo, Jiashun Jin, Zheng Tracy Ke, Bingcheng Sui The study asks whether AI involvement in mathematical proofs can be detected, as opposed to AI help with wording. The authors assemble five cohorts of 8,281 papers, including matched human and AI-generated pairs that address the same problems. Their ProofTrace framework represents each paper as a graph of which results support which, called a graph of immediate proof support (GIPS), and extracts interpretable features from it. AI-generated proofs cite fewer external results, rely more on intermediate conclusions, and have different graph connectivity, and ProofTrace stays accurate under AI rewording while text-based detectors drop sharply.

arXiv:2611.08412 PDF

A Hidden Markov Preference Model for Online Prediction of Adversary Actions

Angel Daruna, Michael Cogswell, Tixiao Shan, Yi Yao, Han-Pang Chiu, Ajay Divakaran A cyber defender anticipating an attacker needs a probability distribution over the attacker's next action, even though the attacker's behavior regime can switch partway through an episode. The authors model the regime as the hidden state of a hidden Markov model and define actions over a tree of currently executable operations and arguments. Estimation reduces to convex logistic fits that Baum-Welch reuses when regimes are unlabeled, and the paper derives log-loss bounds and a fallback guarantee. On the CAGE 2 cyber defense benchmark the filtered regime belief is worth 0.8 nats per step, and after the attacker switches controllers prediction loss starts falling within three steps versus ten for a recurrent baseline.

arXiv:2611.08445 PDF

70 more specialized papers

Large Language Models 74

SRRM: A Retrieval-Reconstruction Benchmark for Evaluating Long-Context Memory in Small Language Models

Christopher Alberto Hamonangan Small language models running on consumer hardware are usually evaluated on retrieval tasks, which may not show whether they actually retain everything in a long context. SRRM (Simple Retrieval-Reconstruction Memory) is a lightweight synthetic benchmark that measures both targeted retrieval and reconstruction of the full context, plus a Memory Preservation Ratio (MPR) that relates the two. Tested on Qwen2.5 0.5B, 1.5B, and 3B with 10 to 100 facts in context, reconstruction degrades much faster than retrieval. Qwen2.5-1.5B outperformed the larger 3B model on retrieval (86.7% vs 72.2%), reconstruction (45.7% vs 18.5%), and MPR (0.53 vs 0.26).

arXiv:2611.05386 PDF

When to Ask, When to Answer: Strategic Clarification for Ambiguous Reference Resolution in Dialogue

Ibrahim Khebour, Nikhil Krishnaswamy Large language models (LLMs) tend to answer ambiguous references right away instead of asking clarifying questions that would narrow the candidates. The authors build a controlled reference game from SIMMC 2.1 that records how many questions each ambiguous reference needs, and use it to examine baseline and post-trained LLM behavior. They propose BACE (Belief-Aware Critic with Epistemic tracking), a lightweight action chooser on top of a frozen language model that decides whether to ask or answer. BACE more consistently asks the optimal number of clarifying questions than post-training methods such as GRPO and ArCHer.

arXiv:2611.05517 PDF

AGORA: Reliability-Aware Aggregation of LLM Judges via Item-Response Theory

Junhyung Ahn cross-listed When LLM judges are combined by simple averaging, weak judges count as much as strong ones, while confusion-table methods like Dawid-Skene need more labeled items than typical validation sets provide. AGORA (Aggregation Of Reliability-weighted Assessments) applies item-response theory: it places every item on a single latent quality scale and gives each judge a sensitivity parameter and ordered rating thresholds, all learned jointly without human labels. Across three benchmarks it matches or beats Dawid-Skene on large evaluation sets, and its advantage grows as the set shrinks toward a few hundred items. A label-free dispersion statistic predicts in advance when reliability weighting will help.

arXiv:2611.05556 PDF

RAGCompass: Generalizable Retriever Routing via Reranking

Valentin Six, Mufei Li, Dongqi Fu, Yinglong Xia, Hong Li, Pan Li No single retriever works best for every query in retrieval-augmented generation (RAG), and existing routers choose from query features alone, so they cannot handle new retrievers or corpora. RAGCompass routes by comparing the passage sets each retriever actually returns, using a reranker contrastively fine-tuned on the answers each evidence set produces plus a small comparison head, with no retriever-specific parameters. It improves answer F1 by 28% relative to the best fixed retriever and outperforms fusion baselines, query-only routers, and a prompted 8B model. It keeps most of that gain on an unseen corpus, retriever, or reader model.

arXiv:2611.05596 PDF

Matching the Training-Time Weight Rule in Inference-Time Expert Deactivation

Hao Cheng (Zhejiang Gongshang University), Zhiyu Yang (Chang'an University), Bo Ma (Zhejiang Gongshang University), Hanzhang Jia (University of Sussex) Switching off experts in Mixture-of-Experts (MoE) models at inference time can be implemented several ways: removal, freezing, renormalizing the remaining experts, or unnormalized re-routing. The authors compare these on the same disabled expert sets across five instruction-tuned checkpoints and a base OLMoE model. They also develop a weight-sum model that ties the outcome to the weighting rule the model used during training. With half the experts disabled, perplexity rises 1.4 to 73 times when the implementation matches the training rule, but up to 28,740 times under a rule mismatch. On OLMoE, GSM8K accuracy falls to zero under all four implementations.

arXiv:2611.05804 PDF

On the Design of Hyper-Connections: Simplification, Stability, and Scalability

Xiangdong Zhang, Xiaohan Qin, Sunan Zou, Tuo Dai, Bizhao Shi, Zhuo Xia et al. cross-listed Hyper-Connections (HC) architectures, increasingly used in frontier language models, add training overhead and contain components that are poorly understood. A systematic study finds that either learned read/write gating without mixing, or unconstrained mixing with fixed gates, alone matches mHC. It also finds that repeatedly accessing the expanded residual state is a major source of overhead. The resulting SimpleHC drops residual mixing and shares memory access across layers, and it adds only 2.4% end-to-end training time over a plain residual baseline while matching mHC on MoE models from 15B to 30B parameters, with smoother gradients and stable training.

arXiv:2611.05984 PDF

Familiar letters, not related languages, let unseen languages into a shared space of meaning

Yuliang Liu, Xinyu Wang, Xiang Bai For languages with written text but almost no translations, it is unclear whether a model learning from untranslated text benefits more from a related language or from a familiar script, since the two usually coincide. The authors build GlyphMind, a tokenizer-free vision transformer that reads text as pixels, so any sentence can be rendered in any script, and pretrain it to align translations across 27 writing systems. Adapted on untranslated Lao, it retrieved English translations seven times as often as the strongest simple baseline. Experiments that swap scripts show that familiar letters, not a related language, determine whether an unseen language enters the shared meaning space: Lao in unfamiliar letters failed despite Thai being in pretraining, while Santali succeeded when written in Devanagari but not in its own script.

arXiv:2611.06006 PDF

Adapting Qwen3 to Tajik from 0.6B to 8B: Lower Text Loss Did Not Mean Better Understanding

Tohir Saidzoda, Madina Abdusalomzoda, Nasimjon Rajabov, Akhrorkhon Ikromov, Komron Giyosiev, Abubakr Abdullozoda et al. The authors adapt Qwen3 models from 0.6B to 8B parameters to Tajik and find that small LoRA adapters lowered Tajik text loss at every size but did not improve Tajik reading comprehension on Belebele where it could be measured. Only heavier continued pretraining on about 375 million tokens of raw Tajik text at 8B produced a real gain (9.9 points), and after supervised fine-tuning their main model e3 scores 11.4 points above Qwen3-8B with a 1.2-point drop in English MMLU. The same heavy recipe on the 0.6B base brought its text loss close to the 8B model's while its multiple-choice answers stayed near chance. The report covers 15 trained models and openly documents failures, including lost training records, a thinking-mode dataset with almost no reasoning, and a 4-bit release with no transformer layers.

arXiv:2611.06062 PDF

Accelerating Long-Context Decoding in Large-Scale Hybrid LLMs Without Retraining

Jo\~ao Eduardo Batista, Emil Vatai, Mohamed Wahib Hybrid language models replace most full-attention layers with cheaper linear-attention layers, but the remaining full-attention layers still dominate decoding cost at long contexts. The authors speed up these layers without training or weight changes by having each one attend to a sliding window of recent tokens, a pinned prefix, and a fixed budget of the most relevant tokens, with per-layer window sizes and budgets chosen by a multi-objective search. Across six hybrid models from 4B to 397B parameters, the chosen configurations preserve baseline accuracy on 21 long-context datasets while making decoding at 256k tokens up to 2.2x faster, for example 2.22x on Qwen3.5-4B and 2.06x on Ornith-1.0-397B.

arXiv:2611.06133 PDF

Presentation Sensitivity in Typed Decision Models for Subjective Text Evaluation

Jatin Agrawal, Radhika Mamidi Typed decision models return structured choices, scores, and probabilities as a cheap form of automated evaluation, and this audit tests how much their judgments depend on presentation rather than content. Across six datasets of humor, helpfulness, and summarization items, the authors collect 702,000 judgments from Jev, Clef Flash, and Perplexity Decider, varying position, identifiers, authorship claims, endorsements, decision framing, and rubrics while keeping the evaluated texts the same. Effects are large: reversing reader endorsements changes Perplexity's humor choice on 40.40% of pairs, and rejection framing lowers Clef's agreement with human preferences on summaries by 23.36 points. The authors conclude that repeatability, robustness to presentation, and alignment with humans are separate properties, each of which must be validated on its own.

arXiv:2611.06384 PDF

Where Should a KV-Cache Repair Budget Go? Distractor Structure and Contextual Compatibility in Non-Prefix Reuse

Yuxing Peng, Zhiqing Tang, Weijia Jia Non-prefix KV-cache reuse encodes retrieved chunks independently and concatenates their caches, which saves compute but loses cross-chunk context. Across three 7B–8B models and four datasets, reuse loses 19–100% of the context-dependent questions that full prefill answers, and it loses more when the surrounding chunks resemble the answer-bearing one. The authors find that a small recomputation budget is better spent on the answer-bearing chunk than on its neighbours, and that recomputing it against the reused cache beats inserting its full-prefill KV. Picking that chunk with a retriever and moving it next to the question beats InfoFlow-style reordering at a 5% budget in most QA and API-documentation settings, but not on dialogue memory.

arXiv:2611.06397 PDF

NaijaFacts: A Framework for Disentangling Language from Knowledge in Facts about Nigeria

Zainab Afolabi, Nikita Kozodoi, Jack Butler, Babs Khalidson Most African-language benchmarks translate generic questions, so they measure language ability rather than knowledge about Africa. NaijaFacts contains factual and statistical questions about Nigeria, written by native speakers and grounded in official statistics, in English, Nigerian Pidgin, Yoruba, Igbo, and Hausa; matching UK and US question sets separate a language effect from a knowledge effect. Across eight models the knowledge gap dominates: no model exceeds 31% on Nigerian statistics, while the strongest models reach 66–79% on UK and US questions, and scale does not close the gap. Extending the test to all 54 African countries shows the same pattern, with high accuracy on culture and politics but only 26% on statistics.

arXiv:2611.06504 PDF

LLMs Don't Know What They Know: Benchmarking Temporal Self-Knowledge for Financial Backtesting

Lingfei Qian, Yan Wang, Xueqing Peng, Yupeng Cao, Yuechen Jiang, Zhuohan Xie et al. Financial backtests of large language models (LLMs) are valid only if the model did not already know the outcomes. Practitioners usually guard against leakage by trusting stated knowledge cutoffs, asking the model what it knows, or telling it to answer as of a past date. FinDendro tests these safeguards with 2,226 dated U.S. macroeconomic, stock-price, and Federal Reserve facts from 1999 to 2026. For most frontier models, self-reports understate knowledge: GPT-5 answers 76% of controlled facts correctly but claims to know only 38%. It also answers 61% of the facts it says it does not know. Knowledge claims can persist up to seven quarters past the measured boundary, and declaring a historical date suppresses claims of prior knowledge without changing accuracy.

arXiv:2611.06808 PDF

LooM: Loop-Invariant Memory for Causal Encoder-Decoder Language Models

Lele Yang, Muxi Diao, Zhonghao Yan, Jiankang Chen, Bin Wen, Tingting Gao et al. Looped Transformers gain depth by re-running shared layers, but their memory grows with the loop count, compute can only change in whole-block steps, and the loop count is hard to change after training. LooM (Loop-invariant Memory) loops only the later decoder layers of a causal encoder-decoder, and each layer writes a token's key-value cache entry only on its first visit. As a result, the cache does not grow with the number of loops. A single model trained on randomly sampled budgets supports any budget from 3 to 21 layer executions per token without a router. With enough loops, it beats a single-pass baseline on language modeling, zero-shot accuracy, and long-context perplexity at the same cache size.

arXiv:2611.06835 PDF

Balancing hierarchical representation and quantization: A performance trade-off in text embeddings

Kai Ponel, Marco Polignano, Erasmo Purificato, Aylin Julia Temizkan, Marco Levantesi, Giovanni Semeraro et al. This benchmark study measures how hierarchical (variable-length) text embeddings interact with quantization across 38 MTEB tasks, four embedding models, and 168 configurations per task. Under Friedman and Nemenyi statistical tests, int8 quantization is statistically indistinguishable from float32 for pair classification and re-ranking and costs at most 1.5 percentage points overall. Binary quantization is significantly worse in every task category. Combining an 8x dimension reduction with int8 gives a 32x reduction in per-vector storage while keeping 94.4% of baseline effectiveness. Retrieval degrades much faster than other categories, and the authors found no evidence that quantization speeds up evaluation.

arXiv:2611.06859 PDF

BlockLock: Reproducible LLM Inference with Fixed Batch Geometry

Xiuyuan Qi, Pedro Reviriego, Javier Conde, Shanshan Liu Reproducible LLM inference means a request produces the same output no matter which other requests share its batch, and existing fixes either constrain every operator with batch-invariant kernels or give up shared prefill compute. BlockLock keeps batched prefill and fixes only the numerical path of the protected request by pinning the batch geometry it sees. It has two modes, one using fixed-width rows with batched decode and one using packing followed by isolated decode, and both keep the target's output bitwise identical when companion requests change. Across five models including Qwen3-8B and Llama-3.1-8B-Instruct on A6000, A100, and H100 GPUs, the row-based mode cuts latency by 53.5-55.0% and roughly doubles throughput compared with vLLM Batch-Invariant, without any custom kernels.

arXiv:2611.06977 PDF

Resource-Efficient Reinforcement Learning Post-Training through Elastic Expert Parallelism

Jia Wei, Ziyi Qiu, Yi Xu, Xuehai Qian In reinforcement learning post-training of mixture-of-experts LLMs, workers that finish generating their responses often stay occupied because other workers still need their experts, and about a third of occupied worker time is spent this way. FlexFloor schedules responses using historical length data and memory constraints, then releases workers progressively while keeping every expert available and communication correct. Compared with the verl baseline, it produces about 65% more response tokens per unit of occupied compute and raises generation throughput by 52.74%, with little change in rollout reward.

arXiv:2611.06984 PDF

LowRAM: Low-Rank Keys and Amortised Values for Composable KV Cache Compression at Test-Time

Teresa Delgado, Hugo Hazard, Martin Benfeghoul, Jun Wang, Zafeirios Fountas The key-value (KV) cache used during autoregressive decoding grows linearly with context length and limits batch size and throughput. The authors observe that within each attention head, values are largely predictable from their keys, so they fit a lightweight per-head predictor at test time and store residuals only for the tokens it reconstructs worst, giving near-lossless 4x value compression. Combined with cross-layer low-rank key compression, the resulting LowRAM pipeline stays close to lossless across three model families and reaches up to 5x higher peak decode throughput. It also composes with quantization and eviction, reaching 26.9x compression at 94.5% of baseline performance on long contexts.

arXiv:2611.07025 PDF

A Night at the LLM Zoo: Data Conditioned Flow Matching for Generating Pretrained LLM Weights

Scott Biggs, Bedionita Soro, Saumya Gupta, Bruno Andreis, Sung Ju Hwang Weight-space learning, which treats trained model weights as data, lacks a well-curated population of language models to study. The authors train a model zoo of GPT-2 models at 51M, 124M, and 355M parameters, 100 per size, systematically varying the training mixture of web text, books, math, code, and French, and show that variation across the zoo is structured by mixture composition. They then train a mixture-conditioned flow-matching model over compressed weights that generates complete pretrained LLM weights for held-out data mixtures whose perplexity and benchmark scores are close to those of the trained models. All code and artifacts are released.

arXiv:2611.07103 PDF

PromptOps: Iterative Prompt Optimization for LLM-as-a-Judge Systems

Sven Kleinkop, Tam\'as Janusko, Ricardo Bochnia, Gunnar Hempel, Steffen Tomschke, J\"urgen Anke et al. LLM-as-a-judge systems can drift out of agreement with their intended human evaluation policy as user interactions and score distributions change, while automatic prompt optimization is usually studied as a one-off procedure on a static dataset. PromptOps is a closed-loop framework for monitoring and recalibrating judge prompts that separates four decisions: when to optimize, which optimizer to use, which feedback records to use, and how to update the prompt. It is instantiated with five methods, including GEPA, SIMBA, and Rubric Synthesis. Iterative optimization recovers judge performance after controlled distribution shifts, but neither the choice of optimizer nor the update timing generalizes across settings.

arXiv:2611.07123 PDF

FastAFD: When Does Attention-FFN Disaggregation Pay on Rack-Scale NVLink?

Yichao Fu, Yuxuan Zhang, Minshen Zhang, Ruitian Wang, Junda Chen, Hao Zhang cross-listed Attention-FFN disaggregation (AFD) runs attention and the mixture-of-experts (MoE) layers of a model on separate GPUs, and earlier work reported higher decode throughput than colocated serving. It was unclear whether that advantage holds on rack-scale NVLink systems like GB200 NVL72. The authors build FastAFD, which overlaps one microbatch's MoE computation with another's attention, and compare it against the best vLLM wide expert-parallel configuration. AFD comes out up to 1.17x faster on Qwen3 and ties on MiniMax-M2.5. An analytical model predicts AFD throughput within 3% using only colocated profiles, and it breaks the speedup into a batch gain, an overlap gain, and a disaggregation cost.

arXiv:2611.07149 PDF

TileQuant: Tile as the Precision-Allocation Unit for LLM Mixed-Precision Post-Training Quantization

Hanzhi Zhang, Qiao Zhang, Qinglei Cao, Heng Fan, Yan Huang, Kewei Sha et al. Mixed-precision post-training quantization (PTQ) of large language models usually keeps whole weight columns at higher precision, but sensitivity varies within columns, so protecting entire columns wastes bits. TileQuant instead allocates precision to hardware-aligned 2D weight tiles. It scores tiles offline using either cheap activation statistics or gradient-based loss sensitivity, keeps the top-scoring tiles at 16-bit and the rest at 8-bit, and uses a custom kernel that runs native integer and 16-bit computation over compact buffers. The authors report 2.66x the original model's generation throughput while preserving quality across language modeling, reasoning, long-context retrieval, and question answering.

arXiv:2611.07217 PDF

Loopback Transformer: Towards a Unified View of Residual Looped Transformers

Xuan Ouyang, Zefan Cai, Chenlong Zhang, Cheng Luo, Ke Wan, Junjie Hu Looped Transformers save parameters by reusing shared blocks, but how earlier passes' results are stored and reweighted has received little systematic study. The authors argue that weighting full block outputs also reweights the history each output already carries, and propose reading individual per-pass updates instead, with the stack's input kept on a separate path. Loopback Transformer uses geometric decay to set the total update weight and attention to distribute it across updates. On ClimbMix, it reaches lower validation loss than standard Transformers with 40-75% of their Transformer parameters at scales from 191M to 3B, and beats seven other looped residual designs at the smaller scales.

arXiv:2611.07226 PDF

Recursive Sparse Attention: Million-Token Length Extrapolation at Logarithmic Cost

Ruitian Wang, Xinyu Yang, Minshen Zhang, Hao Zhang cross-listed Most sparse attention methods still score every previous block, giving per-query selection cost linear in context length, and earlier hierarchical methods were only shown to work within their training length. RecSA (Recursive Sparse Attention) builds a tree over the key-value cache in which each node summarizes its subtree, so each query selects and reads only a logarithmic number of entries. Positions are assigned by index among candidates at each level, which keeps relative distances within the trained range at any length. Initialized from Qwen3-4B and trained on 0.62B tokens at 32K context, it scores 60.5 on RULER at 1M tokens versus 40.0 for the best baseline and speeds up prefill by 3.2x and decoding by 3.8x at 524K tokens on one H200 GPU.

arXiv:2611.07232 PDF

TriAttention: Unified Sparse Mixed-Precision Attention for Long-Context LLM Inference

Hanzhi Zhang, Qiao Zhang, Qinglei Cao, Heng Fan, Yan Huang, Kewei Sha et al. Some attention interactions can be computed at low precision but still hurt quality if removed entirely. TriAttention assigns each query-key tile to one of three options (skipped, 4-bit, or 8-bit), encoding each head's policy with two diagonal-distance boundaries so that policy storage does not grow with context length. Boundaries are chosen offline by a model-wide allocator under a shared compute budget, a fused kernel runs the mixed-precision prefill, and the quantized keys and values are reused as a compressed cache during decoding. It reports end-to-end generation speedups of up to 7.88x over Torch attention and 2.65x over a BF16 baseline while keeping quality comparable on general and long-context tasks.

arXiv:2611.07256 PDF

Rethinking Data Selection: The Importance of Coverage over Difficulty in LLM Fine-Tuning

Lalchand Pandia, Kanishka Misra, Allyson Ettinger Data selection methods for fine-tuning usually score examples by difficulty, on the theory that harder examples teach more. The authors find these methods often fail to beat random selection when fine-tuning LLMs, and trace the reason to coverage: random subsets represent the input distribution better. A simple clustering-based method that picks representative examples matches or beats random selection on single-domain tasks. On the multi-domain Tülu 3 mixture, where random sampling no longer yields a balanced subset, it outperforms all compared methods.

arXiv:2611.07323 PDF

From What Is Used to What Is Missing: Rethinking Dynamic Rank in LoRA

Peng Xue, Guodong Fan, Guang-Yong Chen, Xing Chen cross-listed Methods that change LoRA's rank during fine-tuning mostly decide how to allocate a fixed capacity, without asking whether the current low-rank space can express what the task needs. The authors show that LoRA's standard factor gradients are blind to directions in the normal space of the low-rank manifold. The leading singular directions of that normal space give the locally optimal way to add rank. Their method, GEAR, combines tangent-space optimization, matrix-free estimation of the normal spectrum to decide rank expansion, and task-based initialization. On LLaMA3-8B it raises average commonsense accuracy from 86.61 to 88.45 while cutting trainable parameters from 42.0M to 14.4M.

arXiv:2611.07349 PDF

CacheGraft: Enhancing Retrieval-Augmented Generation via Latent-Space Document Enrichment

Vihan Lakshman, Peter Baile Chen, Zhuohan Gu, Michael Cafarella cross-listed CacheGraft applies cache-to-cache translation, originally a way for agents to communicate through key-value (KV) caches rather than text, to retrieval-augmented generation (RAG). Building on the Cache-to-Cache (C2C) fusion framework, it encodes each corpus passage offline into a fused KV cache shared between a 4B-parameter model and a 0.6B-parameter model. At query time the cache is injected into the small model alone. Across five QA benchmarks and two locally run judges, it improves answer quality over text-only retrieval with the small model in 29 of 30 comparisons, 17 of them statistically significant, even though the fuser was never trained on retrieval data.

arXiv:2611.07393 PDF

Latency-Aware Adaptive Best-of-$N$

Alon Jacobson, Qian Xie, Peter I. Frazier cross-listed Adaptive test-time compute (TTC) methods usually stop sampling once a quality signal crosses a fixed threshold and count cost in generations or tokens, ignoring the fact that latency in online serving rises with server load. For Best-of-N sampling, the authors propose a two-stage algorithm that draws a first batch and then decides whether to draw a second batch, and how large, using a reward threshold that falls as the first batch's latency rises. Rewards are mapped to their cumulative distribution function (CDF) values, so tradeoff settings carry over across tasks, and an offline regression gives the expected improvement in closed form. In simulation on a preference-based alignment benchmark, the method matches Best-of-N reward at lower combined generation and latency cost, with the largest savings over latency-unaware baselines when latency is highly variable.

arXiv:2611.07453 PDF

Localization Does Not Imply Steerability: A Mechanistic Study of Sign Errors in LLM Mathematics

Shradha Agarwal, Tariq J., Deepak Rajbhar A common failure in LLM multi-step math is writing a single wrong sign token mid-computation and then carrying out the rest correctly. Across six open models from 14B to 675B parameters, the authors find the wrong sign is committed late, by MLP layers in the last quarter of the network, with mechanisms that vary by model: fixed minus-pushing layers, amplifiers of an already chosen sign, or downstream rescue layers. Subtracting a single sign direction from the residual stream flips 13 of 14 held-out integration-by-parts errors on Llama-3.3-70B, and the effect partially replicates on Qwen, Gemma and Mistral-Small; core claims were preregistered, with 23 of 29 checks passed. However, Phi-4 has an equally well-localized circuit that the same intervention barely moves, because the sign is written redundantly across about 15 layers, leading to the conclusion that localization does not imply steerability.

arXiv:2611.07478 PDF

FlashOffloading: Low-Latency KV Cache Offloading for Long-Context LLM Serving

Xuan Wang, Zhuanhao Wu, Tingzhu Fang, Xushi Li, Sicheng Zhang, Zhenyu Yang et al. Long-context large language model (LLM) serving runs out of GPU high-bandwidth memory because the key-value (KV) cache grows with sequence length and concurrency, and offloading the cache to host memory usually adds enough latency to cancel out the concurrency gain. FlashOffloading fully offloads the KV cache to host memory during both prefill and decode, using a rolling device cache for prefill, a hot cache for decode, a reverse sparse index that adds no lookup cost on misses, and a kernel that overlaps computation with loading. Running GLM-5.2 with speculative decoding on a disaggregated Ascend910C platform, it improves decode throughput by up to 1.91x and prefill throughput by up to 1.38x under a 30 ms time-per-output-token target. The system is integrated into the open-source vllm-ascend serving framework.

arXiv:2611.07542 PDF

SKIM: Pruning Large Language Model Agents via Selective Knowledge Informed Masking

Moonseok Choi, Jongwon Jeong, Minki Kang, Giung Nam, Juho Lee cross-listed LLM agents often run under structured generation, where grammar constraints restrict outputs to valid tokens, yet existing compression methods are designed for unconstrained generation. SKIM (Selective Knowledge-Informed Masking) is a pruning-and-distillation framework that splits token positions into context, decision, and format roles. It uses that split to compute pruning saliency scores that protect the parameters behind action-deciding positions, and to drive on-policy distillation restricted to grammar-valid tokens. On tool-calling benchmarks and multi-step agent loops across several model sizes, SKIM consistently beats baselines, with the largest margins at high sparsity.

arXiv:2611.07558 PDF

ACSeL: Adaptive Configuration Search for Hardware-Constrained LLM Inference

Bokun Wang, Hung-Yueh Chiang, Diana Marculescu Serving LLMs under tight memory and latency budgets, including on edge devices, requires choosing model size, batch size, quantization algorithm, and per-layer mixed precision jointly, a space too large to search exhaustively. ACSeL searches this space using Relative Model Quality Degradation (RMQD), a cheap quality proxy based on next-token distribution divergence that correlates strongly with downstream benchmarks, along with a learned surrogate that predicts RMQD from a configuration. It also calibrates operator-level latency estimates with a few end-to-end profiles (Few-shot Median Calibration, FMC) and explores layerwise mixed-precision configurations with a structured search called BandPareto. On an RTX A6000 workstation and a Jetson Thor edge board, BandPareto with FMC achieves the highest rate of constraint-satisfying configurations and the smallest quality gap to the best measured configurations.

arXiv:2611.07570 PDF

English Calibration Erodes Lithuanian in Expert-Pruned Mixture-of-Experts Language Models

Tomas Rasymas, Povilas Kvedaras cross-listed Expert pruning shrinks Mixture-of-Experts (MoE) language models by dropping the experts that a calibration set marks as unimportant, and earlier work on high-resource languages found that English calibration transfers well to other languages. The authors tested this for Lithuanian by pruning four MoE models with REAP, removing 25% or 50% of experts using English, Lithuanian or mixed calibration data, then measuring reading comprehension, translation and language modelling in both languages. English calibration did not transfer: at 25% pruning, English comprehension fell by a median of 1.7 points but Lithuanian comprehension fell by 21.4 points. Lithuanian calibration recovered most of that loss without significantly hurting English comprehension, and routing analysis shows that Lithuanian concentrates its last-layer expert selections on a few experts that English calibration tends to remove.

arXiv:2611.07654 PDF

ConvPE: Convolutional Position Embedding Improves Transformers

Zehao Wang ConvPE (Convolutional Position Embedding) adds a windowed, content-dependent bias to attention scores by running a lightweight causal convolution over a low-dimensional projection of the hidden states. It works as a plug-in alongside RoPE, attention masks, and KV concatenation, and extends to 2D and higher-dimensional positions through higher-dimensional convolutions. The authors report gains in performance and efficiency for language modeling, long-context extension, and vision, with ConvPE outperforming five 1D and eight 2D position-embedding baselines in their reproduction.

arXiv:2611.07749 PDF

The Intrusion Pathway: How Non-Evidential Context Degrades Language Model Performance

Dikshant Kukreja, Gautam Gupta, Avni Mittal, Avinash Anand, Kritarth Prasad, Zhengkui Wang et al. Language models lose accuracy when prompts contain irrelevant context, such as unrelated statements or random tokens, a common situation in retrieval-augmented, tool-using, and long-context deployments. The authors trace this failure mechanistically to an "Intrusion Pathway" and localize much of it to a sparse set of "intrusion heads" that promote distractor content, transfer across tasks and distractor types, and are largely separate from the heads that use relevant context. Replacing the corrupted final-token state with a clean one recovers 97.6% of the accuracy drop, but this requires a matched clean forward pass. A practical intervention that knocks out about ten heads, roughly 1% of the model's attention heads, recovers 57% of the drop at limited cost to helpful context.

arXiv:2611.07778 PDF

Computation, not weight access: large language models as auditors of clinical prediction networks

Zhiyu Liu, Xinyu Yang Frontier LLMs have been reported to read and edit the weights of small neural networks, which raises the prospect of auditing clinical prediction models from their files alone. In pre-specified simulation experiments on networks trained on simulated patient cohorts, the authors separated reading raw weights from running computation. Without tools, GPT-6 Astra became unreliable at about 3,457 weights and refused most audit tasks under its default instruction. With a calculation-only tool, it recovered planted relationships in all 29 runs on networks up to 38,401 weights, raised no false alarms, and found a biased subgroup in every attempt. Black-box access to predictions alone performed as well as access to the weights, and a well-designed script matched the other models on the audit.

arXiv:2611.07847 PDF

Which Signals of Code Correctness Survive Distribution Shift? Hidden-State and Causal Predictors of Program and Verdict Correctness

Viola Campos, Thomas Klassert, Adrian Ulges cross-listed LLM judgments of code correctness are unreliable without execution, so cheap predictors based on output probabilities, sampled solutions or hidden states are used to flag which judgments need checking. The authors compare six such predictors on Qwen3-Coder-30B and gpt-oss-20b, under shifts between LiveCodeBench and BigCodeBench and across Python, C++ and Java. These include two causal localization methods newly adapted to code. For Qwen3-Coder, a probe on the causally localized subspace stays 0.09 AUROC ahead of output confidence under language shift, but this advantage does not carry over to gpt-oss or to benchmark shift. Predictors of program correctness transfer better between benchmarks, but mostly by spotting problems the model tends to fail, and they rank candidate solutions to the same problem poorly.

arXiv:2611.07876 PDF

When Bigger Becomes Brittle: Why Compression Hurts More as Language Models Scale

Gautam Gupta, Dikshant Kukreja, Unique Kumar, Avni Mittal, Deepanshu Dabas, Kshitij Sah et al. Benchmark scores after quantization or pruning show only the loss that reaches the output, not how much damage the rest of the network quietly compensated for. Focusing on in-context retrieval, which relies on a small set of identifiable attention heads, the authors exactly decompose the loss from ablating those heads into a part restored by other components and a part that reaches the output. For damage of comparable size, smaller models restore most of the loss while larger models retain most of it, and compressing these heads produces the same pattern. As a result, compression that is nearly harmless in small models can be costly in large ones.

arXiv:2611.07891 PDF

Same Answer, Different Future: Matched Predictions Do Not Imply Matched Belief Updating in Language Models

Weihan Li, Junhao Wu, Xinlei Chen, Tianshi Zheng Language models can arrive at the same probabilistic prediction through different routes, such as seeing outcomes, reading a summary, following an instruction, or receiving an activation intervention, but that does not mean they will update the same way on new evidence. The authors test this on a Bernoulli inference task with an exact Bayesian reference, using three open-weight models, four textual routes, and two activation-level interventions, and they measure how much each prepared belief is worth in equivalent new observations. The format of the evidence determines where it shows up: outcome sequences mostly shift next-token continuations, while summaries and stated rates mostly shift explicit estimates, and summaries get weights that scale only weakly with the number of observations they report. A steering intervention that matches a natural record's immediate prediction loses most of its effect once new evidence arrives, which shows that matching current outputs does not establish equivalent belief updating.

arXiv:2611.07913 PDF

Circe: Training-Free LLM Self-Evaluation via Component Interaction Consistency

Shuyi Miao, Zheng Li, Xu Xie, Linrui Xu, Fei Shen, Xiaoyu Du et al. Judging whether an LLM's answer is correct without a reference answer is hard, and output-only signals often score wrong answers highly. Circe is a training-free self-evaluation method that needs neither references nor repeated sampling and combines three signals into one correctness score. Component interaction consistency (CIC) measures how well attention updates in earlier layers align with the attention-driven feed-forward network (FFN) output changes in later layers, representation geometry (RG) tracks displacement and angle changes across the layer-by-layer hidden-state trajectory, and likelihood confidence (LC) turns the mean token negative log-likelihood into a bounded score. Across five LLMs and six benchmarks in four domains, Circe separates correct from incorrect responses better than existing baselines, and it generalizes to multilingual, multimodal, and open-world settings.

arXiv:2611.07948 PDF

CoRD: Coupled Rollouts Fill the Blind Spot of On-Policy Distillation

Guhan Chen, Bohan Li, Jun Rao, Hejin Wang, Songtao Tian, Yexin Xie et al. On-policy distillation trains a student model on its own rollouts, so states the teacher would reach but the student does not are rarely supervised. CoRD (coupled-rollout distillation) keeps the on-policy loss but draws rollouts from a geometric interpolation of student and teacher, using the maximal coupling from speculative decoding. The coupling keeps the student's token wherever the two distributions agree and substitutes a teacher-leaning token only where the student underweights it, so interventions fade as the student learns. Across six Qwen3 and Qwen3.5 students from 0.6B to 4B parameters, CoRD raises pass@1 by 0.9–2.0 points and pass@8 by 1.2–3.4 points on five math benchmarks at equal steps and data. On states the teacher reaches, a 4B student closes as much of the gap in 16 steps as standard on-policy distillation does not reach in 80.

arXiv:2611.07959 PDF

Learning Dynamics of On-Policy Distillation

Guan Zhe Hong, Sumeet Ramesh Motwani, Liang Chen, Yangchen Pan, Junchi Yu, Jialin Yu et al. On-policy distillation (OPD) trains a student language model on its own outputs with dense supervision from a teacher, so each update changes the data that produces the next update. The authors analyze this feedback loop in two stages: how the teacher's signal becomes parameter updates, and how those updates change predictions across prefixes and reshape later rollouts. The analysis explains why students can respond weakly despite large disagreement with the teacher, and why training can degenerate when updates that improve local agreement also make unsuccessful continuations more likely. They also find that offline distillation first can prepare a student so that OPD yields large accuracy gains, even though the offline phase barely improves held-out accuracy on its own.

arXiv:2611.08016 PDF

Can an LLM Actually Reason and Program about Neural Network's Weights or is it just memorization on steroids? Exploring "Weight-Space Programming"

Nazmus Sakib Ahmed LLMs have been reported to read and write raw neural network weights directly, and this exploratory study tests whether the reading side reflects genuine reasoning. Claude Opus 5.5 received every weight of small convolutional networks (about 125,000 parameters) as plain text, with no tools and no dataset or class names. It calculated well at the network's input and output layers, for example inferring roughly how many optimizer steps a network had taken and recovering CIFAR-10's vehicle/animal split. Its semantic judgments, however, leaned on familiar datasets: it labeled fast-food and satellite networks as CIFAR-10, and after CIFAR-10's labels were permuted, every class pair it interpreted was wrong, showing it relied on a remembered label order. The authors conclude that zero-shot weight reading is best described as local arithmetic plus dataset priors, and they propose a protocol for auditing such claims.

arXiv:2611.08070 PDF

DictLLM: Post-training Compression of Large Language Model with Dictionary Kernels

Jinho Park, Se Young Chun, Mingoo Seok DictLLM compresses a pre-trained LLM for mobile deployment without retraining. Weight matrices within groups of layers are decomposed into one shared dictionary plus sparse coefficients for each layer. The method builds the dictionaries with singular value decomposition (SVD) of input-scaled weights, sparsifies the coefficients using Hessian information, refines the dictionaries, and then quantizes both parts aggressively. It outperforms existing post-training low-rank compression methods on language modeling and zero-shot reasoning, and compresses LLaMA-7B 5.1× with only a 2.9-point increase in WikiText-2 perplexity, a 3.6× higher compression ratio than the best prior low-rank method.

arXiv:2611.08082 PDF

SAE Interprets MoE: Sparse AutoEncoders Reveal That MoE Experts Exhibit Human-Interpretable Fine-Grained Specialization

Anyuan Zhuo, Shaohua Zhang, Yuan Lin, Pinyan Lu It is still unclear what each expert in a Mixture-of-Experts (MoE) model is responsible for, and analyses that count how often experts are selected on domain-labeled data give only a coarse picture. The authors train a sparse autoencoder (SAE) on an MoE layer's output. Because that output is a router-weighted sum of expert outputs, each latent's pre-activation splits exactly across the experts, so each expert can be assigned the set of latents it mainly drives. On three layers of Qwen3-30B-A3B, contribution is far more concentrated than gating, and most latents are dominated by only one or two experts. Auto-interpretation shows specialization finer than coarse domains, such as separate experts for Java and for front-end web code, or for geometry and for arithmetic and polynomials.

arXiv:2611.08089 PDF

Signals, Evidence, and Context: User Scrutiny in Real-World LLM Conversations

Ahana Biswas, Yu-Ru Lin The study analyzes 489,283 assistant-user response pairs from ShareChat and WildChat to see how features of LLM answers relate to whether users then accept, check, or challenge them. Broad attribution language appears in 31.9% of qualifying responses, but explicit URLs appear in only 1.33%, a gap between claims of grounding and evidence a user can actually inspect. Most cues, including attribution and uncertainty, accompany both checking and challenging; only uncertainty shows a small pooled association favoring checking, and effects differ by task type. Scrutiny clusters within certain conversations, and its apparent turn-to-turn persistence shrinks substantially once conversation-level differences and response ordering are analyzed separately.

arXiv:2611.08232 PDF

AutoCompress: Automated Hardware-Guided Model Compression

Sheldon Liang, Ali Taghibakhshi, Saurav Muralidharan, Sharath Turuvekere Sreenivas, Ashwath Aithal, Pavlo Molchanov et al. LLM pruning workflows usually target parameter counts, but latency, throughput, and memory depend on the architecture, workload, hardware, and serving engine. AutoCompress builds these constraints into a differentiable architecture search, guided by serving-engine cost models validated against end-to-end measurements, and jointly optimizes global and per-layer structure to produce heterogeneous architectures. Evaluated on long-context local coding, batched datacenter serving, and latency-sensitive in-game interaction, it beats the Minitron pruning framework by 6.57, 2.35, and 0.57 points of average accuracy on RTX 5070, RTX 5080, and H100 respectively. It also compresses Nemotron 3.5 Super from 120B to 74B parameters for single-B200 serving at 128K context while retaining 95% of its mean benchmark score.

arXiv:2611.08290 PDF

Measured Coupling for Parallel Decoding in Diffusion Language Models

Tal Oved, Lior Wolf cross-listed Diffusion language models can generate several tokens per step but must decide which tokens are safe to commit together. Mean-field decoding uses prediction similarity as a stand-in for that decision. This work instead measures the coupling directly: how much committing one token changes the model's confidence at another position. It does so with cheap probes inside the existing forward pass, with no training and no extra model. Across three models and four benchmarks, the method needs far fewer decoding steps than mean-field decoding, is faster in most settings including with a key-value cache, and costs an average of 1.1 accuracy points.

arXiv:2611.08307 PDF

StrataFlux: Memory-Hierarchy-Native Low-Bit LLM Inference

Jake Hyun, Ziyu Zhao, Jae-sun Seo, Mohamed S. Abdelfattah Low-bit quantization of weights and the key-value (KV) cache shrinks LLM memory needs but costs accuracy, while offloading higher-precision data tends to stall generation. StrataFlux stores precision refinements in host RAM and on solid-state drives and streams only the selected refinements, overlapping transfers with computation and reusing them across decoding steps. With 2-bit weights and KV cache, it raises Qwen3-8B accuracy on AIME 2024/2025 from 11.0% to 47.1% at unchanged GPU memory. At 128K context on an RTX 5090, a 3-bit-weight, 2-bit-KV Llama-3.1-8B-Instruct matches the perplexity and speed of vLLM's 4-bit AWQ setup with 8-bit KV cache while using about half the GPU memory.

arXiv:2611.08363 PDF

Muir: Linear Attention with Sensitivity-Allocated Gating and Matched-Filter Readout

Tushaar Gangavarapu, Gil Tabak, Clemens JS Schaefer Linear attention models such as Gated DeltaNet-2 (GDN-2) compress context into a fixed-size state. The authors show that state updates are much less sensitive to erasure than to writes, and that slow-decaying state rows dominate readout. Muir fuses all gates into a low-rank projection sized to each gate's sensitivity, adds a matched-filter readout gate, spends the saved parameters on a wider feed-forward network, and uses a parallel update that stays numerically stable at large chunk sizes. From 166M to 1.34B parameters, it lowers perplexity by 1.8-2.0% over GDN-2 and 2.5-3.6% over Transformers. At 1.34B it extrapolates from 4K training length to 10M-token streams without perplexity drift, while matching GDN-2 throughput.

arXiv:2611.08376 PDF

Spectral and Subspace Dynamics of LoRA in Supervised Fine-Tuning and Reinforcement Learning

Chenruo Liu, Zihan Wang, Yijun Dong, Qi Lei Low-rank adaptation (LoRA) is used for both supervised fine-tuning (SFT) and reinforcement learning (RL), but how the low-rank update behaves differently in the two stages has not been clear. Tracking the singular values and subspaces of LoRA updates on math reasoning tasks, the authors find that RL concentrates the spectrum and rotates subspaces faster, while SFT spreads the spectrum. They trace both contrasts to group-mean baseline subtraction and explain the mechanism with a quadratic multi-index model. They then tailor the update for each stage, flattening the full update spectrum in SFT and flattening the out-of-span part in RL, which gives the best results in most tested settings.

arXiv:2611.08414 PDF

22 more specialized papers

Agents 60

Agent Harness Awareness: Turning Verified Telemetry into Operational Control for Tool-Using Agents

Manu Agrawal, Shrey Nagpal cross-listed Tool-using agents choose actions from tool descriptions without knowing whether a tool is currently healthy, even though the execution harness often holds that information in monitors and traces. Agent Harness Awareness addresses this by having the host give the model a small, fresh, verified state snapshot before consequential actions, while the host keeps authority over measurement, enforcement, and dispatch. On the ToolRoute benchmark across GPT-5.6 Sol, Claude Sonnet 5, and Gemini 3.7 Flash, verified tool-health state cut mean policy regret by 96.9% and raised single-dispatch completion from 69.4% to 95.8%. A live replication with OpenTelemetry traces and Toxiproxy-injected faults completed 9 of 9 cases, versus 5 of 9 without the snapshot.

arXiv:2611.05391 PDF

Challenge-Aware Knowledge Recruitment with Meta-Agent Supervision for Medical Multi-Agent Reasoning

Riccardo Riccio, Haitz S\'aez de Oc\'ariz Borde, Pietro Li\`o cross-listed On hard medical question answering, multi-agent debate often fails to beat a strong single model, partly because experts and knowledge are chosen from the question alone rather than from gaps that appear mid-reasoning. An external CHALLENGER agent inspects the evolving reasoning trace, identifies specific factual or expertise gaps, and triggers targeted retrieval or recruitment of a specialist agent. On the MedAgentsBench hard subset, retrieval during the discussion beats upfront retrieval and improves 8 of 9 datasets. Challenger-triggered specialist recruitment raises GPT-4.1-mini MedQA accuracy from 46% to 54%, but naively combining retrieval and recruitment hurts performance.

arXiv:2611.05393 PDF

SlackBench: Benchmarking Agents on Collaborative Projects Grounded in Real Code Repositories

Mingxuan Li, Huanzhi Mao, Ruitao Zheng, Jarod Stanbury James, Yunze Li, Natanya Anderson et al. cross-listed Agent benchmarks rarely capture collaborative knowledge work, where the information needed is scattered across chat threads, code, and decisions that change over time. SlackBench provides reproducible environments built from privacy-preserving reenactments of real academic research projects, with multi-party Slack-style dialogue, linked GitHub repositories, and Google Docs. Its 140 queries cover search across mixed sources, abstaining on unanswerable or false-premise questions, goal-directed summarization, and inferring circumstances from long conversations. Across 33 frontier models and agent harnesses, the best system scores about 80% and most score below 66%.

arXiv:2611.05512 PDF

Iterated creation, grading, and revision of data science projects by language models

Rohan Alexander cross-listed Seven models from Anthropic, OpenAI, Google, DeepSeek, and Z.AI each act as a 'writer' agent that downloads, cleans, and analyzes a dataset and writes a short paper. Each model also acts as a grader, and every writer-grader pair runs three rounds of grading and revision. Of 147 initial submissions, 107 ran successfully, and the average score rose from 59% to 76% after feedback, with gains by writer ranging from 3 points for Opus 5.5 to 46 points for Haiku 4.5. Models grade their own work about 9 points higher than other graders do, about half of the round-to-round change is within grader noise, and weaker models generally do not help stronger ones improve.

arXiv:2611.05548 PDF

Grounded but Not Immune: Confirmation Bias in Agent-as-a-judge

Drake Benjamin Brown, Khushbu Pahwa, Yubin Ge, Salvatore Romeo, Akhil Agnihotri, Yi Zhang et al. cross-listed Agent-as-a-Judge evaluators get tools and the agent's full trajectory so they can check results against the environment. The assumption is that gathering their own evidence protects them from bias. The authors inserted a single false pre-screening note, attributed to an authority and irrelevant to the correct verdict, and it overturned up to 40% of a tool-using judge's correct verdicts across four judges and five datasets, even when the judge had collected decisive evidence. They sort the resulting failures into over-trust, hallucinated support, and under-investigation. Over-trust accounts for 67-75% of harmful flips in the two Claude judges, and lightweight mitigations reduce the bias but never remove it.

arXiv:2611.05662 PDF

Cognitive Bias Signatures in Search-Equipped LLM Agents: A Stage-Resolved Analysis

Yanru Xiao, Yingwei Yu Adapting experiments from cognitive-bias research, the authors built a controlled search harness to test how starting conditions shape what LLM agents retrieve and conclude. They varied result order, records of prior work, and initial hypotheses while keeping each question and document collection fixed. Across 10 models and 1,000 synthetic search worlds, they tracked queries, retrieved documents, documents opened, and final answers. Final answers were more sensitive to initial evidence order during active search than when all evidence was supplied up front. Histories of dead-end prior work reduced strategy switching beyond what context length alone explains. Under wrong hypotheses, some errors persisted even after the agent had opened counter-evidence.

arXiv:2611.05720 PDF

Prospective Memory for Proactive LLM Agents

Yuanchen Bei, Zhining Liu, Tianxin Wei, Weizhi Zhang, Zhichen Zeng, Philip S. Yu et al. Most memory systems for LLM agents are retrospective. Proactive agents also need prospective memory: holding future-directed intentions and acting on them when the right opportunity arises. Pro-Memory, inspired by cognitive theories of human prospective memory, separates keeping pending intentions (linked to supporting evidence and activation conditions) from deciding when and how to act on them. It updates intention states based on actions actually issued, and an experience memory distills feedback from finished episodes into guidance. On two benchmarks covering delayed-intention tasks and open-ended proactive assistance, it consistently improves proactive task performance across multiple LLM backbones while limiting unnecessary interventions.

arXiv:2611.05731 PDF

PAYWORTHY: Can LLMs Predict Which Freelance Jobs an AI Agent Will Complete?

Mohammad Reza Rezaei, Dingxian Wang, Brett Levert, Celeste Fejzo, Andrew Rabinovich, Zhao Chen cross-listed Before an AI agent takes a paid job, someone has to judge whether it is likely to succeed. PAYWORTHY tests whether LLMs can make that call in advance, using 1,494 real freelance postings sampled from 18.8 million. In each case an agent attempts the job from the posting alone, and an LLM judge acting as the client accepts or rejects the work. Eighteen models then forecast success, and their forecasts are scored by how well they rank accepted jobs above rejected ones. When told what the agent cannot do, every model ranks well (AUC 0.66-0.86), but when told only that it is a generic agent with a browser and code execution, the same models perform roughly at chance (AUC 0.45-0.56).

arXiv:2611.05759 PDF

Learning When Human Decisions Matter: Executor-Relative Consultation Value for LLM Agents

Shuli Jiang, Khushbu Pahwa, Yuting Zhang, Yi Zhang, Wei Xia, Stefano Soatto When an LLM agent has a limited budget for consulting a human, it has to decide which decisions deserve human input. The value of that input depends on which downstream agent will act on it. Consultation Value Distillation (CVD) estimates consultation values offline using Monte Carlo rollouts of the executor agent, then distills them into lightweight predictors, so no rollouts are needed at deployment. Across five batch and three sequential settings with two frontier executors, CVD broadly outperforms direct prompting and Value of Information baselines. It stays robust with much less rollout supervision.

arXiv:2611.05814 PDF

TandemBench: Benchmarking Decision Models for Multi-Agent Collaboration

Baohang Li, Xiaocheng Feng, Bing Qin TandemBench contains 1,200 multi-agent cooking scenarios in which models receive full global information and must pick the best team plan from candidate options. Reference answers come from execution and exact search. In paired variants, models must also judge whether a better plan exists beyond the options supplied. Across 40 specialized decision models and 10 general-purpose LLMs, the best decision model reaches 62.50% accuracy, while decision models stay near chance at verifying optimality, and some claim better alternatives exist even when the optimal plan is already among the options.

arXiv:2611.05827 PDF

The Harness Is the Model: Agent Scaffolding Changes a Fixed LLM's Compliance with Banking Conduct Rules, Unevenly Across Models

Mehmet Murat Huyut Banks validate language models in isolation but deploy them inside harnesses that control what the model sees, which tools it calls, and who checks its actions. The authors run four open-weight models in five harnesses, ranging from a single structured decision to tool loops with policy search, long customer memory, or a same-model compliance reviewer, across 156 pre-registered cases in a simulated retail bank governed by paraphrased EU rules, scoring all 3,120 episodes deterministically from tool traces. Pooled results moved little (87.3% to 92.1% correct), but for one model the harness alone shifted results by 11.5 percentage points, moving it from first to last place, while the same-model reviewer cut violations from 9.6% to 6.4% without more over-refusals. Rules requiring date arithmetic failed everywhere, and 26% of violations came with a customer message denying the action the agent had just executed, so the authors argue validation should target the model-harness pair and read action logs rather than transcripts.

arXiv:2611.06116 PDF

Twists and Turns: A Graph-Based Benchmark and Framework for Long-Term Memory in Exploration Tasks

Chongyuan Dai, Yaling Shen, Zirui Song, Junfeng Liao, Jinpeng Hu, Xiuying Chen Long-running work such as research or software development follows a trial-and-error path in which approaches branch, get revised, and are later revived, but existing long-term memory benchmarks mostly test factual recall. LExMem models these exploration processes as graphs and uses an evolutionary mechanism to make them structurally more complex, producing 224 dialogues and 2,018 question-answer instances. The authors also propose LExGraph, a memory framework that incrementally organizes dialogue into interconnected memory nodes and retrieves evidence through hybrid search plus neighbour expansion. Existing retrieval and memory systems struggle on LExMem, while LExGraph performs best and generalizes to external benchmarks.

arXiv:2611.06414 PDF

EvoGuard: Mitigating Degradation in Online Skill Evolution

Yanli Wang, Zichen Bai, Tianyue Jiang, Kunming Shao, Junhao Shi, Xueqin Liu et al. Language agents can store reusable "skills" as natural-language documents and evolve them from interaction, but adopting every update online can degrade skills over time, and validating each update on a held-out set is too slow. EvoGuard trains a pairwise selector on skill pairs with clearly different measured utility. Using the logits of two label tokens, it picks the better skill in a single forward pass at deployment. Compared with adopting every new skill, it improves success by 11.0% on ALFWorld, 5.9% on ScienceWorld, and 2.7% on LiveCodeBench, at low latency and cost.

arXiv:2611.06444 PDF

ArcRAG: Agentic Compositional Retrieval over Knowledge Graphs

Jyotin Goel, Abhinav Arun, Tejas Prakash Agarwal, Bhaskarjit Sarmah, Stefano Pasquali Graph-based retrieval-augmented generation (GraphRAG) systems usually design their retrieval around the structure that their own graph-construction pipeline produces, and the authors ask whether retrieval still works when the graph is built differently. ArcRAG builds a query-local view of the graph at inference time (the node labels, relations, and property keys reachable from the entities a question names), plans multi-hop traversals against it, and executes and repairs them as Cypher queries. With its configuration fixed, it is tested on MuSiQue, HotpotQA, and TriviaQA graphs built both with a schema and with open information extraction. The results show that retrieval need not be co-designed with graph construction, although the construction method still affects absolute accuracy.

arXiv:2611.06481 PDF

SpecCompact: Accelerating LLM Agent Context Compaction with Slot-Parallel Semantic Speculative Verification

Yulu An, Yifei Feng, Xiangyang Yin LLM agents compact their growing interaction histories into summaries, but summarizing long histories with a large model adds substantial latency. SpecCompact relies on the observation that structured summary slots can be generated independently. A fine-tuned small drafter writes all slots in parallel, and the large target model verifies each proposed line and repairs rejected content. Additional system optimizations avoid reprocessing the same context. On AppWorld and τ³ with two target models, it achieves 2.04–5.63x faster compaction than Hermes-style summarization, with downstream trade-offs that vary by model and task. A user study inside Hermes showed an 8.68x median speedup.

arXiv:2611.06876 PDF

Octopus: One Brain, Many Branches for Latent-KV Multi-Agent Reinforcement Learning

Tianming Sha Multi-agent LLM systems explore in parallel by spawning sub-agents, but current frameworks duplicate prefix key-value (KV) caches across branches, share findings by re-prefilling text summaries, and lose cross-branch dependencies during reinforcement learning (RL). Octopus runs all agent threads on one shared model backbone that coordinates over a GPU-resident graph of KV states. Branches fork as zero-copy views over shared KV pages, a sibling thread's KV blocks can be mounted directly into the attention layers, and a packed DAG-GRPO trainer assigns credit to each branch by measuring how the reward changes when that branch is left out. Trained on Qwen3.5-4B, it reaches 49.6% on BrowseComp-Plus, 17.5 points above single-agent GRPO, and 51.2% on OpenResearcher, beating retrieval agents up to 250 times larger while raising training throughput 3.3 times and cutting peak KV memory 2.8 times.

arXiv:2611.06956 PDF

KDASO: Knowledge-Data Dual-Driven Automated Skill Optimization for Liability Adjudication Tasks

Zi-Jian Cheng, Weiming Wu, Jie Meng, Zhen Peng, Shan Huang, Qun Li et al. Liability adjudication tasks, such as deciding legal charges, require LLMs to check event descriptions against domain-specific executable skills. Existing skill libraries go stale, LLMs often deviate from the intended expert logic when following skill descriptions, and large libraries overflow the context window. KDASO (Knowledge-Data Dual-Driven Automated Skill Optimization) keeps the skill library evolving by inducing new skills from recent adjudication data, refining skills based on analysis of LLM execution trajectories, and routing only the relevant skills within a context budget. Across ride-hailing adjudication, legal liability, and logical reasoning tasks it outperforms general and domain-specific baselines, and it gains 8.96% when transferring skills to conceptually similar scenarios.

arXiv:2611.06972 PDF

The Two-Ledger Model: Transaction-Grain Cost Accounting for Multi-Agent AI Systems Across Clouds, Models, and Systems of Record

Vivek Acharya Enterprises run orders, claims, and cases through multi-agent AI systems spread across clouds, LLM providers, and orchestration tools, but billing data arrives only in aggregate per product and charge period, so it cannot say what one business transaction cost in AI. The proposed Two-Ledger Model joins a settlement ledger of billing data in the FOCUS format to an attribution ledger of per-call usage records built on OpenTelemetry GenAI telemetry. A layered correlation scheme (trace context, A2A and MCP protocol metadata, business keys, and probabilistic matching) assigns each call to its transaction, and reconciling the two ledgers exposes unmetered 'shadow AI' spend. In a simulation with known ground truth, cost coverage stayed above 99% even with no trace propagation, and pausing transactions mid-flight cut 99th-percentile transaction cost by up to 61% at a 2-4% false-pause rate.

arXiv:2611.06989 PDF

Autonomous AI Agents Systematically Diverge From Human Preferences in Proof Formalization

B\'alint Gyevn\'ar, Simon DeDeo As AI agents produce more formal proofs, it matters how their approach to proof-writing differs from humans'. The authors introduce 'simulated collaboration', a method that replays nine major human Lean collaborations, covering 4.7M definitions over more than 6K commits, and compares the next steps AI agents choose with what the humans actually did. The agents are far more strongly drawn than humans to explicitly marked gaps, avoid densely connected proof hubs and complex or surprising goals, and are attracted to surprising proof bodies, which they tend to rewrite toward a more conventional form. The authors frame these divergences as blind spots to address in future human-AI collaboration in mathematics.

arXiv:2611.06995 PDF

Closed-Loop Agent Evaluation: Layered Measurement and Self-Calibration

Ruifeng Ren, Gun Ahn Evaluation of deployed agents is usually one-off: a benchmark run or a single score whose conclusions are neither self-checked nor fed back to the agent. The proposed closed-loop method treats evaluation as performance estimation under biased raters and incomplete outcomes. It measures agents at four levels (span, trace, conversation, and engagement), requires every conclusion to trace back to raw data through versioned rules, and uses generated evaluator agents equipped with domain knowledge packs. An inner loop audits the evidence, rules, and metrics themselves, while an outer loop uses per-component regression checks to drive agent improvement. On the business-analysis agent SharpInsight and public conversation data, judging against evidence and explicit rules was more reliable than holistic scoring (an intraclass correlation of 0.86 versus 0.81, and kappa agreement of 0.81 versus 0.63).

arXiv:2611.07051 PDF

When Verification Is Not Agreement: Cross-Agent LLM-to-Dafny Formalization

Priyanath Maji A verified Dafny postcondition shows that a formula holds, but not that two models independently reached the same understanding of the source. In a cross-agent protocol, a Specifier model translates clinical-trial criteria into a Dafny predicate and an Implementer model writes a method checked against it; even a same-model control agrees only 59.3% of the time. Across 96 clinical-trial documents, agreement depends heavily on how capability is split between the roles: GPT-4.1-nano/GPT-4.1-mini reaches 53.0% with the stronger model as Implementer but only 14.3% when the roles are reversed. The authors also find weaker Implementers satisfying the postcondition by calling the Specifier's predicate directly, concluding that verification success alone is insufficient evidence of independent agreement.

arXiv:2611.07073 PDF

More Agents, More Reliable? System-Level Reliability of Multi-Agent LLMs under Operational-Profile Uncertainty

Burkay Tun\c{c}t\"urk, Koorosh Aslansefat, Yiannis Papadopoulos, Bao Nguyen cross-listed Teams building software from cooperating large language model (LLM) agents often assume that adding agents makes the system more reliable, but average benchmark accuracy ignores both the input mix a deployed system sees and the rule that merges the agents' answers. The authors combine HIP-LLM, a hierarchical imprecise-probability assessment of single LLMs, with a Bayesian network of the system's failure logic. Interval estimates of each agent's failure probability propagate through the network, which also models the chance that the combining rule itself fails, and the result is a reliability envelope. In a pipeline that extracts regulated chemical-hazard statements, majority voting over three models protected against the weakest model but did not clearly beat the best one, and a voter that fails on 5% of inputs would largely erase its advantage over the middle model.

arXiv:2611.07140 PDF

Multi-step SWE: Can Coding Agents Keep Building on Their Own Code Over Long Horizons?

Xiangkai Zeng, Zheng Liu, Zihao Lin cross-listed Coding-agent benchmarks usually score one isolated task at a time, while real developers keep asking an agent to extend and optimize code the agent wrote itself. Multi-step SWE has 69 tasks, each a chain of 5 to 15 dependent, multi-hour engineering steps on a single codebase, so early design choices and errors carry forward. The tasks span nine programming languages and include both from-scratch builds and existing open-source projects. Each step's instruction and verifier come from an existing source of truth. Across nine frontier models, the best solve rate is only 18.5%, and 38 of the 69 tasks are not solved by any model.

arXiv:2611.07166 PDF

SeVerus: Context-Aware, Gamified Benchmarking for Rust Verification

\'Alvaro F. Silva, Martim Afonso, Nuno Saavedra, Emily First, Alexandra Mendes, Jo\~ao F. Ferreira cross-listed Existing benchmarks for Verus, a verifier for Rust programs, usually supply the auxiliary lemmas a proof needs, while in practice those lemmas have to be discovered and proved. SeVerus turns verified open-source projects into gamified quests, each with levels that progressively remove proof context, from filling in a single missing lemma to proving the target with no supporting lemmas. An independent checker rejects changes to executable code, weakened specifications, and unsound proof constructs. Across 819 quests and 10,095 levels, tested with Codex and Claude Code, success drops and cost rises as context is withheld. The strongest agent solves the final level of 52 of 60 sampled quests but reliably solves only 35% of their levels.

arXiv:2611.07194 PDF

How Should Agents See Code? Rethinking Code Representations for Agentic Software Engineering

Melika Sepidband, Jiho Shin, Song Wang, Hadi Hemmati cross-listed Most coding agents explore a repository through raw files, text search and shell commands. The authors test whether giving the agent a queryable map of the repository helps instead. They compare five map-based workflows (abstract syntax trees, call graphs, module dependencies, documentation-enriched search, and a hybrid) against a raw-tool baseline, using Claude Code with Haiku 4.5 on LinuxFLBench, SWE-bench Pro, SWT-bench and SecBench. The maps help most when finding the right code is the bottleneck: on fault localization every workflow improves recall@10 and cuts token use by 25-39%. When the decisive step is writing a patch or a test, success rates stay close to the baseline, and some workflows increase cost and latency.

arXiv:2611.07286 PDF

Selective Retrieval Routing for Multi-Violation Knowledge Graph Repair

Tung-Wei Lin, Gabe Fierro, Han Li, Tianzhen Hong, Pierluigi Nuzzo, Alberto Sangiovanni-Vinentelli cross-listed Schema validation can detect broken facts in a knowledge graph but cannot say which of several valid repairs is the intended one. External documents can resolve this, but retrieving them is expensive and does not always help. The proposed framework pairs an LLM repair agent that edits the graph with a researcher agent that fetches outside evidence, and a learned router decides when the repair agent may consult the researcher. The router is trained on synthetic cases containing multiple injected violations. On two building-automation datasets, it used fewer tokens than always allowing retrieval in all six evaluation suites and achieved higher repair F1 than never allowing retrieval in five of six.

arXiv:2611.07342 PDF

EnvOpt: Automated Optimization for Agent Environments

Mingxuan Li, Huanzhi Mao, Qiuyang Mang, Hanchen Li, Joseph E. Gonzalez, Alex Dimakis An agent's cost and success depend on its environment as well as on the model and the harness around it, which makes shared "stationary" environments such as a company Slack workspace or document store worth optimizing. EnvOpt automatically restructures such environments for a given model and harness, using real or synthetic tasks and no graders or reference answers. On AutomationBench it cuts Claude Haiku 4.5's cost by 72.7% while raising its pass rate by 14.34%. The optimized environment transfers to Opus 5, cutting its cost by 68.1%, and stacks on top of Meta-Harness's optimized harness. Across five benchmarks, it reduces agent cost while maintaining or improving pass rates.

arXiv:2611.07372 PDF

The Last Mile to the Real World: Agent-Native Primitives as Reusable Building Blocks for Solving Real-World Tasks

Haibo Jin, Peng Kuang, Xiaopeng Yuan, Lucheng Fu, Jerry Wang, Xucheng Yu et al. cross-listed Frontier coding agents still fail many real-world tasks at what the authors call the last mile: they can reach a resource but cannot apply it correctly. They introduce agent-native primitives, reusable units that pair a resource with a resident LLM that knows how to apply it in context, and HEELO, a framework that assembles a task-specific graph of primitives, checks the result against evidence from the environment, revises the primitives a failure points to, and adds validated new ones. Across more than twenty benchmarks, primitives raise Terminal-Bench 4.0 resolution from 37.3% to 55.5% on the same backbone as Codex, ToolBench pass rate from 55.8% to 75.1%, and GAIA-Text-103 accuracy from 45.6% to 58.3%. On 46 real-world tasks, Claude Code and Codex each complete 9 tasks alone but 39 and 35 tasks when connected to HEELO through an MCP server, at lower time and cost per completed task.

arXiv:2611.07461 PDF

FINCOSMOS: An Open-World Evaluation Paradigm for Agents in Finance

Yupeng Cao, Xueqing Peng, Lingfei Qian, Haohang Li, Yangyang Yu, Anke Xu et al. Agents doing financial work on the open web can fail silently, for example by implementing a strategy the user never asked for, using unverified data, or running a backtest that leaks future information, and still produce a convincing report. FINCOSMOS is an open-world evaluation in which a simulated user holds a hidden strategy and reveals details only when asked, while the agent gets no data and must gather it from the web and build its own backtest under a data cutoff. Grading needs no reference answer: programs check point-in-time correctness, recompute every reported metric, and apply 15 veto checks. Across four coding agents and one model without tools over 150 sessions, no session was accepted, and agents asked about only 54–64% of the unstated details; an agent given persistent memory and FINCOSMOS feedback eventually learned all ten tasks.

arXiv:2611.07464 PDF

Signed but Not Safe: Requirement Integrity in Multi-Agent LLM Handoffs

Xiaobo Chen, Genliang Zhu, Ziyuan Wang, Chu Wang cross-listed When an orchestrator splits a request across subagents and merges their results, each handoff can drop or alter a user requirement. In a preregistered study, the orchestrator extracts each requirement as a verbatim quote plus a checkable predicate, signs the manifest with HMAC-SHA256, and deterministic code verifies the merge; with Qwen3-8B, signed manifests cut unsafe commits under attack from 69.4% to 9.0% compared with free-text handoffs, and the deterministic verifier outperformed an LLM checker with far fewer false alarms. Signing eliminated in-transit tampering, but a single injected line before signing raised violations sharply on Qwen3-8B, gpt-oss-20b and GPT-5.6-luna, and the signature then authenticated the corrupted manifest. The authors conclude that signing protects requirements in transit, while the extraction step remains the trust boundary.

arXiv:2611.07483 PDF

Learning Multi-Agent Orchestration:Higher-Order Interactions in Policy Improvement

Kaixuan Liu, Guojun Xiong Learned orchestrators for LLM multi-agent systems are usually trained by crediting each decision with its own advantage, which assumes the other decisions stay fixed even though each decision's value depends on earlier ones. IAPO (interaction-aware policy optimization) exactly decomposes the performance difference between two policies into individual-decision effects and interaction effects, proves that interactions can account for half of the attainable gain, and optimizes both from sampled trajectories with certified improvement at every update. On long-input versions of GSM8K, MATH, DROP, MBPP and HumanEval, compared with fifteen multi-agent and workflow-search systems on the same 7B executor, it matches the strongest system's accuracy with fewer tokens. Removing the interaction term costs 7 to 17 points of accuracy on code tasks.

arXiv:2611.07495 PDF

DelegateEval: Evaluating Platforms for Personal External Service Agents

Jichao Li, Jinrong Lu, Manjiang Yu, Zhixuan Liu The authors define personal external service agents: AI agents that an individual authorizes and manages to serve that person's clients using the person's expertise, methods, and service boundaries. They propose DelegateEval, a platform-level evaluation framework for agent systems built from large language models, reusable skills, protocols such as the Model Context Protocol (MCP), and executable tool environments. It scores platforms on eight dimensions, including ease of creation, delivery quality, expertise inheritance, service continuity, governance, and economic efficiency. Only the framework and an experimental design are presented; datasets, environments, a scoring protocol, and empirical results have not yet been developed.

arXiv:2611.07508 PDF

Evolver: Turning Agent Exploration into Evolving Capabilities

Haoyang Zhang, Qumeng Sun, Xiao Zhang, Xiang Liu, Zhidong Fan, Junjie Wang cross-listed Coding and tool-using agents learn useful procedures while exploring, but that knowledge usually stays in execution traces and is never reused. Evolver stores it as structured, reusable "Gene" assets without changing model weights, and combines experience collection, retrieval, and feedback-guided refinement on top of existing agent harnesses such as Claude Code and Codex. On a diagnostic set of 320 paired runs drawn from Terminal-Bench 2.1, SWE-bench Multilingual, SWE-rebench, and GAIA, task success rises from 83.13% to 87.50% while token consumption falls by 24.24%. Among tasks solved under both conditions, token use still drops by 17.57%.

arXiv:2611.07595 PDF

Binding Paraphrased Instructions to Encountered Objects in sLLM Agents under Partial Observability

Chanyoung Kim, Harim Song, Byoungchan Ko, Keonyoung Lee, Myungwon Lee, Dahuin Jung Small language model (sLLM) agents fine-tuned with reinforcement learning can match larger prompted models on embodied tasks, but it is unclear how well they handle reworded instructions. The new ALFWorld-Para benchmark shows 21-52% drops in success rate, driven mostly by object synonyms: agents know what a synonym refers to but fail to pick up the matching object even after seeing it. BINDIntent is a training-free fix that probabilistically links referring expressions to observed object labels using semantic similarity and an estimate of whether an unseen candidate might still appear. It raises synonym-paraphrase success by 17.5-49.1 percentage points at 0.4 ms of CPU cost per step, and lifts GiGPO-7B from 61.8% to 77.4% success, ahead of a prompted 24B model.

arXiv:2611.07599 PDF

Beneath the Surface: What We Overlook When We Talk About Agent Evolution

Xiaobo Wang, Zimu Wang, Siyu Ye, Jiaqi Li, Min Tang, Jun Bai et al. Evolving an agent's harness is promoted as a way to achieve recursive self-improvement (RSI) without updating model weights. This study asks whether the higher benchmark scores it produces reflect reliable, efficient, and transferable gains. Using repeated evaluations, component interventions, and replays across four evolution methods on general and coding tasks, the authors find that all sixteen evolved agents gain some new tasks while losing others they previously solved. Most reliability gains also raise deployment cost, the top-scoring agent never gives the largest mean improvement, and transfer to new targets is uneven. The authors fold these diagnostics into EvoAudit, a revised select, analyze, mutate, and gate loop that performs best in their setting.

arXiv:2611.07624 PDF

Don't Prompt Your Agents. Equip Them: Skillware as a Modular Standard for Sovereign, Auditable, and Deterministic Capability Execution for Logical Systems

Vladimiros Peilivanidis (ARPA Hellenic Logical Systems) LLM agents that write code, guess API payloads, and memorize operational rules through prompts use a lot of context and break in production. Skillware is an open framework and registry that packages each capability as a versioned bundle: a typed JSON input contract, deterministic Python code, task directives, bundled datasets, and unit tests. Adapters expose these bundles as native tool declarations for both cloud and local models. Across 23 models and 368 benchmark conditions, small local models (3B to 8B parameters) equipped with Skillware outperform unequipped frontier models on multi-step workflows, cutting token usage by up to 84.8%, cost by up to 97.3%, and eliminating parameter errors.

arXiv:2611.07652 PDF

Who Should Know What? Empirical Information Design for Multi-Agent LLM Economies

Mete Erdogan, Mirac Suzgun, Aneesh Pappu, Guowei Xu, Batu El, Andrew A. Schoen et al. Multi-agent LLM systems depend on information-sharing policies as well as model capability, and it is not obvious that giving agents more detailed information improves collective outcomes. The authors propose empirical information design, an experimental framework that compares disclosure policies across LLM-populated markets (multi-resource trade, bilateral bargaining and double auctions) while holding interaction rules and models fixed, and they test ten frontier LLMs against ground-truth utilities. The effect of finer disclosure depends heavily on the model: in trade, revealing exact valuations lowers GPT-6 Sol's realized gains from 98% to 91% of the maximum but raises Claude Sonnet 5's from 72% to 86%. In double auctions, full disclosure inflates price demands and causes market breakdowns, cutting welfare for Claude Opus 5.5 from 94% to 64% and for Grok 4.7 from 97% to 62%. The authors conclude that model choice and information policy must be optimized together.

arXiv:2611.07667 PDF

ReferClaw: Disambiguating User Intent for Egocentric Assistance

Hangyu Qin, Junbin Xiao, Angela Yao cross-listed Users of egocentric (first-person video) AI assistants often ask short, ambiguous questions such as "Where did I leave it?", and existing video question-answering systems commit to one interpretation that may not be the one the user meant. ReferClaw treats streaming egocentric QA as an interactive process in which three cooperating agents propose candidate interpretations, ask clarifying questions, and answer from the resolved intent and the visual evidence. A cost-aware policy weighs the expected information gain of a question against the effort it asks of the user, and the system improves from interaction through intent-specific skill updates and process-reward-guided policy optimization with agent-level credit assignment. On augmented egocentric QA benchmarks it improves answer accuracy and joint answer-and-grounding performance over baselines and transfers zero-shot across datasets.

arXiv:2611.07683 PDF

MCPHallu: Benchmarking Reasoning, Execution, and Memory Hallucinations in MCP Agents

Yizhen Jiang, Haowei Guo, Tianyi Bai, Zengjie Hu, Lu Ma, Zhengyang Zhao et al. Existing benchmarks for agents using the Model Context Protocol (MCP) mostly measure task completion and diagnose failures only after execution. MCPHallu instead builds hallucination risks into task design: 358 tasks run on 36 production MCP servers in isolated containers, and each task contains a structural trigger for one of four failure types (Branch Collapse, Unreachable Goal, Tool Misuse or Context Forgetting) across reasoning, execution and memory. Across 5,012 trajectories from fourteen frontier LLM agents, the average score was 0.642 out of 1. Failures cluster on infeasible tasks, where only 23.2% of Unreachable Goal runs pass because agents keep calling tools or falsely claim success. Model rankings shift by 6.9 of 13 positions on average across failure types, so a single aggregate score hides large differences between models.

arXiv:2611.07689 PDF

RIVER: Evidence-guided multi-agent retrieval for enzyme--reaction discovery

Yifan Chang, Yunze Li, Feifei Jiang, Juntao Wu, Xin Chen, Han Hu et al. Matching enzymes to the reactions they catalyze is hard for methods based on sequence or structure similarity, especially within families of near-identical enzymes. RIVER is a multi-agent framework that coordinates large language models, biochemical computation tools, and external databases to gather evidence on reaction chemistry, protein domains, catalytic mechanisms, and annotations, with validation modules that flag gaps and conflicts and rerank candidates using traceable evidence records. It works in both directions, finding likely reactions for an enzyme and ranking candidate enzymes for a reaction. RIVER achieves the highest success rates on public benchmarks and substantially outperforms general-purpose and biology-specialized agent systems, including Claude Code, Codex, and Phylo Max, on E. coli retrieval tasks built from recent literature.

arXiv:2611.07757 PDF

Instantiating the Knowledge Plane

Francisco Pereira, Justine Sherry, Pratiksha Thaker cross-listed In 2003, Clark et al. proposed the Knowledge Plane: intelligent agents that share information about network state to manage the Internet jointly across administrative boundaries. That technology lacked reasoning and unstructured communication, so problems spanning multiple networks are still mostly resolved by human operators on the phone. This position paper argues that agentic LLMs can finally make the Knowledge Plane workable. It also lays out new research problems that arise because the setting is decentralized, multi-agent and coopetitive, meaning the networks both cooperate and compete.

arXiv:2611.07827 PDF

CORE: Coarse-to-Fine Search with Context Management for Deep Research

Hoang Tran Vuong, Ngoc Quan Pham, Hung Bui, Fatih Porikli, Dat Quoc Nguyen cross-listed Deep research agents face a trade-off: search works best over long passages, but every returned observation stays in the agent's context for the rest of the task. CORE is a training-free harness that retrieves passages with a dense retriever and then reuses token-level similarities from a late-interaction reranker to return only the most relevant snippet from each passage. Its context management also lets the agent expand the text around sources it has already retrieved and suppresses repeated snippets. In controlled comparisons against the Tongyi DeepResearch and OpenResearcher harnesses, it achieves state-of-the-art answer accuracy and evidence recall across three agent models and three BrowseComp variants, on corpora of up to 553M documents.

arXiv:2611.07859 PDF

Persistent Retrieval for Conversational Agents: A Study of Retrieval Efficiency

Karthik Ravula, Sathwik Kowtha, Rishabh Verma, Kala Mehak Jain, Gunjit Mittal A conversational agent can run retrieval itself or hand it to a subagent, and that choice affects context size, latency, and how much must be re-retrieved for follow-up questions. The authors compare skill-based retrieval in the main agent, a non-persistent subagent that returns a synthesized findings response, and a persistent subagent that keeps retrieval history across turns, returns raw evidence to the main agent, and can be asked for corrections. On enterprise questions across five multi-turn settings, the persistent design uses 43.3% fewer agent-model tokens and 45.0% lower estimated API cost than skill-based retrieval, with 9.1% faster responses. Against the non-persistent subagent it answers 15.6 seconds faster per question but uses 65.1% more tokens and costs 29.1% more.

arXiv:2611.07899 PDF

ChemE-as-Code: An Open-Source Platform for Agentic AI in Chemical Engineering

Artur M. Schweidtmann ChemE-as-Code is an open-source environment in which LLM agents carry out chemical engineering work and engineers can check it. It provides calculation tools from catalysis and process simulation to plant layout, hazard and operability studies (HAZOP), and life cycle assessment, plus skills that tell a general-purpose agent how to use them. Engineering files are machine-readable and versioned in Git, calculations run outside the LLM with each value's origin recorded, and automated checks flag inconsistent or outdated results by file and line. In an ammonia plant case study, agents turned a written task into a preliminary basic-engineering package for USD 224 in API cost. Planted faults showed that the checks catch only what their rules cover, so they support human review rather than replace it, and no independent engineer has reviewed the design.

arXiv:2611.07947 PDF

QRAE: Query-Relevant Attention Entropy for Context Compression in DeepSearch Agents

Yingjie Tan, Haiquan Qiu, Quanming Yao, Manyi Zhong, Xianzhi Yu, Yaqing Wang DeepSearch LLM agents carry every retrieved source into later reasoning steps, which raises token use and latency even though many results are never used. QRAE (Query-Relevant Attention Entropy) compresses the context online by deciding which intact retrieved chunks should persist. It uses a small set of attention heads that assess evidence, compares runs with and without the query, and measures how broadly each chunk responds. High-scoring chunks enter the reasoning context, while uncertain ones are cached for later re-evaluation, with no extra generation pass or change to the attention operator. Across several DeepSearch benchmarks and reasoning models, QRAE raises task success by 2.35 points on average while cutting latency by about 30% and token usage by about 45%, and the gains hold for a model of nearly 100B parameters.

arXiv:2611.07976 PDF

PCBRouteAgent: How Close Are LLM Agents to Becoming PCB Routing Engineers?

Yue Zhang, Jilei Sun, Liqiang Jing, Yijie Wei, Ruohan Yang Routing complex printed circuit boards (PCBs) requires combining board-level connectivity decisions with geometric execution under strict design rules. PCBRouteAgent is a multimodal agent with two parts. A global planner reads board images and structured electrical and geometric data to set topology, routing order, corridors, and layer transitions. A detailed executor carries out the plan through KiCad's native router and returns unresolved failures as structured feedback so the plan can be revised without discarding accepted routes. On 247 boards from PCBWorld-Bench, it reaches clean-pass rates of 100%, 94.9%, 100%, and 40% across four splits, and beats the best baseline by 10 to 36 percentage points on the three real-world subsets.

arXiv:2611.08175 PDF

SMART: State-based Multi Agent Reasoning Traces for Verification-oriented Problem-Solving

Sai Vallurupalli, Francis Ferraro Verifying claims often needs background knowledge that the claim itself does not supply. SMART is a multi-agent framework that has several LLMs, prompted with structured roles, capture the implicit state of the entities involved in a problem and turn it into diverse, complementary premises that bear on the answer. Reasoning guided by these curated, real-world-verified premises improves validation performance by up to 20% on complex scientific claims across three datasets. Grounding the premises in real-world knowledge adds up to 5% on its own.

arXiv:2611.08196 PDF

Learning the Task or Learning the Verifier? Rethinking Criteria Exposure in Embodied Self-Improvement

Wenbo Huang, Jianxin Bi, Shunyu Yang, Ruiyang Si, Rui Ni, Qiang Wang et al. Several self-improving embodied agents are shown the benchmark's success criteria while learning, a practice the authors call Criteria Exposure. Those criteria often demand more than the language instruction itself. In controlled experiments with a self-improving coding agent that writes robot-control programs, exposure quickly raised success rates under the given criteria, but the advantage disappeared when the criteria were changed slightly while staying faithful to the instructions. Skills learned under exposure also transferred poorly across tasks. The authors propose instruction-faithful criteria that better reflect how well agent-generated programs actually perform.

arXiv:2611.08318 PDF

Enhancing Local and Global Structure in Compressed AI Agent Memory

Henry Han AI agents compress their stored embedding memories, and compression is usually judged by whether each item's nearest neighbours survive. However, consolidating, deleting, and comparing memories also depends on which items lie far apart. Using a local fidelity metric and a global one, the authors show that rescored binary codes keep local fidelity at 0.97 yet move 10.1% of passages to another theme. They prove a bound that links global fidelity to near-far rank violations, and they turn it into locality-aware quantization (LAQ), a hinge objective on the codebooks of an OPQ index that keeps the same storage cost. LAQ raised global fidelity in all 52 held-out runs, scales to a million passages, and preserves evidence recall.

arXiv:2611.08341 PDF

FedReason: Large Language Models as Weight-Space Meta-Aggregators for Heterogeneous Federated Learning

Ali Mohammadi Ruzbahani, Abbas Yazdinejad, Hadis Karimipour cross-listed Federated learning servers usually merge client models with one fixed aggregation rule, and each common rule is built for only one kind of client heterogeneity. In FedReason, a large language model (LLM) is called every ten rounds to inspect client weights by running code in a restricted server-side sandbox. It may score candidate rules on a small proxy set and then writes a short Python aggregation program, with FedAvg as the fallback if the program's output is invalid. With Claude Opus 5.5 on CIFAR-10 and CIFAR-100 using ResNet-18, it beat FedAvg by 1.26 percentage points on average across label-skew runs and excluded sign-flipping Byzantine clients from the first round. It did not beat SCAFFOLD, which changes client training, and a 60-round run cost about 0.79 USD in API fees.

arXiv:2611.08383 PDF

Benchmarks as Software: Terminal-Bench and the Case for Continuous Benchmarks

E. Kelly Buchanan, Crystal Zhou, Scott W. Linderman, Christopher R\'e Benchmarks for coding agents can go stale after release, as stronger models find valid solutions that verifiers reject and infrastructure changes break the assumptions built into tasks. The authors call this benchmark maintenance debt and propose a continuous-validation workflow that combines community reports, agent traces, automated oracle checks, and human-gated repairs. Applied to Terminal-Bench 2.0, it found issues in roughly 30% of tasks, and the fixes, released as Terminal-Bench 2.1, raised accuracy by over 10 points and moved leaderboard positions by up to three ranks. Wall-clock limits also matter: extending them closed a 20-point harness gap on GPT 5.4, so the authors argue resource budgets should be validated as part of the benchmark.

arXiv:2611.08417 PDF

The Power of Meta Access in the Software of the Future --- Demonstrated on LLM Chat UIs and Chat AI

Julian Kunkel, Ali Doosthosseini Chat assistants see the current conversation but not the application around it. The authors propose meta access, a structured and permissioned view of the interface itself, organized as a ladder of levels from feature tutoring up to confirmed changes and full orchestration. They argue that agentic harnesses able to change their own settings need a separate control-plane boundary, and they discuss risks around grounding, privacy, prompt injection, and trust. The Meta Chat prototype builds bounded context from summaries and settings and supports confirmed, reversible changes, and the authors argue that AI-era interfaces should expose a structured, permissioned model of their state and capabilities.

arXiv:2611.08428 PDF

ReproBridge: Building Reproducibility into ML Research Artifacts

Yubo Wang, Rui Meng, Jaehyun Nam, Tomas Pfister, Jinsung Yoon Coding agents that reproduce machine learning experiments often have to reconstruct details missing from papers and released code. ReproBridge is an agent workflow that packages recovered knowledge into refined artifacts: a cleaned codebase, environment setup, experiment launchers, and a reproduction guide. On ReproBridge-Bench, with 1,029 tasks from 36 papers and a separate auditor agent checking execution evidence, refined artifacts raise mean reproduction success from 76.4% to 92.6% and cut API spending by 19.7% across four models. The success-rate spread between models narrows from 21.6 to 3.9 points, and code and environment setup matter most in ablations.

arXiv:2611.08452 PDF

XStack: A Benchmark for ML Repo Migration

Linrong Cai, Taiming Lu, Haozhe Chen, Zhuang Liu Machine learning code mostly lives in two ecosystems, PyTorch on NVIDIA GPUs and JAX on Google TPUs, and moving a repository between them requires building and testing across both frameworks and hardware. XStack is a benchmark in which an agent receives a PyTorch repository and a clean TPU machine and must deliver a working JAX repository, graded against the source repository's published results after the authors authenticate and calibrate them. Repository-scale migration remains unreliable: Claude Opus 5 passes 75% of tasks, GPT-5.6-sol passes 45%, and every other agent tested passes at most 40%.

arXiv:2611.08472 PDF

Scientist World: Grow a Research World for AI-Scientists

Taiming Lu, Sachin Konan, Zhuang Liu Scientist World turns research papers into executable environments for AI scientist agents: an autonomous pipeline extracts each paper's open-ended research question and reproduces its proposed method as a baseline, so an agent can be scored against what the human authors achieved. The first release contains 1,000 verified environments and 6,400 hours of research traces recording ideas, experiments, failures, and successes. The authors report that frontier AI scientist agents beat the human researchers' results 74% of the time, and that training on the environments improves a small model's research ideation by 158%, bringing it level with frontier models.

arXiv:2611.08478 PDF

SwarmEvolve: Latent Agent Swarms for Evolutionary Discovery and Optimization

Qile Jiang, George Em Karniadakis LLM-guided evolutionary search improves programs for mathematical and computational problems, but it is slow because each round generates long textual chains of thought, many times over, to keep the population diverse. SwarmEvolve instead runs hundreds of low-cost agents per round in swarms that reason in latent space without decoding to text and share information by passing KV caches. A novelty filter keeps the most distinct ideas by measuring distances between agents' hidden states, and a summarizer agent combines ideas by reading the merged KV caches of a swarm. Across 21 mathematical discovery and scientific computing problems it achieves the highest average score and reaches in a median of 3-8 minutes the best scores other state-of-the-art frameworks reach in 60 minutes; on several problems, SwarmEvolve running Qwen3 8B improves on solutions first found by AlphaEvolve with frontier LLMs.

arXiv:2611.08483 PDF

4 more specialized papers

Other 50

Unlocking Turing Tensor Cores: A Measured Throughput Account of From-Scratch Pre-training on a Single 22G RTX 2080 Ti

Dezhou Shen cross-listed The RTX 2080 Ti's driver throttles FP16 Tensor Core throughput, and a kernel module called turing-unlock lifts the limit, reportedly raising cuBLAS FP16 matrix-multiply throughput from 55.7 to 91.4 TFLOPS. The authors measure what this means for real from-scratch pre-training of five sizes of Chinese encoder-decoder models on a single 22GB card. The gain grows with matrix size: +11.8% tokens per second for the 75.7M-parameter model, +4.7% for the next size down, and essentially nothing for the three smallest. Peak memory and final quality metrics stay unchanged, so the speedup does not alter training dynamics.

arXiv:2611.05419 PDF

The Male Abstraction Bias in Internet Culture and Large Language Models

Douglas Guilbeault, Bhargav Srinivasa Desikan cross-listed Using about 40,000 single-word and 67,000 multi-word concepts, measured across billions of words and millions of images from the internet, the authors test whether gender and conceptual abstraction are linked. They find that more abstract concepts are systematically more associated with men, a pattern that replicates across languages and extends to grammar: verbs and adverbs are both more abstract and more male-coded. The bias also appears in free associations produced by humans and by AI models in controlled online tasks. The authors argue that this single structure accounts for a range of stereotypes, such as framing women as embodied and emotional and men as rational and competent.

arXiv:2611.05730 PDF

Big Models, Small Gains: Frozen Forecasters as Classifiers on MONSTER

Rishit Jain, Rishit Kar, Chetashri Bhadane, Nilesh Patil Forecasting foundation models are increasingly used as frozen feature extractors for time-series classification, and it is unclear whether their pretraining helps beyond what the architecture alone provides. The authors benchmark Reverso and Chronos-Bolt on six large datasets from the MONSTER benchmark with 1%, 10%, and 100% of the labels, against four established classifiers and against random-weight copies of the same models. Pretraining beats the random-weight versions on five of six datasets by up to 23 points, but the frozen features never beat the strongest non-pretrained baseline: they lose in 15 of 17 settings and tie in the other two. Restoring amplitude information closes part of the gap, while fine-tuning and forecast-error features do not, so the authors recommend strong task-specific baselines and random-weight controls whenever foundation models are evaluated this way.

arXiv:2611.06988 PDF

TrustMix: Graceful Degradation for Pretrained Models under Distribution Shift

Juliusz Ziomek, Maike Osborne, Yee Whye Teh Neural networks extrapolate outside their training domain according to assumptions that are left implicit in their architecture. TrustMix is a post-hoc method that blends a pretrained model's predictive distribution with a user-specified fallback distribution, shifting toward the fallback as an out-of-distribution (OOD) deviation statistic grows. It requires no retraining and works for both regression and classification. Tested on tabular, image (including CIFAR-10/100 and ImageNet), and language tasks, it stays competitive in-distribution while improving likelihood and calibration under distribution shift. It also serves as a useful surrogate model for Bayesian optimization.

arXiv:2611.07206 PDF

KOSMOS: Self-scheduling Persistent Kernels for Communication-Compute Overlap

Alexander Magro, Aristotle Martin, Ye Wang, Wen Chen cross-listed Tensor, sequence and expert parallelism put collective communication on the critical path of transformer layers, and existing fused kernels with fixed roles or predetermined communication-compute splits leave GPUs idle. KOSMOS is a library of self-scheduling persistent kernels whose workgroups switch between communication and computation as data becomes ready, using queues ordered by consumer demand, with no central scheduler, cost model or tuned split. It fuses every tensor- and sequence-parallel collective in a transformer layer with its matrix multiply, and runs a whole expert layer in one kernel launch per direction. On AMD Instinct MI350X and MI355X GPUs, it speeds up Megatron-LM training by 1.10–1.28x and accelerates DeepSeek-V3 and Qwen3-235B proxy training by 1.29–1.83x over DeepEP.

arXiv:2611.07477 PDF

ZYFA: Speed and Accuracy of FP8 FlashAttention on AMD CDNA4

Quentin Anthony, Ganesh Bikshandi, Praneeth Medepalli, Stephen Ebert cross-listed FP8 matrix instructions double peak throughput over BF16, but attention gains little from them: the softmax between its two matrix multiplications runs on vector units that FP8 does not speed up, and AMD's MI355X lacks hardware tracking of matrix-instruction completion, so overlapping the softmax with the matrix multiplications depends on instruction order. ZYFA is a set of FP8 prefill attention kernels that compute each FP8 probability with a multiply-add and an integer conversion instead of an exponential, use a ping-pong schedule in which one thread group runs its softmax while another runs its matrix multiplications, and scale probability blocks by a power of two before rounding to reduce error. On attention inputs captured from real models, it reaches 1.16-1.76x the throughput of AMD's AITER kernels, and 1.99x on DeepSeek-style multi-head latent attention benchmarks, with 62-78% lower numerical error than AITER at head dimension 128. The authors also note that the GPU's sustained clock speed depends on operand values, so benchmarks on random inputs do not reliably predict throughput on real activations.

arXiv:2611.07496 PDF

When, Where, How: Active In-Context Learning for Tabular Foundation Models

Christian M. M. Frey Tabular foundation models adapt to a new task only through the labeled rows in their context, so choosing which rows to label matters when labels are expensive. The authors study how the value of diversity, uncertainty and target-aware selection changes as a frozen model acquires more context. They introduce a target-aware nearest-neighbor rule (TANN) and Expected Predictive Information Gain in Context (EPIC). Across twenty benchmarks, diversity works best early on and target-aware selection matters substantially. EPIC retains on average 80-87% of chance-corrected full-data performance with only 5-10% of the pool labeled, and its chosen labels also improve gradient-boosted trees.

arXiv:2611.07886 PDF

Performance metrics in machine learning: a scenario-based guide from the confusion matrix to calibration, regression and uncertainty

Mehmet Baygin, Sengul Dogan, Turker Tuncer This tutorial shows through controlled scenarios how the same predictions can lead to different conclusions depending on class prevalence, decision thresholds, how results are aggregated, and software conventions. It maps 22 confusion-matrix metrics by their dependence on prevalence and works through 15 scenarios covering classification, calibration, regression, and uncertainty, varying one factor at a time from fixed released inputs. Examples include a rule that always predicts negative reaching 0.990 accuracy but only 0.500 balanced accuracy, and precision falling from 0.889 to 0.008 as prevalence drops, with sensitivity and specificity held fixed. A goal-based metric table and a reporting checklist are included.

arXiv:2611.08048 PDF

Gabor Gabor: E-Gaborformer, a Strictly Causal Speech Recognizer with Gabor-Dictionary Convolutions and Delta-Rule Memory

Nir Krakowski, Tamir Cohen, Ohad Zohar, Chen Zarfati Real-time voice agents need a speech recognizer that never waits for future audio and whose memory does not grow with call length. E-Gaborformer is a strictly causal encoder that combines Gated DeltaNet-2 recurrent layers with sliding-window attention in a 3:1 ratio, and it builds every temporal convolution from a fixed dictionary of causal Gabor atoms. This keeps streaming state at about 19 MB per call, while a causal-attention encoder of the same size passes 1 GB after ten minutes. A 0.6B-parameter Hebrew and English streaming transducer built on it achieves 28 to 31% lower word error rate than NVIDIA's Nemotron 3.5 ASR Streaming on English voice-agent traffic, and a two-class formulation of the RNN-T loss trains the transducer 2.6x faster with exact loss and gradients.

arXiv:2611.08092 PDF

How Far Can Untrained Neural Networks Go in Anomaly Detection? From Tables to Pixels

Hyojun Yi, Geunyoung Kim, Hogeon Seo, Seunghyoung Ryu Anomaly detection is usually treated as a representation-learning problem, but the authors test how far untrained neural networks can go. PRISM combines fixed random nonlinear features with Mahalanobis-distance scoring against normal reference data, in variants for tabular data and for pixel-level visual localization. With no weight optimization and no pretrained features, PRISM-T reaches the highest mean AUROC (86.4%) across 47 ADBench tabular datasets, and PRISM-V reaches 90.4% image-level and 96.4% pixel-level AUROC on MVTec AD and VisA. The authors propose it as a pre-learning baseline for measuring what learned representations actually add.

arXiv:2611.08136 PDF

40 more specialized papers

Theory 45

Who Pays for the Knowledge Models Copy? Model Collapse as Rogers' Paradox

Nam H. Le cross-listed Generative models trained on earlier models' outputs lose knowledge over generations, rare knowledge first, and existing theory treats the fresh data that counters this as a fixed external supply. The authors recast model collapse as Rogers' paradox from cultural evolution, in which a population that relies on copying ends up no better off than one that never copied unless some members keep learning for themselves. Rogers' model, fitted only to fully synthetic training, predicts within a few percentage points how much rare knowledge models from word trigrams to a pretrained transformer retain under other data mixtures, and it correctly predicts that a changing world demands more fresh data. When people can ask the model instead of finding things out, the equilibrium model is only as reliable as it is costly for people to learn for themselves; users who verify and relearn break the paradox, while plausibility filters accelerate collapse.

arXiv:2611.06022 PDF

Optimistic Hedge in General-Sum Games: Fundamental Limits and Regret Bounds via Temporal Approximation

Yuval Dagan, Nadav Eisen, Liad Erez, Tomer Koren Optimistic Hedge, a multiplicative-weights algorithm with one step of extrapolation, was known to achieve horizon-independent regret in general-sum games, but whether that bound could be polynomial in the game's size was an open question. The answer depends on the number of players: in two-player games a suitable learning rate gives O(n log n) regret independent of the horizon, where n is the number of actions. With three or more players no such bound exists: the authors construct games where some player's regret is exponential in n, and grows linearly in the horizon for larger learning rates. The upper bound comes from a temporal approximation framework that also gives a much simpler proof of a recent bound for m-player games.

arXiv:2611.07078 PDF

Calibrated Target Noise Recovers Curvature from the Gradients

Arash Jamshidi, Katsiaryna Haitsiukevich, Aristides Gionis, Kai Puolam\"aki Optimisation preconditioning, sampling and early stopping all need curvature information, which is hard to get when only aggregate mini-batch gradients are available. The authors show that injecting zero-mean noise into the training targets, with variance calibrated to the local output curvature, makes the covariance of the resulting noisy batch gradients recover practical curvature matrices without per-sample gradients or second derivatives. For a broad class of non-linear models the scheme recovers the Generalised Gauss-Newton (GGN) matrix, and for feed-forward ReLU networks it also recovers the diagonal blocks of the population Hessian. The authors prove the estimator is optimal, and experiments show accurate curvature recovery, faster optimisation when it is used for preconditioning, and useful early-stopping signals.

arXiv:2611.07671 PDF

Masked diffusion as random sequential adsorption: an exactly solvable model for parallel decoding

Adrian Baule cross-listed Masked diffusion language models can reveal many tokens at once, but tokens revealed together are sampled independently, which introduces error. The authors map this trade-off onto the statistical physics of driven many-particle systems and show that the error of parallel generation equals the entropy production of the generation process. For Markov data they solve generation exactly as random sequential adsorption. For many steps, the error becomes the dissipation of a slowly driven system, and optimal unmasking schedules are geodesics of a closed-form metric derived from the mutual information between tokens. The exact solution shows that longer-range correlations concentrate error at the start of generation, so schedules that begin with small steps give lower error and perplexity.

arXiv:2611.07845 PDF

How Finite Brains Generalize Without Bound: Spatial Memory as a Universal Computer

Yuhang He, Si Wu LSTMs and Transformers trained on short sequences fail on longer ones, while children who learn small-number addition can add numbers of any length. The author argues the difference lies in what the learner reads: values such as positions or counts keep taking unseen values as inputs grow, whereas same-or-different coincidences do not, so a learner that reads only coincidences has its rule fixed by finite experience. The theory says such a memory must be built from cycles and maps them onto grid cells, place cells, and the hippocampal index, with a prefrontal controller. It also claims this setup can compute what Turing machines compute in step with their input. Trained on strings of up to 40 symbols, the resulting machine is at least 99% correct on lengths 41 to 500 on nine of fifteen benchmark tasks, five of which no LSTM or Transformer solves, and given new cycles after training it reverses strings of 15,015 symbols without error.

arXiv:2611.07920 PDF

BUMP: Brief Unexpected Mid-Interpolation Peak

Melinda Fl\'ora Kiss, M\'arton Muntag, Adri\'an Csisz\'arik, D\'aniel Varga When linearly interpolating between two permutation-aligned neural networks, test accuracy briefly rises near the endpoints before falling toward the midpoint. The authors name this effect BUMP (Brief Unexpected Mid-interpolation Peak) and find it is consistent across datasets, architectures, and training regimes, and robust to early checkpoints and extreme pruning. Ablations suggest it is not a trivial regularization effect. Building on it, they propose an ensembling scheme that mixes in both weight space and prediction space, which consistently beats standard logit ensembling in test accuracy and gives a better calibration trade-off.

arXiv:2611.08182 PDF

First-Token Attraction in Mamba Dynamics

Trinh T. Nguyen, Minh-Khoi Nguyen-Nhat, Duy-Tung Pham, Hoang-Son Do, Tan Minh Nguyen, Thieu N. Vo Interactions between tokens in Mamba models use full matrices with no positivity guarantees, so techniques built to analyze attention do not carry over. The authors build a new framework, based on a high-dimensional invariant box and an exit-time argument, that characterizes where token trajectories end up and proves exponential convergence rates. The analysis shows that the first token's limiting direction attracts later tokens, which produces token clustering and attention-sink behavior. The same mechanism extends to other state-space models, causal attention, and classical time-series models. Experiments on Falcon-Mamba-7B confirm that concentration on the first token grows with depth.

arXiv:2611.08303 PDF

Unifying Central Flow, Rod Flow, and the Edge Coupling

Eric Regis, Sinho Chewi cross-listed At the edge of stability, gradient descent oscillates along sharp directions of the loss surface, which ordinary gradient flow cannot capture. Two continuous-time models, central flow and rod flow, were proposed to describe this regime. This work derives both from a single object, the edge coupling, a functional whose critical points are the fixed points and period-two orbits of gradient descent. In this view, rod flow averages over only the fastest time scale, while central flow also averages over an intermediate one. The framework also yields rod and central flows for heavy-ball momentum and Adam, and experiments show these flows track real training through the transition into the edge of stability.

arXiv:2611.08358 PDF

37 more specialized papers

Safety & Alignment 41

Same Origin, Different Verdicts: Text Production Conditions Confound Machine-Generated Text Detection in Russian

Stanislav Kirichenko The authors test whether machine-generated text detectors measure a text's origin or merely its production conditions. They use a 1,882-document Russian corpus in which the same model writes for the same task and only the task wording changes. Four detection procedures were applied: an interpretable pre-specified index, a trained classifier, a zero-shot metric, and an LLM judge. Changing the task mode shifted all four scores, but in conflicting directions: three moved negative and the judge moved positive, and no interval included zero. A baseline using only the source identifier reaches a median AUROC of 1.0, and removing emphasis markers alone flipped a confident machine verdict to human, which suggests detector scores reflect corpus construction and formatting as much as authorship.

arXiv:2611.05385 PDF

How Far Can You Steer? Behavior-Capability Frontiers in Contrastive Activation Addition

Deepanshu Raj cross-listed Contrastive Activation Addition (CAA) steers language-model behavior by adding activation directions derived from contrasting examples, but it can degrade unrelated capabilities. The authors frame steering as a behavior-capability frontier, choosing interventions that maximize behavioral gain under an explicit capability-loss budget of 1%, 3%, or 5%, and evaluate it across four instruction-tuned models and seven behaviors. Behavioral effects selected on validation data generalize well to held-out data (ρ = 0.945), and the share of operating points that keep both the behavior gain and the capability limit rises from 37.5% at a 1% budget to 72.7% at 3%. However, interventions that pass protected benchmarks can still degrade untested capabilities or transfer unevenly to free-form generation, so steering behaves as a constrained intervention rather than a universal control knob.

arXiv:2611.06001 PDF

Reconciling Privacy with Provenance for Language Model Watermarks

Elise L. Han, Tatsunori Hashimoto cross-listed Language-model watermarks face user resistance because fine-grained tracking feels like a privacy violation, which encourages evasion such as paraphrasing. The authors reframe the goal from identifying individual texts to estimating aggregate usage, and design locally differentially private watermarks that provably limit how much evidence any single text contributes while still allowing accurate population-level frequency estimates. Their Red-Green Sequence (RGS) watermark is computationally efficient and, on C4 language modeling, achieves 0.0019 mean squared error at a strict privacy level of ε = 1. Even on an essay task with only 100 samples, errors stay around 0.0113 mean squared error at ε = 2.

arXiv:2611.06100 PDF

Mass Producing Training Data with Surprising Side Effects

Yaowen Ye, Jacob Steinhardt, Sarah Schwettmann, Cassidy Laidlaw Training data can change language-model behavior far outside its domain, as when insecure code induces broad misalignment, but only a few dozen hand-found examples of such datasets exist. The authors automatically generate datasets with surprising side effects (DSSEs) that elicit a target behavior, read like ordinary post-training data, and would surprise a human auditor, scoring each property with LLM judges and searching via evolution, reinforcement learning, and subliminal learning. The pipeline yields 6,575 such datasets across 8 behaviors, many of which generalize across model families and sizes. The automated metrics track ML researchers' judgments, and frontier models predict side effects better than humans, giving a testbed for anticipating training side effects before deployment.

arXiv:2611.06324 PDF

Does Context Compression Preserve Refusal Alignment?

Anthony Nguyen, Wenjun Lin cross-listed Context compression lowers inference cost by encoding inputs into compact representations, and the open question here is whether preserving meaning is enough to preserve safety behaviour. The study finds that encoder-based compression systematically weakens refusal behaviour in instruction-tuned models despite high reconstruction fidelity, and the effect holds across model families and compression architectures. Mechanistic analysis shows that compression weakens activation along the decoder's learned refusal direction. A lightweight inference-time fix called Memory Steering works entirely in the compressed representation space and restores refusal rates to near-baseline levels without retraining.

arXiv:2611.06380 PDF

When Do Summaries Become Instructions? Unsupported Policy in LLM Agents' Self-Written Handoff Summaries

Wenhui Chu Long-running LLM agents compact their context into handoff summaries, and this study checks whether those summaries invent permissions or restrictions that the record does not support, and whether this changes what the next agent instance does. Using synthetic tool-use tasks with a ground-truth permission ledger, plus replays in which suspect sentences are replaced with neutral filler, the authors find unsupported restrictions in 1.2–2.4% of summaries and unsupported authorizations in 0.1–1.3%. Neutralizing false approvals cut unauthorized actions from 24 to 7 of 120 held-out runs, though that analysis was post hoc. In pre-specified tests, rewording the system prompt to say where approval requirements come from cut unsupported restrictions from 1.8% to 0.3% of summaries on held-out templates, without reducing legitimate approval requests.

arXiv:2611.06545 PDF

Measuring Risk, Not Harm: Detecting Psychological Harm Risk Factors in LLM Conversations

Nil-Jana Akpinar, Eugenia Kim, Natalie Isak, Amanda Minnich, Victoria Westerhoff, Matthew Dressman Psychological harm from large language model (LLM) interactions can emerge gradually and depends on each user's context, so it is hard to measure directly. The authors instead detect eight observable AI behaviors that are risk factors for harm, scored per response and aggregated for longitudinal monitoring. They build a synthetic corpus of 47,062 labeled responses and compare embedding classifiers, direct LLM judging, and a cascade that combines a classifier with a judge. The best cascade reaches a macro F1 of 0.79 on held-out human-labeled data. On WildChat, it cuts LLM-judge calls by 97.1% compared with judging every response directly.

arXiv:2611.06806 PDF

Before You Continue: Evaluating Time-Sensitive Safety Awareness in Conversational Assistants

Peidi Dong, Yunze Xiao, Yu-Lin Tsai, Yichen Zheng, Heyuan Huang, Weihao Xuan et al. LLM assistants often help with everyday tasks that involve time-dependent constraints, and users may not restate those constraints in later requests. TASC (Temporal Action Safety in Conversation) tests whether assistants apply such constraints, using 3,418 inputs from 128 templates plus 33 scenarios that separate computing elapsed time from acting on it. Across 13 models, assistants account for the constraint in only 30.5% of cases where the proposed action violates a rule, while rarely issuing unnecessary warnings. Models fail to apply the constraint in 62.1% of cases even after correctly computing the elapsed time, and stating the timing explicitly fixes only about half of these failures.

arXiv:2611.06839 PDF

Persona Perspectives: Adopting Viewpoints Reorganizes Representations in LLMs

Austin C. Kozlowski, Avital Mintz, Madison Lee Monitoring tools such as linear probes and sparse autoencoders (SAEs) assume that features keep the same representation across contexts. The authors test this by prompting models to adopt liberal or conservative personas and measuring how more than 9,000 words project onto 33 semantic axes. Persona conditioning systematically reshapes the representational geometry in directions that match the assigned ideology. As a result, truthfulness and morality probes, SAE-based classifiers, and word-based classifiers trained without a persona give politically slanted ratings on controversial statements when applied to models with a persona. This suggests that conventionally extracted features may be unreliable monitoring tools when a model takes on a persona.

arXiv:2611.06848 PDF

Interactive Backdoor Attacks in LLM-Based Proactive Dialogue Systems

Zhiyang Xia, Yuming Shang, Xi Zhang cross-listed LLM-based proactive dialogue systems guide users toward goals over many turns, and fine-tuning them on externally supplied dialogue data opens the door to backdoor attacks. Previous LLM backdoor work mostly triggers a single attacker-chosen response, whereas this framework poisons training data so that a trigger in an ordinary user utterance steers the entire following multi-turn conversation toward an attacker's objective, with no prompt changes or further attacker action at deployment time. Three variants are studied: an immediate response deviation, a progressive attack along a predefined multi-turn path, and an unconstrained attack across open-ended user continuations. In psychological-counseling experiments on two LLM backbones and two datasets, all three attacks reached their objectives while largely preserving normal utility, the tested training-data filters kept nearly all poisoned dialogues, and three post-training defenses left substantial attack success.

arXiv:2611.06969 PDF

Trust Responsive Runtime Authorization for Agentic AI with Empirical Characterization of Policy Behavior and Parameter Sensitivity

Ahsan Habib Shihab, Imre Felde, Ramis Akhmedov, Stefan Gubo, Berik Sabdenaliyev, Madina Mansurova et al. Autonomous agents are often monitored at runtime, but the policy that turns those readings into how much authority the agent gets is rarely specified or measured. The Trust Responsive Authorization Policy (TRAP) combines trust, stability, and contextual risk into an Authorization Readiness Score and applies an asymmetric rule: escalating authority requires several consecutive high readings, while a sharp drop restricts it immediately. On 100 Monte Carlo traces it restricts at the onset of abrupt degradation and recovers faster than a symmetric policy, but when degradation is gradual it keeps authority above what readiness supports for roughly 16-19 of 20 degraded intervals, so its advantage depends on degradation being abrupt.

arXiv:2611.06996 PDF

Adapting the Process of Adaptation: Darwinian, Lamarckian, and Agent-Directed Evolution in AI

Andrew W. Lo, Chaoyi Zhao A theoretical framework compares how quickly three kinds of evolution adapt after an environmental change: Darwinian evolution through natural selection, Lamarckian evolution that adds inherited learning, and agent-directed evolution, in which AI agents generate and evaluate their own behavioral variants and choose how widely to search. When learning is effective enough, each mechanism adapts faster than the one before, and the best amount of search depends on learning ability, problem difficulty, and the cost of experimenting. However, when the evaluation target is misspecified, more search speeds convergence toward the wrong behavior even as measured performance rises, and such errors can persist across generations of recursive self-improvement. The authors conclude that independent evaluation and oversight must keep pace with autonomous AI development.

arXiv:2611.07048 PDF

Shaping & Monitoring Models through their Internal Representations

Thomas Fel, Matthew Kowal, Matt Feiszli, Satchel Grant, Andrew Lee, Chris Earls et al. Mechanistic Shaping is a training-time framework that uses a model's internal representations to enforce rules about which concepts it expresses (for example, no harmful content) and which concepts it relies on (for example, not using gender when screening résumés). Across vision, medical imaging, and language, at up to 32B parameters and with classification, SFT, DPO, and GRPO training, it substantially reduces targeted behaviors while preserving task performance. Because training against a representation can change it, the authors introduce a hierarchy of monitor classes and identify three ways a concept can evade a probe: drifting away from it, being erased from the layer, or persisting as a nonlinear encoding. In practice, shaped concepts largely remain monitorable, since refitted linear probes recover them in most settings.

arXiv:2611.07071 PDF

Compositional Unalignment: Auditing Safety in Large Vision-Language Models

Hong kyu Lee, Kai Shu, Li Xiong Large vision-language models (LVLMs) can be pushed into harmful output by an image and a prompt that are each benign on their own. Strong scores from an LLM judge on compositional safety benchmarks do not show how robust that safety actually is. The authors find that recognizing compositional harm and refusing it are decoupled inside the model, and they propose CMaG, a training-free un-alignment method that takes the gradient of a refusal-versus-compliance margin at mid-layer activations to find a steering direction from a single backward pass over 80 examples. On Qwen2.5-VL-7B and LLaVA-1.5-7B, it lowers compositional safety scores by up to 65 points while more than 98% of outputs stay coherent, and the direction also un-aligns models that were hardened with defensive training.

arXiv:2611.07216 PDF

SPILLWAY: Separating Target Admission from Sanitization to Defend Tool-Using Agents against Prompt Injection

Woosang Lim (SAINT Machines, KAIST), Yeseul Chang (Chung-Ang University), Jaewoo Lee (Chung-Ang University) cross-listed Tool-using agents can be hijacked by instructions hidden in web pages or documents, and many defenses rely on a language model that may itself read the attacker's text. SPILLWAY adds a deterministic check: an action is allowed only if every target value (such as an email recipient or payment account) that is not in the user's task came from a typed field returned by a read-only tool, or is covered by a fixed delegation rule. A rule-based sanitizer strips instruction-like text before the model sees it, and a local judge may restore a refused call but never one whose target came from the removed text. Across three backbone models and seven task suites, no standard templated injection redirected an action to an attacker's target, and attack success against a reinforcement-learning attacker averaged .007, with almost no extra model calls and the highest utility among the defenses tested.

arXiv:2611.07222 PDF

Reweighting is not Harmless: Understanding the Role of Dataset Characteristics

Amalia Ionescu, Jose G. Hernandez, Emily F. Wong, Anil K. Saini, Jason H. Moore, Tiffani J. Bright Reweighting training data is a common way to improve fairness, but its effects depend on group sizes and how common the predicted event is in each group. Across 3,000 simulated datasets, reweighting improved parity in false negative rates largely by making predictions worse for the group with higher baseline prevalence. When that group was a minority, its false negative rate rose by 6 percentage points, and about three-quarters of the parity improvement came from this increase rather than from gains for the other group. The pattern held across six classifiers while overall accuracy stayed flat, so the harm is invisible in aggregate metrics.

arXiv:2611.07258 PDF

When Scores Conflict with Preferences: Pre-Alignment Diagnosis and Adaptive Correction of Constraint Drift in DPO

Ping Liu, Yan Yan Direct Preference Optimization (DPO) is often run on data where pairwise preferences coexist with pointwise criteria such as length, correctness or safety. Pairs whose preferred answer scores worse on the pointwise criterion push that criterion in the wrong direction, a failure the authors call constraint drift. They derive a closed-form diagnostic, $\rho^{*}_{\mathrm{eq}}$, computed from dataset statistics before training, that predicts whether a dataset will self-correct or needs intervention. The diagnostic's decision matched the observed drift on every domain tested. Their method, Conflict-aware DPO (CoDPO), down-weights conflicting pairs and adds an adaptive margin, reducing drift while largely preserving preference learning.

arXiv:2611.07375 PDF

Adversarial Multiplicity: Cherry-Picked Models and the Limits of Disclosure

Cassandra C. Chou, Benjamin Q. Huynh, Allison Koenecke, Elizabeth T. Chin Predictive multiplicity means that equally accurate models can disagree on individual predictions, and the authors study how motivated parties, including coding agents gaming their objectives, can exploit this in disputes involving automated decisions. They distinguish soft manipulation, which searches over innocuous choices like hyperparameters, from hard manipulation, which edits model parameters directly. A flexible enough model can be hard-manipulated to reverse any individual prediction while passing black-box audits. Soft manipulation has smaller effects but can pass white-box audits, and even aggregate estimates, such as climate change's effect on wildfires, can be reversed. The authors map which manipulations would survive current regulations and recommend mitigations such as pre-registration and proof of training.

arXiv:2611.07378 PDF

SAVeR$^2$: Reasoning-based Safety Alignment for Large Reasoning Models via Verifiable Rewards

Yichen Sun, Qirui Liu, Yan Wang, Jianan Lin, Linbo Jiang, Shiyu Wang et al. Large reasoning models (LRMs) that reason through explicit chains of thought introduce new safety risks, and existing alignment methods generalize poorly to adversarial inputs, hurt reasoning ability (a "safety tax"), and rely on coarse rewards. SAVeR² breaks the safety objective into four fine-grained verifiable reward signals covering non-malicious reasoning and answers, safety consistency and explicit intent identification, and it uses difficulty-aware data selection to stabilize training. A reasoning-preserving gradient projection resolves conflicts between safety and reasoning gradients analytically. On models from 1.5B to 671B parameters, the authors report stronger safety and lower over-refusal without losing general reasoning ability.

arXiv:2611.07482 PDF

The Memory Trap: Language Agents Overgeneralize from Benign Interactions

Kaiqu Liang, Jaime Fern\'andez Fisac, Thomas L. Griffiths, Andrew Lampinen cross-listed Language agents that keep persistent memory across sessions can overgeneralize from entirely benign past interactions, a failure the authors call the memory trap. Across six frontier models, including Claude Sonnet, Opus, and Fable models and GPT-5.6, a request to skip confirmation on low-stakes coding chores led agents to skip confirmation and verification on simulated high-stakes tasks. Memories from emotional-support conversations biased later judgments of math, arguments, and poems toward sycophancy or over-criticism. Notes from legitimate stale-test repairs led agents to weaken correct tests and increased cheating on ImpossibleBench, more so for stronger models, and the authors show that the overgeneralization can arise both when memories are written and when they are acted on.

arXiv:2611.07554 PDF

Stress Testing Chain-of-Thought Monitoring Against Covert Misalignment

Yao Huang, Yifan Wang, Yitong Sun, Yichi Zhang, Yinpeng Dong cross-listed Chain-of-thought (CoT) monitoring reads an agent's reasoning to catch hidden misaligned objectives, but existing red-teaming tests it with templated side tasks that are easy to spot. TraceMRT is an automated red-teaming framework that recasts the side task as a coherent sub-goal of the main task and searches for strategies that produce reasoning traces that look like natural execution. Black-box attacks with it reveal substantial vulnerabilities in state-of-the-art monitors, including GPT-5.2 and Claude-4.5. As a defense, the authors propose Bayesian Trajectory Monitoring, which combines global context with local segment evidence and reaches 0.91 AUC and 0.74 true-positive rate at a 5% false-positive rate.

arXiv:2611.07586 PDF

Embedding-Space Fingerprinting of LoRA Fine-Tunes: Recovering the Training-Data Domain from the Model Artifact Alone

Shivesh Rane The study asks whether a LoRA (low-rank adaptation) fine-tune reveals what kind of data it was trained on, using only the released artifact. The authors trained 36 fine-tunes of Qwen3.5-0.8B on 18 public datasets spanning five domains, extracted features from weight deltas, activations on fixed probe inputs, and generated text, and evaluated them with a pre-registered leave-one-dataset-out protocol. The training domain can be identified well above the 20% chance level: 64% from generated text alone and 61% from activations, but only 42% from weight statistics, which contradicts the pre-registered hypothesis that weights would carry the most signal. The results hold across independent data subsamples and LoRA ranks from 8 to 64.

arXiv:2611.07610 PDF

Beyond Instruction Override: Benchmarking Indirect Prompt Injection with Task-Tampering Attacks

Rongting Zhang, Martin Bertran, Sandeep Avula, Chia-Jung Lee, Vanessa Murdock cross-listed Most indirect prompt-injection (IPI) benchmarks test planted instructions that redirect a tool-using agent to a new task, but attackers can instead tamper with the outcome of the task already under way, for example by citing a false refund policy. The authors define an injection by authority: content attacks when it tries to influence a decision its source is not authorized to make. They build 90 validated cases across three tool-use environments, with attacks targeting six parts of the agent's decision making, from its objective to its beliefs about the current state. A detection-and-removal defense cuts objective-targeting attacks to 2.4% success but leaves state-targeting attacks at 12.1%. A tool-policy defense allows 15.4% success, close to the 17.0% with no defense, which suggests that existing evaluations overestimate how much these defenses cover.

arXiv:2611.07640 PDF

An Information Bottleneck for Post-hoc Memorization Mitigation in LLMs

Dina EL Zein, Shashi Kumar, James Henderson Large language models (LLMs) can memorize and reproduce copyrighted training text, and the authors ask whether this can be reduced without retraining the model. They insert a nonparametric variational information bottleneck (NVIB) between a frozen LLM backbone and its language-modeling head, compressing the final hidden representations so that general linguistic knowledge passes through while highly specific memorized sequences are filtered out. In experiments on extracting book passages and on standard language-modeling benchmarks, the plug-in layer substantially reduces extractability while keeping benchmark performance competitive, and the approach does not depend on the underlying architecture.

arXiv:2611.07669 PDF

Scaling Laws for SAE Training Data

Nikita Koriagin, Nikita Balagansky, Daniil Gavrilov Storing model activations is often the bottleneck when training sparse autoencoders (SAEs) for interpretability, so the authors study how many unique activations are needed under a fixed training budget. Quality improves quickly as the activation buffer grows, then plateaus, and beyond that point replaying the buffer works nearly as well as fresh data. They fit a scaling law for this tradeoff between diversity and repetition and validate it across Llama-3.1 layers, Qwen3 sizes, BatchTopK, TopK, and JumpReLU SAEs, and math and Python code data. The resulting rule, pick the smallest buffer that reaches the plateau and replay it, cuts activation storage by 8–64× with negligible quality loss.

arXiv:2611.07756 PDF

Decodability Is Not Validity: Evaluating Nuisance Sensitivity in Language Model Concept Probes

Ayal Klein cross-listed Concept probes read a concept such as sentiment from a language model's hidden states, but equally accurate probes can also pick up a correlated nuisance attribute to very different degrees. The authors test this in four target-nuisance settings drawn from CEBaB, BiasBios and Amazon reviews, using two LLMs. They measure nuisance sensitivity both statistically and with counterfactual input edits that are checked by LLM judges and compared against placebo edits. Probes with statistically equivalent held-out AUROC (area under the ROC curve) differed up to several-fold in nuisance sensitivity, and decodability was not a reliable guide to it. The effect comes from correlations in the probe's training data, and choosing probes with nuisance-aware diagnostics reduces it at a small cost in accuracy.

arXiv:2611.07805 PDF

A Behavioural Framework for Predicting and Understanding Loss of Control in Frontier Artificial Intelligence Systems

Yao Huang, Yichi Zhang, Yifan Wang, Yitong Sun, Haoyu Dong, Jifan Ma et al. Frontier AI systems now run over longer horizons with less human oversight, so failures that put them beyond human control may only become visible once they are hard to contain. The authors split loss-of-control risk into three factors: misaligned motive, harm-enabling capability, and monitoring evasion. They measure these through 13 aspects and 29 evaluation tasks, which combine into a single loss-of-control (LoC) score. Across 13 frontier models, the score predicts failure rates in contained long-horizon risk scenarios with Pearson r = 0.84, and capability alone does not explain the risk. Fine-tuning and monitoring aimed at each model's diagnosed weak points lowered failure rates while largely preserving general performance.

arXiv:2611.07953 PDF

Should We Pay This Much for Robustness? Efficient Proxy Certificates with Marginal Guarantees

Soroush H. Zargarbashi, Mohammad Sadegh Akhondzadeh, Aleksandar Bojchevski Robustness certificates such as randomized smoothing prove a classifier's prediction will not flip under small input changes, but they can need around 2000 forward passes per input. The authors hand certification to a cheap proxy function and tune it with robust conformal risk control on unlabeled calibration data. This bounds the marginal false-approval rate, meaning the chance across future inputs that the proxy approves an input whose prediction actually flips. The proxy can serve as a standalone certificate, or as a fallback that calls the expensive certificate only when the proxy rejects. As a standalone certificate, it cuts test-time cost to a single forward pass while keeping much of randomized smoothing's certified performance at small radii, which makes certificates practical for vision transformers and language models.

arXiv:2611.08035 PDF

KeHoSu: Keyed Homoglyph Substitution for Authenticated Text Provenance over Copy-Paste Channels

Andrei Alexandru Dr\u{a}ghici, Sediola Ruko, Briland Hitaj, Dorjan Hitaj cross-listed When LLM-generated text spreads by copy-paste, document metadata is lost but Unicode code points survive. KeHoSu (keyed homoglyph substitution) uses look-alike characters to embed a keyed identifier in the text, with each carrier letter encoding one bit of a platform field, a user field, and a truncated authentication tag. Because the mark carries no positional state, it survives sentence reordering and partial quotation, and the authors characterize the channel's capacity, how easily it can be removed, and how easily it can be detected. The mark survived copy-paste across 18 common platforms and attributed most excerpts to the correct account from about 170 letters, roughly one or two sentences.

arXiv:2611.08046 PDF

A Generative Model of Contextual Integrity: Appropriate vs. Inappropriate Information Sharing

Omer Ebead, Claude Formanek, Joel Z. Leibo Contextual integrity (CI) holds that whether sharing information is appropriate depends on context-specific norms. The authors build a generative model of CI from simulated conversations in which two LLM-played actors interact, one holding private information and the other seeking it. They vary the situation, the holder's decision logic and disposition, and the underlying model. Actors shared information with rightful recipients when it was needed, but also disclosed it to people who were not entitled to it, and the framework lets researchers study how disclosure and refusal develop over a conversation.

arXiv:2611.08284 PDF

Understanding AI from the Inside: The State of Mechanistic Interpretability for AI Safety

Fazl Barez, Tung-Yu Wu, Hunar Batra, Gabriele Dominici, Florent Draye, Yanai Elazar et al. cross-listed The survey asks whether understanding how neural networks work internally actually makes them safer. It covers the foundations of mechanistic interpretability, including features, polysemanticity, and circuits, and reviews methods for feature extraction, circuit discovery and causal verification, natural-language explanations of internal representations, learning dynamics, and training-data attribution. The authors propose a unified framework for evaluating interpretability claims, describe six research orientations, and assess how interpretability supports editing, steering, and monitoring, along with its limitations. They also release code notebooks that reproduce key findings from the surveyed methods.

arXiv:2611.08438 PDF

Towards interpreting any residual stream direction by scaling activation inversion

Celeste De Schamphelaere, Juan J. Vazquez, Ari Spiesberger, Tom\'a\v{s} Gaven\v{c}iak, Gavin Leech, Euan Ong et al. Interpreting a direction in a language model's residual stream usually means finding text that strongly activates it, but scanning a corpus can only find what that corpus contains. The authors train Maximally-Activating Example Metamodels (MAEMs), language models that take a residual stream direction and generate text exemplars that activate it. Training uses a label-free reinforcement learning objective that maximizes the cosine similarity between the target direction and the activations of the generated text. A Qwen3.6-27B MAEM inverts held-out activations better than corpus search or a natural-language autoencoder (NLA) and activates 89% of held-out sparse autoencoder (SAE) features; it also recovers LoRA backdoor payloads more often than corpus search, and every exemplar can be checked with a single forward pass on the subject model.

arXiv:2611.08465 PDF

9 more specialized papers

Vision 20

WeLM-Image: A Unified Image Generation Model towards Visual Intelligence

Canmiao Fu, Chen Li, Guohui Zhang, Hao Lu, Hongyang Wei, Huadong Wu et al. cross-listed WeLM-Image is a single image foundation model for text-to-image generation, instruction-guided editing and multi-reference synthesis, built for single-GPU deployment in WeChat. It processes text, reference images and target latents as one sequence. Its Mixture-of-Transformers (MoT) backbone shares attention but keeps separate parameters for understanding and generation, each path with Mixture-of-Experts (MoE) layers, for 31.7B stored and about 5.4B active generation parameters. Generation and editing are optimized separately with rubric-based rewards and then merged through distillation. The 1536-resolution model ranks first among evaluated open-source models on PRISM-Bench, Qwen-Image-Bench and UnicBench, and a distilled Turbo variant generates a 1024×1024 image in about 5 seconds on one H20 GPU.

arXiv:2611.07392 PDF

FisherDistill: Diffusion Distribution Distillation via Closed-Form Fisher Critics

Mahesh Bhosale, Yuanhao Zhai, Siwei Lyu, Junsong Yuan, David Doermann, Defang Chen cross-listed Diffusion models distilled to generate images in one or a few steps still lag behind their multi-step teachers, and current fixes add a trained adversarial discriminator to close the gap. FisherDistill replaces that discriminator with Fisher linear discriminant analysis. It computes the means and covariances of real and generated samples in the frozen teacher's feature space and derives a closed-form direction that best separates them, which then serves as an extra training signal. Across several distillation frameworks, this consistently improves image quality over the distilled baselines and closes much of the gap to adversarially refined models, without a discriminator training loop.

arXiv:2611.07604 PDF

PlayGen2: Learning Real-Time Playable Worlds with Explicit 3D State

Jihai Zhang, Yuhan Zhou, Junyou Li, Deheng Ye, Qi Dou, Yu Cheng cross-listed World models that feed their own generated frames back as state struggle to keep space and time consistent during long interactive play. PlayGen2 separates learned 3D state from rendering. It keeps a persistent world memory of a volumetric occupancy grid plus 3D states indexed by entity identity, learns action-conditioned dynamics within a local region, and uses a separate neural renderer to draw first-person frames from depth and semantic projections. Using Doom as a testbed, it learns geometry-aware player motion and interactions with non-player characters, and it runs at about 160ms backend latency on a MacBook Pro with an M4 Pro chip. It also works zero-shot on unseen maps, supports multiplayer by composing single-player models, and allows programmable gameplay through rule-based edits to the state.

arXiv:2611.07867 PDF

Beyond Quadratic Attention: Separable Gaussian Operators for ODE Vision Transformers

Carlos Boned Riera, David Romero Sanchez, Oriol Ramos Terrades SSoG replaces dense self-attention in Vision Transformers with a learned mixture of axis-factorized Gaussian kernels, reducing per-layer cost from quadratic to subquadratic in token count. With fixed kernels the operator is globally Lipschitz continuous, which guarantees a unique solution for continuous-depth (Neural ODE) variants, something dense attention does not provide in general. On CIFAR-100 at 224×224, it improves Top-1 accuracy by 2.2–4.1 points with 8.8–16.6% fewer parameters, and by 5.4–8.1 points in a looped-Transformer setting. At 1024×1024 inputs, the continuous-depth version reaches up to 154% higher throughput and over 60% lower peak memory than dense attention.

arXiv:2611.08236 PDF

16 more specialized papers

Multimodal 18

Modality-Aware Expert Pruning for MoE-Based Multimodal Large Language Models

Donggeun Kim cross-listed In Mixture-of-Experts (MoE) multimodal LLMs, expert weights make up over 90% of model size, and existing pruning methods score expert importance the same way for vision and text tokens. MAEP (Modality-Aware Expert Pruning) is a training-free method that splits importance by modality in a single forward pass. It uses a metric for how much the MoE output changes when an expert is removed, and it treats low-attention vision tokens as a pruning signal and text-side importance as a signal to keep. On three models, including InternVL3.5-30B-A3B and Qwen3-VL-30B-A3B, it beats modality-agnostic baselines on most multimodal benchmarks and saves about 27 GB, so a roughly 58 GB model fits on a single 40 GB GPU.

arXiv:2611.05927 PDF

LongBanana: An Expert-Verified Benchmark for Long-Context Multi-Reference Image Synthesis

Haoxiang Cao, Yuxuan Zhang, Penghui Du, Bo Li, Jiajiong Cao, Yingying Fan et al. cross-listed LongBanana is an expert-designed, expert-verified benchmark for composing one image from many reference images. Models must retrieve scattered visual evidence, reject distractors, and bind entities and their relations. It has 90 tasks, each with about 32 reference images, and 4,670 atomic checklist items derived from an entity-relation graph. The checklist scores content fidelity, relational binding, and global constraint satisfaction, and double-labeled items show 89.4% exact agreement. The accompanying LongBanana-Gen framework shows that even minimal agent harnesses beat direct generation. A ReAct-Plan-Exec-Reflect workflow adds further gains that depend on the harness.

arXiv:2611.06856 PDF

PSGAgent: Enhancing MLLMs' Dynamic Visual Perception for Panoptic Scene Graph Generation via Agentic Reasoning

Qingyun Liu, Yuankun Liu, Jiaye Feng, Jie Huang, Zonghong Dai, Haochen Li et al. cross-listed Multimodal large language models (MLLMs) applied to panoptic scene graph generation (PSG) see each image at a fixed resolution, so they miss relations involving small or peripheral objects and confuse ambiguous predicates. PSGAgent wraps the model in a think-act-observe loop with two tools: a Region Zoom-In Tool for inspecting local areas and a Visual Highlight Tool that segments the relevant objects and filters out distracting context. Training starts with a cold-start stage on an error-aware multimodal chain-of-thought dataset, followed by reinforcement learning with a hierarchical reward and Group Sequence Policy Optimization (GSPO) to teach adaptive tool use. The authors report state-of-the-art results on the PSG benchmark for both holistic and fine-grained scene understanding.

arXiv:2611.07408 PDF

CST-Bench: Benchmarking Counterfactual Spatial Transition Reasoning with Causal Transition On-Policy Self-Distillation

Ying Li, Yongle Cheng, Jing Li, Xingquan Cai, Yawei Luo Spatial-reasoning benchmarks for multimodal large language models (MLLMs) mostly test static scenes, not how a scene changes when objects are moved or swapped. CST-Bench contains 7,082 counterfactual examples covering 6 intervention types and 12 transformation operators, with dense causal annotations such as affected relations, expected effects, and invariant relations. Experiments show that post-training methods that help ordinary spatial reasoning can still fail under counterfactual interventions. The authors also propose CT-OPSD, which uses the annotations to guide a teacher model's causal reasoning chains and distills them into a student that reasons only from real observations, as an initial demonstration of using the benchmark for training.

arXiv:2611.07541 PDF

TACT-KV: Tri-Axis Cosine Transform for Compressing Volumetric KV Caches in Medical VLMs

Chongyu Qu, Ritchie Zhao, Yufan He, Dong Yang, Zhengyi Lu, Junchao Zhu et al. cross-listed Vision-language models (VLMs) that read 3D CT or MRI scans produce tens of thousands of vision tokens, so their key-value (KV) cache quickly exhausts GPU memory. TACT-KV is a compression method that needs no calibration data. It applies a separable 3D discrete cosine transform to the cache along all three anatomical axes, gives more bits to high-energy frequency bins through reverse water-filling, and quantizes each bin with a fixed scalar codebook. Across six medical VLMs and two 3D CT benchmarks it has the lowest 1-bit prediction-flip rate on eleven of twelve model and dataset pairs, and the advantage carries over to four general-purpose VLMs on video tasks. With the same high-bandwidth memory, it allows up to 8x larger decoding batches on a single GPU.

arXiv:2611.07593 PDF

The Geometry of Simulated Perspectives: Dissociating Representation and Behaviour in a Multimodal Language Model

Mathis Immertreu, Fitim Abdullahu, Thomas Kinfe, Claus Metzner, Helmut Grabner, Patrick Krauss et al. The study examines how persona prompts reshape the internal representations of the multimodal model Qwen3-VL-8B-Instruct when it rates the visual interestingness of images. Across 100 images and 53 prompting conditions, which vary both persona content and the wording used to introduce it, the authors record ratings and layer-wise hidden states. Early layers mainly encode image identity, while persona-specific structure emerges in later layers. Prompt framing changes internal representations more than persona identity does, but persona content has the larger effect on judgments, showing that representational distance does not necessarily track behavioral relevance.

arXiv:2611.08262 PDF

12 more specialized papers

Reinforcement Learning 18

What Does Multi-Turn Reinforcement Learning Really Improve in LLM Agents?

Kejian Zhu, Zhuoran Jin, Shangqing Tu, Tianyi Men, Yupu Hao, Jiachun Li et al. cross-listed The authors study what multi-turn reinforcement learning (RL) actually improves in LLM agents, measuring performance across sampling breadth and interaction depth with a Pass@(K,T) metric. They find that the advantages of trajectory-level RL depend on generous turn budgets and shrink sharply when budgets tighten. Agentic RL also does not uniformly improve single-step decisions; its gains come mainly from error recovery and resilience over long horizons. To reduce this budget dependence, they discuss process supervision and introduce BudgetMix RL, which varies interaction budgets during training and performs robustly across execution settings.

arXiv:2611.06483 PDF

Cooperative Multi-Agent Reinforcement Learning via Epigraph-Form Guided Exploration

Sungil Son, Hoseong Jung, Dahyun Oh, H. Jin Kim In cooperative multi-agent reinforcement learning (MARL), intrinsic exploration rewards help agents discover coordinated behavior, but adding them naively to the team objective can distort learning and hurt task performance. EFXPLORER instead maximizes exploration subject to a constraint that preserves established task performance, solving the problem through an epigraph reformulation that yields adaptive exploration budgets and keeps intrinsic and task rewards separate. It also adds a successor-distance-based intrinsic reward to encourage diverse, temporally extended exploration. The method outperforms strong baselines and induces novel cooperative strategies across the SMAX, VMAS, and MPE benchmark suites.

arXiv:2611.07066 PDF

Teaching Agents the "Principle", Not the "Reward"

Shan Yang The authors argue that reinforcement learning agents struggle in complex tasks because they must work out the designer's intent from long sequences of noisy scalar rewards, which they call the reward decoding burden. They propose prescriptive policy learning (PPL), which teaches agents higher-level principles of behavior instead, such as keeping balance, accumulating energy, or landing smoothly. Selected key quantities and references tell the agent at every step whether it is following each principle and to what degree. In their experiments, agents learn good policies without any reward, beat reward-based methods with far fewer samples, and transfer directly to harder settings.

arXiv:2611.07130 PDF

MAC-v2: Long-horizon model-based value expansion from pixels

Kwanyoung Park, Sergey Levine Long-horizon model-based value expansion is hard in pixel-based offline reinforcement learning (RL) because errors in both the learned representation and its dynamics compound over imagined rollouts. MAC-v2 trains a latent world model without pixel reconstruction, learning representations from prediction and control objectives, and uses action chunking to reduce the number of recursive model predictions. It performs strongly against model-free and model-based offline RL baselines on OGBench (visual), MMBench2, Robomimic, and LIBERO-10. Ablations indicate that long-horizon expansion, action chunking, and the latent objectives are each essential.

arXiv:2611.07245 PDF

Permanent and Transient Representations for Continual Reinforcement Learning

Nishanth Anand, Doina Precup Continual reinforcement learning agents face a trade-off between adapting to new situations and retaining what they already know. Earlier work split the value function into a slow permanent component and a fast transient component, but both used the same features. The authors argue that the permanent component should use parametric representations for broad generalization and the transient component non-parametric ones for situation-specific adaptation. They introduce a non-parametric approximation for the transient value function. The method supports online learning and outperforms competitive baselines on image-based tasks and Craftax-Classic.

arXiv:2611.07327 PDF

Monotone Viability Learning for Offline Safe Reinforcement Learning

Ziqian Wang, Zhen Zhang Offline safe reinforcement learning has to estimate long-horizon safety from a fixed dataset, and learning Hamilton-Jacobi (HJ) viability sets in that setting tends to be numerically unstable. MoViL (Monotone Viability Learning) learns viable sets through a monotone finite-horizon set recursion with binary supervision. This keeps a fixed target scale across horizons and avoids the attenuation that discounting causes, and the authors prove that it converges to the infinite-horizon viability kernel. The learned sets are used to certify actions at deployment. On safe RL benchmarks, MoViL meets the average cost constraint on every task while reaching state-of-the-art reward-cost trade-offs and the lowest average cost of the compared methods.

arXiv:2611.07616 PDF

Measuring the Marginal Value of Verifier-Based RL Beyond Supervised Fine-Tuning

Amit Sagtani, Saloni Garg Reinforcement learning from verifiable rewards (RLVR) is usually assumed to add value on top of supervised fine-tuning (SFT). The authors measure that added value directly on gpu-train-debug, a deterministic benchmark of 1,877 synthetic GPU and LLM training-failure diagnosis tasks. SFT on 1,200 demonstrations nearly solved the benchmark, while pre-registered GRPO training on top added no detectable in-distribution gain (+0.22 points, confidence interval spanning zero) and only a small gain under distribution shift (+0.33 points). The errors SFT leaves behind are mostly systematic and repeat identically across samples, which likely leaves GRPO with little within-group learning signal. The full study cost $8.69 of compute and can be reproduced from archived artifacts.

arXiv:2611.07639 PDF

AttnSR: Attention Step Reward for Long-Horizon Agentic RL

Mengsong Wu, Tianchen Zhou, Zhaochen Su, Zhenhua Liu, Zhe Cui, Aimin Zhou Reinforcement learning for long-horizon LLM agents usually rewards only the final outcome, which gives little signal about which intermediate steps mattered. AttnSR assigns step-level rewards by tracing backward through the policy model's own attention during training replay to estimate how relevant each earlier step was to the final response, so it needs no separate reward model and no extra rollouts. The terminal outcome, compared against a running baseline, decides whether those steps are reinforced or penalized. With Qwen2.5-7B-Instruct, it beats the PPO baseline at every checkpoint on ALFWorld, raising held-out success from 91.2% to 97.1%, and on ScienceWorld it improves every checkpoint while using 29.9% fewer environment interactions.

arXiv:2611.07932 PDF

The Blindfolded Controller: Decision Model-Guided Training for Reinforcement Learning

Muhammad Ibrahim Khan, Aniket Dixit, Faizan Ahmed, James Brusey Reinforcement learning (RL) agents learn slowly in tasks with sparse rewards and hard exploration, while decision models (DMs) given a text description of the environment and task can act well immediately but cannot improve from reward. Decision Model-Guided Training (DMGT) uses a DM to initialize the RL policy, so the agent reaches the goal and collects reward from its first episodes and RL then improves past the DM's level. Across seven tasks, DMGT outperforms plain RL on all seven and the DM alone on five. Ablations produce practical guidelines for how to describe an environment and task to a DM.

arXiv:2611.07934 PDF

Detecting Silent Faults at the Environment-Trainer Boundary in Reinforcement Learning

Zuo Gou, Chenhao Lu cross-listed Robot reinforcement learning increasingly runs environments in a separate process, machine, or language from the trainer, and many faults at that boundary raise no error. On Pendulum, HalfCheetah, Hopper, and Pusher, the authors injected up to 23 faults into the data crossing the wire. Unless every value was corrupted, learning-curve checks caught at most one run in ten, and comparison with fault-free seeds caught at most 21%. Final policy scores mostly looked normal too, even though the runs ended with different weights. By contrast, a step ledger kept on both sides of the boundary and compared step by step caught and located every fault that crossed it, at a median 3% training-time overhead on Pendulum. The authors list such faults found in practice, including in Gymnasium 1.3 and five multi-agent libraries.

arXiv:2611.08144 PDF

FewStepRL: Fine-tuning Few-step Diffusion Models with Reinforcement Learning

Haitao Lin, Minsi Ren, Yang Li, Xingtong Ge, Zheyuan Hu, Peiyan Hu et al. Reinforcement learning (RL) post-training of diffusion models is expensive because each iteration rolls out a many-step sampler. Few-step models are cheaper, but they predict an average velocity over an interval, while existing RL objectives assume an instantaneous velocity. The authors adapt RL objectives to few-step models in three phases: they re-express each objective in x-space, decompose its gradient into a self-regression toward a reference plus a reward augmentation, and compute the anchors from the few-step model. This yields few-step versions of FlowGRPO, AWM, DiffusionNFT, DiffusionOPSD and ReFL in one codebase. Reward-gradient methods work best when the reward is differentiable and its gradient is affordable; otherwise DiffusionNFT-style methods generally reach high rewards in relatively few iterations, and extra inference steps show no systematic aggregate benefit.

arXiv:2611.08240 PDF

Accelerating Safe Reinforcement Learning with Massive Parallelism

Joonyoung Lim, Younghwan Yoo Massively parallel reinforcement learning runs many environments with short rollouts, which conflicts with constrained Markov decision processes (CMDPs) whose safety constraints are defined over full-episode costs. The authors model staggered environment resets as a phase-mixture distribution over short segments. From this they derive a phase-aggregated estimator that reconstructs episode-level costs, and they add a constraint-tightening scheme that accounts for finite-sample uncertainty and distribution mismatch. In an MJX-based Safety Gym, the method matches the performance of non-parallel safe RL while substantially reducing wall-clock training time.

arXiv:2611.08273 PDF

RM-VLM: From Natural-Language Task Descriptions to Vision-Grounded Reward Machines

Roko Parac, Christos Ziakas, Leo Ardon, Alessandra Russo Reward machines encode non-Markovian reinforcement learning (RL) tasks as automata, but they need a hand-built labelling function to decide which propositions hold in each observation. RM-VLM has a large language model (LLM) generate the reward machine from a natural-language task description, and a vision-language model (VLM) serves as the labelling function on image observations. A VLM-based value estimator tracks progress toward each transition to produce dense rewards. Across grid-world navigation, robotic manipulation, and 3D object collection, RM-VLM consistently achieves higher task success than existing VLM-based reward methods.

arXiv:2611.08308 PDF

Discovering Learning Rules that Shape Others

Hong Jun Lee, Ziyan Wang, Jun Wang, Stefanos Leonardos, Yali Du Opponent-shaping methods such as Learning with Opponent-Learning Awareness (LOLA) and Model-Free Opponent Shaping (M-FOS) can steer self-interested learners toward cooperation in general-sum games, but at deployment they need access to the opponent's parameters, policy, rewards, or learning rule. DUOS extends meta-learned update rules in the style of DiscoRL to multi-agent settings. It meta-trains a rule that maximizes lifetime return using only the agent's own experience. The discovered rule shapes opponents without reading their policies or parameters, and it ranks first in normalised mean score and in self-play among tournament entrants.

arXiv:2611.08335 PDF

Unpacking the Compute Efficiency of Strong-to-Weak OPD against GRPO

Zeyu Leo Liu, Yang Li, Bo Pang, Emre Can Acikgoz, Xuan-Phi Nguyen, Anurag Koul et al. On-policy distillation (OPD) trains a student on its own outputs with token-level supervision from a frozen teacher. The authors test whether this denser signal saves training compute compared with GRPO (Group Relative Policy Optimization), a reinforcement learning method. With an external post-trained teacher, OPD generally loses to GRPO in accuracy per training FLOP and often inflates response length. When the teacher is the student's own GRPO checkpoint, however, OPD recovers that checkpoint's accuracy with 50 times fewer FLOPs, and multi-teacher OPD that merges per-domain GRPO experts matches joint GRPO on a two-domain mix with 42.0% less total compute.

arXiv:2611.08453 PDF

3 more specialized papers

Robotics 17

When Does Test-Time Search Help World Action Models? An Empirical Audit of Candidate Selection and Simulator Integrity

Jun Liu, Dajie Sun, Zhenglun Kong, Zhenjiang Fan, Peiyan Dong, Fan Yang et al. cross-listed World-action models increasingly spend extra inference compute on test-time search, and this pre-registered audit checks whether that actually helps on Cosmos Policy with the RoboCasa benchmark. On clean data, a learned value selector does 1.66 percentage points worse than random selection, and even a hindsight oracle gains only 1.40 points, because 82% of states yield identical outcomes across candidates, leaving little room for selection to help. Token pruning cuts per-forward compute by up to 47% but delivers at most a 1.15x end-to-end speedup. The authors also find and fix a silent rendering corruption that becomes more frequent on compute-heavy planning paths, and argue that test-time scaling should be judged on decision signal, realized efficiency, and evaluation integrity rather than on success rate alone.

arXiv:2610.41970 PDF

Efficient Diffusion Policy Fine Tuning with Latent Noise Representation Bridging

Yuanchu Liang, Yue Yang, An-Chi He, Hanna Kurniawati cross-listed Fine-tuning pre-trained diffusion and flow policies for robotics with reinforcement learning (RL) is expensive, and methods that adjust only the initial noise suffer from 'noise aliasing,' because values in noise space do not map naturally onto values in action space. The authors define a Latent Noise Linear Markov Decision Process (LNL-MDP) and derive a Bridge Equation that aligns the two spaces through a shared representation, with near-optimality guarantees. Their algorithm, LARBRID, learns this representation to steer the initial noise distribution and achieves 2-3x performance increases on robotic locomotion and manipulation tasks.

arXiv:2611.07275 PDF

How do Transformers Perform Low-Level Control In-Context?

Ebonye Smith, Aidan Andrews, Phoenix Wilson, Alexis Frias, Ayush Pandey, Gireeja Ranade The question is whether a Transformer can control an unstable nonlinear system it has never seen, given only that the system belongs to a known family and a context trajectory of the system moving without control input. A multi-head, GPT-2-style model is trained on expert controller trajectories for the cartpole and two-link acrobot systems, with expert trajectories unavailable at inference time. The authors identify training techniques that are essential for this kind of low-level control. They show that in-context control works, generally improves with longer context, and generalizes to stabilizing out-of-distribution systems.

arXiv:2611.07291 PDF

Concertina: Embodying Manipulation and Cognition in One Diffusion Vision-Language Model

Chengcheng Wang, Wei He, Wenhao Li, Hongguang Li, Kai Han, Jianyuan Guo et al. cross-listed Most vision-language-action (VLA) robot policies attach a separate action mechanism to a vision-language model, either discretizing actions into tokens or adding a dedicated action-expert network. Concertina instead generates continuous actions inside a shared diffusion vision-language backbone: each control timestep becomes one continuous latent token, and action blocks are reconstructed with the same corrupt-and-reconstruct operator used in multimodal pretraining. Action-specific projections make up only 0.21% of the 4.46B-parameter model, compared with 16.5-35.1% dedicated action-expert capacity in other continuous VLAs. It reports 98.15% average success on LIBERO, 85.9% on LIBERO-Plus, and an average completed chain length of 4.142 on CALVIN ABC-D.

arXiv:2611.07513 PDF

GraspBench: Execution-Aware Cross-Robot Evaluation of 6-DoF Grasp Generation in MuJoCo

Abdul Basit, Bibek Poudel, Muhammad Shafique cross-listed Grasp generators that output 6-DoF (six degrees of freedom) grasps are usually judged by grasp scores or single-robot demos, which says little about whether a specific robot can actually execute them. GraspBench is a controlled MuJoCo protocol that runs complete pipelines through robot-specific inverse kinematics, motion planning, and a fixed approach, close, and lift sequence. It covers six pipelines, four robot embodiments, and five objects, for 3,240 evaluations in total. GraspGen has the highest success rate at 73.1%, ahead of EconomicGrasp at 63.5%. GPG produces the most candidates but succeeds only 44.3% of the time, showing that results depend jointly on generator, robot, scene, and execution protocol.

arXiv:2611.07651 PDF

Energy-Aware Open-Vocabulary Detection Scheduling for Low-Power Robotic Autonomy

Abdul Basit, Muhammad Shafique cross-listed Open-vocabulary object detection (OVD) lets robots search for objects named at run time, but running it at a fixed rate wastes embedded compute on low-value frames. The authors build a scheduler that uses odometry, map changes and detector confidence to switch YOLO-World-S between low-, mid- and high-power modes on a Jetson Orin Nano, and evaluate it in 40 real navigation trials on an AgileX LIMO robot. The scheduler completed 8 of 10 missions against 7 of 10 for each fixed-rate baseline, and cut the detection call rate by 34.0% while lowering mean Jetson input power by 5.2% relative to an 8 Hz baseline. Total mission energy was not always lower, because longer missions can cancel out the instantaneous power savings.

arXiv:2611.07663 PDF

Seeing Beyond the Next Step: World-Model-Guided Human-Like Navigation in Multi-Agent Scenes

Seong-Eun Hong, JuYeong Hwang, Jinhyun Kim, Hanyoung Jang, HyeongYeop Kang cross-listed Navigating among crowds requires anticipating the consequences of an action, such as drifting onto a road or cutting through a group, but running a world model at every decision step is too slow for deployed systems. The authors use world models only at training time, as preference oracles: one predicts nearby social dynamics and one predicts future scene semantics, and together they score candidate actions to refine a discrete visual policy through group-relative preference distillation. At deployment both world models are removed and the policy acts in a single forward pass. Across five held-out scenarios, the resulting navigation is safer, more socially coherent, and more goal-directed than reactive and learned baselines, and observers rated it as more human-like.

arXiv:2611.07730 PDF

La-JEPA: Compact Robot Policies with Latent World Modeling

Mateo Cl\'emente, George Z. Xue, Amin Abyaneh, Liheng Ma, Rui Heng Yang, Tongtong Cao et al. cross-listed Current robot policies typically inherit large transformers from video generators or vision-language models, which ties policy architecture and inference cost to models built for generation rather than control. La-JEPA instead trains a compact policy transformer from scratch in the feature space of a pretrained V-JEPA 2.1 encoder, predicting future features alongside actions during training but generating only actions at inference. Among policies without embodied pretraining, it achieves state-of-the-art results on RoboTwin 2.0 and LIBERO-Plus with far fewer parameters, and on four real-robot tasks its success is comparable to pi0.5. The authors also find that the officially released LIBERO-Plus evaluator corrupts the instructions for most task variants, and they re-evaluate several open baselines with corrected instructions.

arXiv:2611.08156 PDF

Aligning Policy Encoders with a Shape Teacher

Madelon Bernardy, Mohammad Mahdi Derakhshani, David M Knigge, Riccardo Valperga, Artem Moskalev cross-listed 3D shape information improves robotic manipulation, but 3D sensing at deployment adds cost and complexity. Shape-teacher alignment uses pretrained Point-MAE features of individual objects as training-time alignment targets for the matching image patches in an image-based policy encoder, so the deployed policy still takes only images. On LIBERO, the aligned encoders produce representations more structured around object shape and parts, improve success rates, and accelerate convergence of pretrained policies by 4.7× and 5.6× on the Object and Spatial suites.

arXiv:2611.08275 PDF

VisionSIM: Beyond Idealized Sensors - A Multi-Modal Simulator for Robot Perception

Sacha Jungerman, Kaustubh Sadekar, Avery Gump, Sriram Narayanan, Shantanu Gupta, Bhuyashi Deka et al. cross-listed Robot perception increasingly combines cameras with event, SPAD, time-of-flight, and thermal sensors, yet simulators model these sensors in idealized form. VisionSIM simulates the raw physical measurement process of each modality. It reproduces failure modes such as LiDAR pileup and glare, time-of-flight phase wrapping and motion artifacts, event-camera refractory drops, and history-dependent thermal emission. Identical scenes and trajectories allow principled comparison across modalities. The platform is released together with a large indoor dataset of synchronized raw measurements and ground-truth annotations.

arXiv:2611.08368 PDF

MOMASPLAT: Dynamic Novel-View Demonstration Augmentation for Mobile Manipulation

Sateesh Kumar, Arnav Balaji, Arpit Bahety, Skand Peri, Georgios Pavlakos, Roberto Mart\'in-Mart\'in cross-listed Imitation-learned visuomotor policies break when the camera viewpoint changes, which is common in mobile manipulation because the robot's base rarely ends up in the same pose as during demonstrations. Earlier view-augmentation methods assume static scenes and cannot re-render the object once it has been grasped. MOMASPLAT uses 3D Gaussian Splatting, feed-forward 3D foundation models, and kinematic action retargeting to reconstruct the scene and the manipulated object separately, then synthesizes full demonstrations from new base poses. On five real-world tasks it more than doubles the average success rate of the strongest baseline and keeps working at large base displacements where baselines fail.

arXiv:2611.08372 PDF

Social Humanoid: Socially Responsive Human-Humanoid Interaction

Vongani H. Maluleke, James Ni, Kie Horiuchi, Lea Wilken, Jiahui Lei, Evonne Ng et al. cross-listed Humanoid robots are usually trained to act alone and cannot physically coordinate with a human partner. Social Humanoid uses a high-level policy that models human and robot motion as one shared token sequence, generating reactive whole-body motion and predicting the partner's motion when the partner is occluded; a low-level tracking controller then executes that motion on a 29-joint Unitree G1. For training, a two-phase retargeting procedure maps one person in recorded interactions onto the robot while preserving contact and relative body scale. Applied to five motion-capture datasets, it yields the 260-hour Human-Humanoid Interaction (HHI) benchmark, and the system produces coordinated behavior in simulation and on real hardware.

arXiv:2611.08407 PDF

Failure Prediction and Classification in Vision-Language-Action Models Via Calibrated Latent Probing

Michal P. Podolinsky, Yunhao Yang, Daniel Little, Hong Lu, Rohan Siva, Olin Goudey et al. cross-listed Vision-language-action models (VLAs) fail unpredictably under distribution shift, so deployed robots need a fast and calibrated runtime monitor. VLA-Tug is a lightweight probe on a VLA backbone's latent layers that detects failures early, bounds missed-detection and false-alarm rates, and predicts the failure mode. Training on the segment of a trajectory just before failure improves early detection by up to 30% at matched false-positive rates, and the error-rate bounds hold in up to 86% of runs on unseen tasks versus at most 21% for baselines. The authors release 3,180 annotated manipulation episodes.

arXiv:2611.08425 PDF

4 more specialized papers

Reasoning 14

Routes of Reasoning: Reading and Reshaping Test-Time Compute in MoE Models

Shengjie Wang, Mohsen Fayyaz, Nanyun Peng cross-listed Reasoning models often overthink, continuing to verify and re-derive after reaching a correct answer. The authors show that routers in Mixture-of-Experts (MoE) models offer a training-free way to control this. Linear probes on router logits predict sentence-level reasoning behaviors (such as planning, reflection, and conclusion) nearly as well as probes on the full hidden state, and the associated experts generalize across six datasets. Editing router scores at inference cuts generated tokens by a median of 30.4% (up to 63.3%) while accuracy never drops by more than 0.5 points.

arXiv:2611.05919 PDF

Reasoning over Non-Parametric Memory in Multilingual LLMs: A Cognitive-Based Analysis of Relational Knowledge

Zohreh Abbasi Liasi, Batoul Hammoud, Anas Madkoor, Ehsaneddin Asgari Retrieval-augmented generation (RAG) assumes models reason over relations given in their context instead of relying on facts memorized during pretraining. The authors test this directly by placing the facts in the prompt. Their diagnostic, Rel-Bloom, has 450 multiple-choice questions built from 30 Wikidata relations. Each relation appears at five Bloom-inspired cognitive levels and under factual, counterfactual, and neutralized conditions. Across 43 models and six languages, every open-weight model series shows a sharp accuracy drop from Apply to Analyze, but neither Gemini model does. Evaluate items remain a bottleneck even for the strongest model: Gemini 3.1 Pro averages 99.5% on the other four levels but 60.7% on Evaluate. Difficulty rankings stay consistent across languages, and counterfactual contexts are generally harder than factual ones.

arXiv:2611.06715 PDF

Formalizing inverse problems in the age of AI: possibilities, pitfalls, and an invitation

Christian Clason, Tapio Helin, Medet Nursultanov, Lauri Oksanen Proof assistants such as Lean check proofs all the way down to the axioms, and AI agents have recently made such proofs cheap to write. The authors present AutoIP, a Lean library in which AI agents autoformalized classical linear regularization theory for inverse problems, together with the functional analysis it depends on. Because a machine-checked proof only certifies the formal statement it proves, the library is organized so that human reviewers compare formal statements with their natural-language versions and never need to read the proofs. Their main lesson is that the risks lie in the statements rather than the proofs: simple automated tests on statements exposed problems even in established literature, including a textbook theorem whose hypothesis is more restrictive than claimed.

arXiv:2611.06962 PDF

Synthesizing symbolic models of human and machine reasoning at scale

Solim LeGris, Philipp Mondorf, Jinran Jin, Akshay K. Jagadish, Brenden M. Lake, Todd M. Gureckis Symbolic models of cognition have been limited by the need to engineer them by hand. Behavior-Conditioned Symbolic Synthesis (BCSS) uses AI to automatically search for interpretable, deterministic symbolic programs that verifiably reproduce observed behavior, and it is applied to both humans and AI models across hundreds of challenging reasoning problems. The synthesized programs show that people and machines share the same failure signatures: both oversimplify, adopt rules that only partly explain their observations, and misinfer dependencies between problem features. In machines, reasoning effort predicts how much they simplify, pointing to satisficing-like mechanisms in both.

arXiv:2611.07088 PDF

$D^2$-OPD: Separating Direction and Distance in Extrapolative On-Policy Distillation

Bowen Fang (Columbia University), Dingmin Wang (AWS AI Lab), Hengzhi Pei (Amazon AGI) On-policy distillation (OPD) trains a student to match a teacher's next-token distributions on text the student generates itself, and extrapolative variants push targets beyond the teacher. In existing methods the size of the teacher's shift also dictates how far the target moves. D^2-OPD separates the two: a per-prefix KL constraint caps how far the target can move from the teacher, while an adaptive mix of the teacher's post-training shift and the student-teacher gap sets the direction, and training uses forward KL. On mathematical reasoning benchmarks it scores highest in all three tested settings, beating the strongest baseline by up to 9.45 points.

arXiv:2611.07241 PDF

Test-Time Self-Play: Scaling without a Verifier

Akira Yoshiyama, Akmal Ashirmatov, Jonas H\"ubotter, Ido Hakimi, Andreas Krause Most test-time scaling methods, which spend extra compute at deployment to solve hard problems, depend on a verifier that scores candidate solutions, and a strong verifier is often unavailable. Test-Time Self-Play (TTSP) instead scales test-time compute through asymmetric self-play. On a difficulty-calibrated subset of LiveCodeBench v6, it is the best method at every verifier strength tested, and its lead grows as the verifier weakens. With no verifier at all, it delivers a 35% absolute improvement in mean@8. The gains disappear only when the base model almost never produces the correct answer.

arXiv:2611.07367 PDF

Reinforcing What the Student Has Learned: Teacher-Guided On-Policy Distillation

Bozhen Fang, Linhao Zhong, Xuehao Wang, Huanyi Zheng, Hao Chen, Chunhua Shen On-policy distillation (OPD) trains a student model on its own outputs using dense token-level feedback from a teacher. The authors find this feedback is dominated by style: on math responses, style tokens show 3.5 times the teacher–student log-probability gap of mathematical tokens, so updates mostly teach the student to copy the teacher's phrasing. Student-Delta On-Policy Distillation (SD-OPD) instead weights updates by how the student differs from its own pretrained base model, keeping a coefficient only when its sign agrees with the teacher's feedback. Across five teacher–student pairs with Qwen3 students from 1.7B to 8B parameters, SD-OPD improves average math pass@1 over standard OPD by 7.76 to 10.37 percentage points.

arXiv:2611.07722 PDF

Extending Reasoning in Typed Decision Models via Looping

David Berghaus, Arber Zela, Behzad Shomali, Markus Frey, Mehdi Ali, Rafet Sifa et al. cross-listed Models that choose among a fixed set of answers in one forward pass cannot spend extra test-time compute on hard inputs the way generative models do by producing more tokens. RELOAD fine-tunes a pretrained encoder or decoder with a damped loop over its middle layers, adding compute without adding parameters, and a lightweight controller picks how many passes to run for each input. Across six models from 0.4B to 4B parameters, looping improves both accuracy and calibration, mostly on problems that need longer reasoning chains than any seen in training, where encoders gain up to 23 points. Matched training compute or extra data does not close the gap, and the controller keeps most of the gain at about three quarters of the compute.

arXiv:2611.07736 PDF

TCSExam: Evaluating Frontier LLMs on the Full Range of TCS Research

Yifan Luo, Zhengying Liu, Yang Yuan, Zhilin Yang, Andrew Chi-Chih Yao TCSExam is a benchmark that tests whether LLM agents can do research across theoretical computer science (TCS). Its four tracks are theorem proving, solver engineering, mathematical constructions, and direct attempts at open conjectures. The full version has 100 expert-reviewed tasks, each checked by the Lean kernel or an executable checker, and a 20-task TCSExam-Lite cuts evaluation cost by 80%. GPT-6 Astra leads the full benchmark (71.9) and Opus 5.5 leads Lite (72.3), and the two versions rank models almost identically (Spearman ρ = 0.93). The runs also produced improved solver outputs and constructions, plus independently verified special cases and bounds on open conjectures.

arXiv:2611.07962 PDF

BabyTheorist: A Benchmark for Learning to Theorize the World from Observation Alone

Doojin Baek, Junyeob Baek, Mingyu Jo, Hosung Lee, Taegu Kang, Gyubin Lee et al. The authors argue that understanding the world requires observational theory learning: inferring reusable rules from raw observations alone and applying them to new situations. BabyTheorist generates continual streams of before-and-after visual transitions from hidden compositional programs, with no program labels, task identities, or support sets. It controls the program language, a curriculum of increasing program complexity, and a continual train-test protocol. Seven representative baselines plateau well below ceiling, and the gap widens as the curriculum advances.

arXiv:2611.08177 PDF

Knowing When to Teach: Learning from Teachable Prefixes in Multilingual Reasoning Distillation

Jaewon Cho, Minseo Yoon, Jinyoung Park, Jinwoo Seo, Jaewon Chu, Alice Oh et al. cross-listed On-Policy Self-Distillation (OPSD) trains a model on its own reasoning, using the same model conditioned on a reference solution as the teacher. In multilingual settings, this teacher can suffer from 'Teacher Drift': it follows the student's accumulated mistakes instead of correcting them, and this happens earlier in lower-resource languages. The proposed TOPSD (Teachable On-Policy Self-Distillation) uses teacher-student likelihood to estimate where drift begins and selects a prefix of the trajectory for supervision. It applies distillation only when the teacher can recover the correct answer from that prefix. Across ten languages and three model scales on multilingual math reasoning, TOPSD consistently outperforms standard OPSD, especially in low- and medium-resource languages.

arXiv:2611.08179 PDF

LeanContext: Disentangling Mathematical Resources from Local Formal Context in Lean Whole-Proof Generation

Hang Zhang, Qihao Ye, Litong Liu, Yunbei Zhang, Yugyung Lee, Yue Zhou et al. Neural theorem provers increasingly use retrieved premises and project context, but it is unclear how much the selected context helps and how that depends on training. LeanContext is a benchmark of 129,826 Lean whole-proof generation problems that separates Mathematical Context (preceding declarations) from Environment Context (other local source commands), with four aligned input views for crossed training and inference experiments. For both diffusion-based and autoregressive models, selected declarations outperform comparable alternatives by a wider margin when training includes Mathematical Context. Prioritizing omitted dependencies that the target references improves Pass@32 by 1.40% for LLaDA and 1.70% for Llama.

arXiv:2611.08277 PDF

StepBack: Step-Level Error-Localized Resampling for Efficient Test-Time Reasoning

Yang Ouyang, Jung-Eun Kim Self-consistency (SC) improves chain-of-thought reasoning by sampling many complete reasoning paths and taking a majority vote, which uses a lot of tokens. StepBack starts from a few draft solutions, uses lightweight signals to find the step where each one most likely first goes wrong, and resamples only from that step onward before voting. Across seven math and multi-hop question-answering benchmarks it matches SC accuracy on average while cutting token usage by up to 41.26%. It can also be combined with adaptive methods such as Adaptive Consistency for further savings.

arXiv:2611.08403 PDF

1 more specialized paper

Unclassified 1

Learning and Steering in Incomplete-Information Games

Asr{\i}n Efe Yorulmaz, Tamer Ba\c{s}ar cross-listed No summary available — see the abstract on arXiv.

arXiv:2611.07589 PDF