Papers for

ai system auditors

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Interventional training improves model self-reporting accuracy

Interventional Training Reduces Causal Bypass in In-Context Introspection

Abstract: Introspection, the ability of a system to access and reason about its internal signals, is crucial for language model (LM) self-consistency and scalable interpretability. Prior work argues that LMs possess introspective capabilities, and that training (SFT) could enhance such behavior. However, most setups leave open the possibility of "causal bypass," in which the self-report relies on signals that are correlated with the self-report's subject, while being causally unrelated to it. Although high-level concepts are difficult to intervene on, lower-level signals (such as a single neuron activation) allow precise interventions. Understanding such signals can serve as a minimal prerequisite before understanding more complex introspection. In this study, we train hundreds of introspectors across three low-level signal types and eight LMs. We find that straightforward SFT training leads to causal bypass, and propose interventional training, an alternative where we train the model to report on counterfactually perturbed values. This method enables more accurate introspection of endogenous $\textit{and}$ injected signals, particularly in out-of-distribution (OOD) data. The mechanism generalizes across token positions and scales with more data. Our results demonstrate that while causally grounded introspection is possible, it is not guaranteed -- emphasizing the need to train on mechanisms, rather than behaviors alone.

Wed 28 OctComputation and LanguageArtificial Intelligence
The gist
Some language models can think about their own thoughts, a bit like introspection, but often they guess based on related clues rather than true understanding. The authors found that usual training methods let models take shortcuts that aren't truly connected to what they claim to know. They suggest training models by changing signals inside the model and asking it to report on these changes, which helps models give more honest and accurate self-reports. This approach works well even when the data looks different than what the model saw during training.
Open → 2610.38911v1

Evaluation limits mean AI tests cannot fully certify model abilities

What Lies Beyond Perception: A Partition Theory of the Limits of AI Evaluation and Oversight

Abstract: Replacing the judge can move a benchmark score, and models can be trained to hide capabilities. Both put the evaluator in question: what can it certify? We develop a partition theory of evaluation from one principle: judgement is bounded by perception. An agent's discrimination is the partition of its inputs into classes it cannot tell apart. Discrimination is necessary for capability but not sufficient, so bounds on it bear directly on whether evaluation can show that a model lacks an ability. We prove a one-sided bound. An examinee whose partition refines its evaluator's has the discrimination to pass every test the evaluator can grade, provided each input has an acceptable reply. We define the echo test, which accepts any reply the evaluator perceives as identical to the input, and show that it is complete for the tests the evaluator can grade. Passing therefore certifies at most a floor on discrimination, never a ceiling, and only a sharper evaluator can raise it. Used to detect concealment, echo-test failure points the wrong way: under exhaustive probing it flags every honestly weaker examinee and no concealer that presents as the evaluator's peer. Exact imitation of a weaker model is undetectable by any behavioural evaluator. We extend the bound to ensembles of monitors and to channels a model controls, explain published findings on judge disagreement and sandbagging, and derive testable predictions. A safety case that argues from behavioural evaluation alone that a model lacks an ability must assume the model's cooperation.

Thu 22 OctArtificial IntelligenceComputers and SocietyMachine Learning
The gist
It can be hard to tell exactly what an AI can or cannot do just by testing its behavior. The authors explain that evaluators only see what their own perception allows, meaning some AI capabilities might remain hidden or mimic others. They introduce a way to understand these limits by looking at how an AI divides inputs into groups it can tell apart. Their results show that passing a test only guarantees the AI can do at least that much, never that it can’t do more, making some hidden abilities undetectable without the AI’s cooperation.
Open → 2610.30803v1

Agent messages can reveal private data despite matching expected outcomes

Don't Judge an Agent by Its Messages: Private-State Leakage under Passive Monitoring of Agent Communication

Abstract: An AI agent can reproduce the distribution of its messages and of the receiver's task outcomes while disclosing private information that the task never required. We ask what a passive audit can certify when the auditor knows the authorised sender and the exact observable law but has no trusted pairing of messages with the private states behind them. For a single round, compatible mutual-information leakage forms a sharp interval, and fixing the entire task-relevant message law, with every declared task utility, can still leave a full private bit undetermined; total leakage is determined if and only if, in every task state, the remaining private state or the authorised message is a deterministic function of that state. For a sender, such as an LLM, that selects among its own responses, we prove that in a balanced case its change to the message law within each task state equals $(1-2^{-k})$ times the honest messages' dependence on the attribute, which also sets, up to a constant, how many messages a monitor needs. With Qwen2.5-1.5B-Instruct on a synthetic routing task, selection among 16 responses lets a public decoder recover a private bit in all 8,192 held-out rounds at 98.60\% routing accuracy (honest sender 98.90\%). A monitor that knows the selection rule reaches AUC 0.645 on single messages, close to the ceiling of 0.671 that honest messages predict, and 0.972 over 16, while generic monitors stay near chance. A law-preserving sender built from the same samples recovers the bit in 97.7\% of rounds, and every monitor without the true bit stays near chance against it. A canonical task interface preserves every receiver decision and bounds the remaining information about a balanced attribute by twice the routing-error rate, even for a receiver that shares a key with the sender. These results distinguish what passive auditing can certify from what restricting communication can enforce.

Sun 18 OctCryptography and Security
The gist
Sometimes, an AI agent can seem like it's only sharing what’s needed for its task but is actually leaking private information you wouldn’t expect. The authors studied what a passive observer can tell about hidden private details just by watching the messages, without linking them to those private details directly. They found it’s possible for an agent to hide a full bit of private info while still acting honestly according to its task. Their experiments with a language model show that subtle changes in message selection can reveal private bits with high accuracy, even when messages seem task-appropriate. This work helps clarify what monitoring can and cannot guarantee about privacy when watching agent communication.
Open → 2610.25032v1

LLM graders vary widely in judging harmful response compliance

The Missing Compliance Class: LLM Graders That Collapse Jailbreak Success, and a Free Check

Abstract: Jailbreak papers report an attack success rate, the share of responses that deliver the harmful request, and read it as a property of the target model. We hold the target model, the prompts and the responses fixed and change only the grader. Three dense graders of 8B and 9B parameters, from three model families, move compliant responses to the neighbouring class, evasion, instead of scattering them across classes. One of them assigns the compliance label zero times in 900 responses. This class collapse also appears on new harmful requests, on a target model from a third family, and in a held-out 7B grader from a fourth family. Per-class label counts expose it at no cost and without human labels. The collapse decides how the rate behaves under a change of grader. On two corpora of 900 responses and eight graders, the compliance rate differs by a factor of 22 to 25, while the non-refusal rate differs by 18 to 23 percentage points. Without the three collapsing graders, compliance differs by a factor of 1.7 to 2.8 on all four corpora, and non-refusal still differs by 10 to 22 points. These results do not change when every grader is called once. We propose a reporting minimum that keeps the compliance rate and adds its per-class label counts and the named grader. Beside it goes the non-refusal rate, whose disagreement across graders is additive.

Sat 17 OctCryptography and SecurityComputation and LanguageMachine Learning
The gist
When people test language models for harmful or unsafe responses, they rely on 'graders' to judge if a response follows rules or breaks them. This paper finds that some graders unfairly lump all good responses into a rarely used category, making it look like the model breaks the rules more often than it really does. The authors show this problem happens across many models and graders, and suggest always reporting detailed counts of each response category to avoid confusion. This makes safety tests for language models clearer and more honest.
Open → 2610.24872v1

Verbalising model reasoning improves chain of thought faithfulness detection

Verbalising Model's Computation for Chain-of-Thought Faithfulness Detection

Abstract: Current Chain-of-Thought (CoT) verification methods detect reasoning faithfulness from model outputs or static activations, but are limited in explaining how unfaithfulness develops during generation. We introduce VERITAS to verbalise the model's computation: how different reasoning anchors emerge, transfer across layers, and surface in the output. VERITAS adopts the layer-wise Jacobian projection to produce a verbalised account of the model's internal reasoning evolution at each generated CoT token. By training a classifier on the extracted features along the traces, we show that these structured features provide insightful perspectives on how and where reasoning diverges toward unfaithfulness. Experiments on four datasets from FaithCoT-Bench and BonaFide show that VERITAS achieves a significant performance gain over LLM-as-Judge, with a 28.4% gain in balanced accuracy, and an average improvement of 16.0% over activation probing. Further analysis shows VERITAS can be generalised to different datasets and model architectures. Our work shows that verbalising model computation provides a richer and more interpretable lens on CoT faithfulness, moving beyond detection toward a mechanistic understanding of how reasoning fails.

Fri 16 OctComputation and Language
The gist
Large language models sometimes produce reasoning steps that don’t fully match how they actually think. This paper introduces VERITAS, a way to turn the model’s internal calculations into readable explanations at each step of its reasoning. By looking at these explanations, the authors train a classifier that better detects when the model’s reasoning goes off track compared to previous methods. VERITAS also helps understand why and where the model deviates, making it easier to trust or debug the reasoning.
Open → 2610.23275v1

Memorizing networks differ from generalizing networks in test behavior and training costs

Memorization in image classification: test set behavior and scaling laws

Abstract: Deep neural networks are capable of both learning generalizing solutions on natural tasks and memorizing arbitrary mappings. We argue that understanding the former requires understanding the latter, which is much less studied. In what ways do networks that generalize or memorize differ in their behavior or their training dynamics? Do memorizing networks simply function as a lookup table where input-output mappings are stored independently? We investigate these questions in the context of CNNs trained on image classification tasks with randomized labels or pixels. We first study the behavior of such memorizing networks on unseen images. We find that independently initialized networks trained on the same random labels learn different predictive functions: they make different predictions on test examples, in contrast with generalizing networks. We then examine the effect of dataset size on memorization through the required network capacity and training time to interpolate the training set. Counter-intuitively, we find that the number of presentations of a given example required for complete memorization can decrease with dataset size even when input-output pairs share no common structure. Although memorizing networks do not learn a universal solution, they exhibit interesting behaviors which call for further investigations into the underlying mechanisms.

Mon 12 OctMachine Learning
The gist
Deep learning networks can either learn useful patterns or just memorize random data. This paper looks at how networks that memorize behave differently on new images compared to those that learn general patterns. The authors find that memorizing networks trained from different starting points make different predictions on test images, unlike generalizing networks. They also discover that as the dataset grows, the amount of training needed to memorize all examples can actually go down, even if the data has no meaningful patterns.
Open → 2610.16090v1

Framework finds gaps in large language model safety tests

Specification-Based Testing of Large Language Models

Abstract: Model cards, system cards, and safety reports increasingly document LLM safety behaviors, yet safety evaluations typically start from predefined benchmarks rather than asking which documented claims those benchmarks actually test. We introduce LEST (LLM Evaluation through Specification-driven Testing), a framework that treats documented safety claims as specifications for black-box testing. In LEST, each claim determines which benchmark prompt tests it and whether a Refuse-to-Comply transition, where a model refuses a prompt but complies with its mutated version, counts as evidence against it. LEST mutates these prompts to search for counterexamples, manually validates each candidate, and traces validated counterexamples back to the claims they contradict. We evaluate LEST using the system cards of Claude Opus 4.8 and GPT-5.5 with 97 seed prompts from SORRY-Bench across Mental Health and Self-Harm, Harmful and Violent Content, and Fairness and Bias. Of 56 identified safety claims, 29 (51.8%) are prompt-testable, but only 17 (58.6%) are exercised by an applicable benchmark prompt. Both models refuse >95% of benchmark prompts. Evaluating 1,836 mutated prompts on both models reveals 312 candidate Refuse-to-Comply transitions flagged by automated response classifiers. However, human validation confirms only 19 (6.1%) as both intent-preserving and genuinely compliant, showing automated evaluation substantially overestimates behavioral failures. Tracing these 19 transitions back to the claims reveals counterexamples for 6 of 9 covered claims for which refusal is an applicable oracle. Our results show that benchmark prompts may not be sufficient to validate all documented LLM safety behavior, and automated failure detection requires manual validation. LEST provides end-to-end traceability from natural-language safety documentation to executable tests and human-validated counterexamples.

Sat 10 OctSoftware EngineeringArtificial Intelligence
The gist
Large language models (LLMs) like GPT are tested for safety using specific benchmark prompts, but it's unclear if these tests actually cover the safety claims made by the models’ documentation. The authors created LEST, a method that uses safety claims as test guides and automatically changes prompts to find cases where the models' responses don't match their safety promises. They found many safety claims aren’t fully tested by existing benchmarks and that automated checks often mistake safe responses for failures, so humans need to verify results. This method links natural language safety promises directly to tests and verified counterexamples, helping improve how LLM safety is assessed.
Open → 2610.14443v1

Attention head choices shape vision-language model grounding and steering

What Do Visual-Head Discovery Scores Actually Find? Attention Source, Necessity, and Random-Control Pitfalls in Vision-Language Models

Abstract: Attention heads that attend to image regions relevant to a question are increasingly used to steer, ground and interpret vision-language models (VLMs) and to reduce their hallucinations. They are mostly found by ranking heads with an attention- pattern score and validated by steering or masking them. We ask how the choices inside such a discovery score shape the heads it returns, and which of the two validations identifies them. On Qwen3-VL-8B-Instruct we vary the query type, the discovery corpus and the token positions whose attention is read (the attention source) in a full 2 x 3 x 2 design, and test all 12 head-sets for steerability (CERS: Contrastive Evidence-Region Steering score) and necessity (NCS: Necessity Con- trast Score) against layer-matched random head-sets. (1) The attention source and the query type reshape the selected heads far more than the corpus: changing the source keeps a median of 49 of the top-100 heads, the query 55 and the cor- pus 84, while two halves of the same data share 96-99. (2) Necessity follows the attention source: head-sets discovered from query-span attention are more nec- essary than last-token ones (difference 0.083, p=6 x 10^-10), and the two re- ferring + query-span sets lie 17-19 standard deviations above 250 layer-matched random sets (Holm-adjusted p=0.048). The referring + query-span effect re- plicates on several recent VLMs. (3) Steerability is not specific to the discovered heads: no discovered head-set steers better than its layer-matched random sets (rank p >= 0.14), and random sets drawn from the same or from any layer span the discovered sets' scores. Necessity therefore separates the discovery settings, while steering at this strength does not. We turn these findings into a protocol for reporting visual-head discoveries.

Fri 9 OctComputer Vision and Pattern Recognition
The gist
Many vision-language models use special parts called attention heads to focus on image areas that matter for a question. This paper studies how the way these attention heads are chosen changes what the model learns and how well it can be guided. The authors find that where the attention looks and what kind of question is asked changes the selected attention heads much more than the example data used. They also show that some attention heads are truly important, while the ability to steer the model isn’t unique to those heads. These findings help improve how we find and report useful attention heads in these models.
Open → 2610.13111v1

Cancerous backdoor gradually corrupts large language model reasoning

Cancerous Backdoor Attack: Gradual Activation via Invisible Tokens and A Stage Controller

Abstract: Backdoor Attacks on Large Language Models (LLMs) typically follow a trigger-response pattern, where satisfying a trigger condition activates a single terminal behavior. However, this single-point backdoor activation does not explore attacks in which malicious behavior develops gradually through multiple intermediate stages before reaching the terminal activation stage. We present Cancerous Backdoor Attack, that gradually corrupts an LLM's reasoning over a sequence of interactions by leveraging invisible tokens and a stage controller. Specifically, invisible tokens provide hidden stages to the model without appearing in the user's visible request and the stage controller tracks the attack's progression during inference to realize gradual activation. We evaluate Cancerous Backdoor Attack across several reasoning datasets. The attack consistently produces gradual reasoning corruption across models and tasks. We compare Cancerous Backdoor Attack with prior backdoor attack baselines to demonstrate our proposed attack outperforms the baselines. Our results indicate that reasoning corruption can develop gradually before it becomes visible, making answer accuracy alone insufficient for detecting backdoor attacks.

Thu 8 OctCryptography and SecurityArtificial IntelligenceComputation and Language
The gist
Backdoor attacks on language models usually cause a sudden change in behavior when a hidden trigger is present. The authors show a new kind of backdoor that slowly changes how the model reasons over several steps, making it harder to detect. They do this by hiding invisible tokens that control different attack stages without showing up in user input. Their tests show this gradual corruption happens in different models and tasks better than previous attacks. This means just checking if answers are correct is not enough to find these attacks.
Open → 2610.12644v1

Reasoning longer does not reduce bias in language models

The Long Road to the Same Answer: Cognitive Bias Under Escalating Reasoning Budgets in Large Language Models

Abstract: Reasoning models allocate extra computation at inference time and present their answers as the product of deliberate thought. If this deliberation works the way dual-process accounts of human cognition suggest, longer thinking should weaken the classic decision biases that fast, intuitive judgment produces. Using 30 vignettes covering six biases (anchoring, framing, loss aversion, escalation of commitment, availability, confirmation) from an established benchmark, we run a dose-response study across four model families, pairing each reasoning model with a matched non-reasoning sibling and requesting thinking ceilings of 0, 1,024, 4,096, and 8,192 tokens, for 12,350 API calls. Because a requested ceiling is not the same as realized deliberation, we use the reasoning tokens each call consumed as the dose. First, reasoning models are not less biased than their siblings; the point estimate leans the other way in every family, but the item-level pooled contrast is not reliable (Delta = +0.031, t(29) = 1.45, p = .157). Second, bias magnitude does not reliably fall as realized deliberation grows: no slope is significantly negative, and where anything moves it is the signed score drifting further from the human direction. Third, anchoring is the only bias in the human direction (d = 1.89). Four of the other five lean the opposite way in all seven models; with five items per bias, that reversal is reliable for framing and directional for escalation of commitment, confirmation, and loss aversion, while availability is absent. A one-line instruction to restate the anchor before answering lowered anchoring on all five anchoring items, which no amount of additional thinking did, although the effect does not reach significance (p = .057). The results argue against treating test-time reasoning as a rationality guarantee and for auditing deployed models bias by bias.

Wed 7 OctComputation and Language
The gist
Some people think that if AI models think longer, they will make fewer mistakes caused by common mental biases. The authors tested four families of large language models on six well-known biases, asking them to think for different lengths of time. They found that thinking longer does not make the models less biased, and sometimes the models even get more biased with extra thinking. This suggests that making AI spend more time reasoning is not a reliable way to fix biased decisions.
Open → 2610.10049v1

Vision language robots miss implied harm in instructions

What the Guard Misses, the Robot Executes: Implied Harm in VLA Instructions

Abstract: Vision-language-action models (VLAs) act on instructions without being able to refuse, so screening harmful requests falls to monitors. We test whether these monitors catch ordinary robot tasks requested for harmful reasons, holding the task fixed while varying only how explicitly the intent is stated. $π_{0.5}$ completes the task at every level of explicitness, as often as for harmless controls. Text guards flag nearly every blunt request but few implied ones: up to 95% of implied-harm runs end with the task done and no flag raised, and up to 90% even after recalibrating on robot instructions. Monitoring the model's activations does not close this gap. Linear probes separate harmful from harmless instructions almost perfectly in the base language and vision-language models, but this separation weakens after robot training in two model families, most for implied harm.

Mon 5 OctRobotics
The gist
Robots that follow instructions from language models can carry out harmful tasks if the harmful intent is not clearly stated. The authors tested if monitoring systems can catch these harmful requests when the task is the same but the harmful intent is hidden or implied. They found that monitors flag obvious harmful commands but fail to detect most implied harmful ones, allowing the robot to complete the harmful task unnoticed. Attempts to monitor internal signals in the model also did not reliably reveal implied harmful intent after the robot training.
Open → 2610.05818v1

LLMs often fail to reveal true reasoning in chain of thought

Making LLMs Say What They Think: Measuring and Improving CoT-Interpretability Alignment

Abstract: Chain-of-thought (CoT) traces often serve as a proxy for how Large Language Models (LLMs) arrive at their answers. However, growing evidence shows that models' CoT often fails to reflect their internal computations and can be changed without affecting their final answers. In this work, we measure and improve the alignment between the reasoning described in an LLM's CoT and what it computes internally. We propose CoT-Interpretability Alignment (CIA), a metric that measures the agreement between a model's CoT traces and its internal reasoning strategies as detected by interpretability tools. We evaluate CIA on three tasks (two-hop question answering, hint intervention, and integer multiplication) across three LLMs, finding that LLMs exhibit limited alignment across all tasks (44.8-75.9%). We then experiment with improving CIA via post-training, setting both the task accuracy and parametric faithfulness signals as a reward. Experiments show that we can substantially improve CoT parametric faithfulness while maintaining or improving the task accuracy. We provide rich analysis, such as their generalization patterns. Our work provides both a framework for auditing CoT parametric faithfulness and a pathway toward making models' explicit reasoning more trustworthy. Code and data are available at https://github.com/yihuaihong/CIA-minimal-repro.

Wed 30 SeptComputation and LanguageArtificial Intelligence
The gist
Large Language Models (LLMs) often write out their reasoning steps, called chain-of-thought (CoT), to explain how they get answers. However, these explanations don’t always match how the model actually thinks internally. The authors introduce a new way to measure how well the CoT matches the model’s true reasoning and show that current models have limited alignment. They also try training models to make their written reasoning closer to their real computations without hurting accuracy. This work helps make LLM reasoning more trustworthy by auditing and improving their explanations.
Open → 2609.38972v1

Flatness measures alone do not guarantee robust model improvements

When a Flatness Proxy Is Not a Function: Robustness Certificates and Training Interventions

Abstract: A valid curvature upper bound need not justify either a robustness certificate or an intervention on an intrinsic predictor property. We demonstrate this distinction for a last-layer relative-flatness proxy used in both settings. First, empirical-risk stationarity does not eliminate pointwise first-order loss terms: at a finite global empirical-risk minimum, the retained certificate expression underestimates a loss increase by over $210\times$. We derive a globally valid, gauge-invariant feature-space repair. Second, common-row softmax shifts preserve predictions and the exact contraction while making the proxy unbounded. Even standard reference-class choices double it on average relative to the centered representation. For a single fixed-feature example with at least three classes, scalar retuning generically cannot align the induced probability updates. Row centering gives the orbit-minimized bound and restores value and full-model gradient invariance under this symmetry. Across 45 paired one-step tests on algorithmic and image models, amplified shifts separate raw-regularized predictors while quotient-regularized predictors remain aligned. Long-horizon CIFAR-10 experiments show substantial, reversible suppression of generalization, while evidence for selective delay after memorization is less consistent. Together, these results show that validity as a curvature upper bound does not by itself justify either inversion into a robustness certificate or differentiation into an intrinsic training intervention.

Tue 29 SeptMachine Learning
The gist
When making computer models robust, people often use measures of how 'flat' or smooth the model's predictions are. This paper shows that a common flatness measure does not reliably prove the model is more robust or help fix it. The researchers found that this measure can underestimate risks and be affected by certain transformations, meaning it might mislead decisions about the model's safety or how to train it. They offer corrections that better respect the model's structure but highlight limits of these flatness proxies for guaranteeing robustness.
Open → 2609.38540v1

Gradient conflict does not predict multimodal model trade offs well

Does Gradient Conflict Predict the Understanding--Generation Trade-off? A Controlled Audit of Conflict-Metric Validity in Unified Multimodal Models

Abstract: Unified multimodal models (UMMs) are increasingly designed around gradient conflict between understanding and generation objectives. The premise that reducing these metrics improves the downstream understanding-generation trade-off has never been tested directly. We audit it in a controlled testbed, GRIDUMM, which mirrors key structural ingredients of UMM training while making the ground-truth trade-off exactly computable. Across 63 configurations and 372 measured checkpoints, no directional conflict metric reaches an absolute Spearman correlation of 0.3 with a confidence interval excluding zero for conflict measured during training against the eventual trade-off. A dose-response intervention that monotonically suppresses conflict leaves the trade-off flat, separating correlation from causation. The norm ratio is a generation-failure detector and becomes null among configurations that master generation. Functional interference measures outperform directional conflict metrics, while training loss tracks the trade-off strongly. Our results do not show that conflict is useless; they show that its validity as a diagnostic target must be established, not assumed, and we release the audit protocol as a reusable standard.

Tue 29 SeptMachine LearningArtificial IntelligenceComputer Vision and Pattern Recognition
The gist
Multimodal models that both understand and generate data often try to reduce conflicts between these two tasks, hoping to improve overall performance. The authors tested whether these conflicts really predict how well models balance understanding versus generation and found no strong link. When they artificially reduced conflict, it didn’t improve the balance, suggesting that conflict isn’t a reliable sign for model improvement. Other metrics like training loss tracked performance trade-offs better than conflict measures.
Open → 2609.38465v1

Behavioral certificates improve quantized language model deployment efficiency

Behavioral Capacity Certificates for Quantized Language Models

Abstract: Activation and key-value cache precision change what a quantized language model computes without altering its stored weights. Direct weight-code bounds, however, assign identical complexity to deployments that behave differently and charge separately for weight codes that behave identically. Behavioral Capacity Certificates (BCC) charge for behavior using the aggregate prior mass of complete implementations---weights, scales, activation and cache rules---that induce the same bounded loss. When quantization merges implementations, this shared mass lowers the complexity penalty, and a break-even law determines when the saving survives the cost of validating it. BCC supports a three-step deployment workflow, and our experiments verify each step. First, a forward-only screen shortlists per-layer bit-widths by how often candidate perturbations preserve the reference predictions, with quality comparable to Hessian-guided selection at lower preprocessing cost. Second, margin-certified cells identify weights that can be pruned or sign-flipped without changing the deployed behavior: every permitted combination preserves all declared predictions, and on OLMoE-1B-7B and SmolLM2-1.7B, independent probes bound the probability that any permitted combination changes a prediction on new text. Third, BCC bounds the population loss of the deployed model, nonvacuously for complete decoders and more tightly than the compressed-code route. At equal cache memory, giving keys higher precision than values yields lower NLL and higher prediction agreement on GPT-2, Qwen2.5, and SmolLM2, together with a tighter complexity bound in the GPT-2 audit.

Tue 29 SeptMachine Learning
The gist
Quantized language models run using simpler numbers can behave differently depending on how calculations are done, even if the core weights are the same. The authors developed a way to measure the model’s effective complexity by looking at how many implementations behave similarly, rather than just counting weight details. Their approach helps pick efficient bit sizes and prune unnecessary model parts without losing accuracy on predictions. Tests on popular models show this method gives better guarantees about model performance and complexity than previous techniques.
Open → 2609.37887v1

Fisher induced geometry improves understanding of model predictions

Fisher-IRG: Fisher-Induced Local Invariant Representation Geometry across Language and Vision Models

Abstract: Semantic-preserving transformations can induce substantial motion in learned representations, while small changes may strongly affect model predictions, raising a basic question: what local metric best captures semantically consequential variation? We propose Fisher-induced invariant representation geometry (Fisher-IRG), which measures local representation directions through their predictive sensitivity. Around each representation, we construct semantic-preserving and semantic-changing neighborhoods, aggregate their local Fisher information, and recover invariant directions through a contrastive generalized eigenvalue problem. Controlled displacement analyses first show that comparable Euclidean motion can have substantially different predictive consequences, supporting the need for a predictive geometry. Across language and vision models, Fisher-IRG yields stronger semantic-versus-nuisance predictive selectivity and generally more reproducible subspaces than covariance-based geometry, while recovering systematically distinct local directions. Representation interventions further localize semantic effects to the Fisher-derived subspace, and held-out separation and retrieval show that the recovered geometry generalizes beyond the discovery neighborhoods. These results support Fisher-IRG as a principled framework for characterizing local invariant representation geometry.

Tue 29 SeptMachine LearningComputation and LanguageComputer Vision and Pattern Recognition
The gist
Some small changes in how machines see words or images can cause big differences in their answers, while other bigger changes might not matter much. The authors propose a new way, called Fisher-IRG, to measure which changes really affect the machine's understanding by looking at how sensitive the model's predictions are. They tested this method on language and image models and found it better at capturing meaningful changes than older methods. This helps us understand what parts of the machine’s internal view are important for meaning and which are just noise.
Open → 2609.36458v1

Training order creates identifiable memory traces in language model weights

Commutator Memory: Sparse, Path-Local Reading and Steering in Language Models

Abstract: Gradient updates on different data generally do not commute: training a language model on two data sources in opposite orders gives different weights, even with the same data and total exposure. Loss or benchmark deltas show that the models differ, not where. We ask whether this path dependence leaves a parametric training-history memory: a weight component that flips sign when the two sources are swapped, is localized in output space, changes the held-out loss gap between the two orders under targeted interventions, and reveals which trained model came from which order. For one small SGD step of size $η$ on each of sources $A$ and $B$, the weight difference $θ_{AB}-θ_{BA}$ is, to leading order, $η^2 b_{AB}$, where $b_{AB}=H_Bg_A-H_Ag_B$ is the Lie bracket of the two gradient fields at the base model. We define commutator memory by projecting the bracket through the logits into one score per vocabulary token; the scores sum to the bracket's prediction of the gap. The scores are localized: on three models, the same readout of the measured $θ_{AB}-θ_{BA}$, or of a bracket from disjoint batches, shares 82-99% of the original top-20 tokens, versus 35-49% for norm-matched random directions. They are causally actionable: in Qwen-3-4B SFT, downweighting the ten tokens with the largest predicted share of the gap closes a median 32% of the measured gap, while frequency-matched tokens with near-zero scores have almost no effect. The weights themselves carry the component: projecting the difference between the two trained models onto $b_{AB}$ identifies which came from which order in 92% of cases across four LLMs (chance 50%). Controlled tests also cover matched-batch DPO, a frozen-rollout GRPO-style objective, and an AdamW endpoint check. The memory is defined per source pair, not per example, and its projection on $b_{AB}$ decays with further training.

Mon 28 SeptMachine LearningArtificial IntelligenceComputation and Language
The gist
When training a language model on two different data sources, the order in which the data is presented changes the model's final settings, even with the same data. The authors found that this difference creates a kind of ‘memory’ in the model's parameters that reflects the training order and is linked to specific words. This memory can be identified and even influenced, showing which tokens contribute most to the differences caused by the training order. Their work reveals how subtle interactions during training leave lasting, traceable effects in language models.
Open → 2609.34348v1

Agent harness records need second author for trustworthy audit

Hearsay: Can an Auditor Trust the Record a Deployed Agent Harness Writes?

Abstract: An agent harness, the code that turns a model into an agent, writes its own record of each run, and that record is all a later reader gets when a run is disputed, investigated or audited. We call a record evidentiary when a reader who was not there can check it without trusting the writer. Across sixteen deployed frameworks, none writes one in full. Hearsay examines the record, not the task: five harnesses run fourteen tasks, three blinded LLM examiners and a human panel read the records, and every excerpt an examiner quotes is checked mechanically for who wrote it. First, the record lets a reader name the fault but not prove how the run went. Examiners name the right fault in 74 to 91% of 140 runs, but the fault can be proved only from two files the benchmark adds; for what happened in between, fewer than one citation in ten lands on anything the harness did not write, and the examiner with the fewest false alarms catches half of the entries we delete, rewrite or fabricate. Second, the remedy is a second author, not a stronger seal on the first. An append-only log of what passes between harness and model, kept outside the harness and read against the record in both directions, reports all 28 omissions and fabrications we made a harness commit as it ran, where a hash chain over the harness's own record passes all 28. Handed the log, examiners keep their fault verdicts but rest more of their citations on what the harness did not write. What makes a record evidence is who writes it, not what is captured.

Sat 26 SeptCryptography and SecurityArtificial IntelligenceComputational Engineering, Finance, and Science
The gist
When AI tools called agent harnesses run tasks, they keep a record of what happened. However, the researchers found these records don't fully prove what actually took place, so auditors can't fully trust them alone. They showed that adding a second independent log of communications between the harness and the AI model can catch problems and omissions. This means the trustworthiness of the record depends more on who writes it than on what details are captured.
Open → 2609.32495v1

Language model reasons for rejecting candidates influence their choices

Does a model's stated reason for rejecting a candidate do any work?

Abstract: Asked to choose between candidates and explain the choice, a language model often rejects a rival by naming a fact its profile lacks: no director, no date of death. That sentence is a claim about the text in front of the model, and it can be tested without any judge. We insert a real corpus sentence stating the named fact into the rival's profile and ask again under greedy decoding. Two controls separate content from placement: a length-matched irrelevant sentence at the same profile, and the same two sentences at a third option the model never mentioned. In the largest of three runs, six open models on 2WikiMultihopQA, supplying the named fact at the profile the model named moves its choice more than the irrelevant control does, odds ratio 3.57 [1.54, 8.26], Holm p=0.0210, and this survives dropping any single model. The contrast the design was built to detect, the same fact at the option nobody named, does not clear correction, Holm p=0.2428. The strongest result in the family carries no content claim at all: the identical irrelevant sentence moves the choice more at the named rival than at the third option, Holm p=0.0008. Repair and control also differ in co-candidate mentions, relation template and fluency; post-hoc matching on the first two preserves the content effects' direction, matching fluency weakens one, so the content contrasts bound an effect rather than establish one. A forced single-token probability read disagrees in direction with the free-text choice on that same contrast, and three candidate explanations for the disagreement find no support. Every measurement is a string rule, so each was validated against the records it reads; validation caught eight defects. The largest, a choice-parsing rule that returned the option a model had just rejected in 17.1% of adjudicable responses, would have reported six surviving contrasts instead of four.

Thu 24 SeptComputation and LanguageArtificial IntelligenceMachine Learning
The gist
Language models often explain why they reject one option by pointing out missing facts. This paper checks if adding the missing fact to the rejected option changes the model’s choice. The authors find that supplying the stated reason does affect which option the model chooses, but the effect is subtle and mixed with other factors like sentence placement and fluency. They also show that not all effects are clear-cut, and some controls behave unexpectedly. Overall, the paper shows that a model’s given reason for rejecting an option does have some influence, but it’s complex and still unclear how much content alone drives decisions.
Open → 2609.30151v1

Leakscale measures how training exposure affects benchmark performance

Beyond Overlap: Estimating the Causal Effect of Benchmark Exposure

Abstract: Evidence that evaluation material entered training does not reveal how much it affected evaluation. This distinction leaves a contaminated benchmark score difficult to interpret: provenance can establish contact, but only a counterfactual can quantify the performance attributable to that contact. We present LeakScale, an interventional framework for estimating this missing quantity. LeakScale creates fresh executable tasks that require private, family-specific information absent from and non-derivable from the public task, controls access to that information, and estimates the resulting control-adjusted change in executable accuracy. Across 2,048 unique families, two model families, two executable domains, and 262,144 generations, exposure improves accuracy in every model-by-domain combination, with gains ranging from +7.17 to +27.31 percentage points. These findings separate two empirical questions that are often conflated: whether benchmark contact occurred and how strongly a reported score depends on it. LeakScale makes the latter directly measurable.

Wed 23 SeptComputation and Language
The gist
Sometimes, test examples sneak into a model's training data, which can make it hard to tell if the model is genuinely smart or just remembering those examples. The authors created LeakScale, a way to measure how much this kind of 'cheating' improves a model's scores. It does this by designing new test tasks that use private information held back from training, then seeing how much better a model does when it has access to that private info. They found that exposure from training can boost performance by a noticeable amount across different models and tasks. This helps separate whether a model’s good score is because it saw similar examples before or because it actually learned the task well.
Open → 2609.27176v1

MorphoSHAP explains deep visual models using shapes not pixels

MorphoSHAP: Rethinking the Unit of Attribution in Explanation for Deep Visual Models

Abstract: Visual attribution methods typically explain predictions using pixels, superpixels, or regular patches. These representations can localize important regions, but provide limited information about their structure. We introduce MorphoSHAP, a model-agnostic post-hoc method that instead uses morphological shapes as the players of a Shapley attribution game. Using the Tree of Shapes, each shape is described by its scale, geometry, and signed contribution, providing explanations of where the evidence lies, what type of structure carries it, and how strongly it affects the prediction. This shared morphological vocabulary enables spatial, textual, and global class-level explanations beyond image-specific heatmaps. To the best of our knowledge, MorphoSHAP is the first SHAP-based image attribution framework to combine these different forms of explanation. Across five diverse datasets and three architectures, MorphoSHAP achieves strong insertion/deletion performance and outperforms competing attribution methods on several benchmarks. Finally, a user study shows that MorphoSHAP provides explanations that are easy to use and are preferred over standard attribution baselines.

Tue 22 SeptComputer Vision and Pattern RecognitionArtificial Intelligence
The gist
Most tools that explain AI vision models highlight important pixels or patches, but this often misses how those parts relate as structures. The authors created MorphoSHAP, which breaks images into meaningful shapes and measures how each shape contributes to a model’s decision. This approach shows not only where the model looks but also what types of shapes influence its prediction and by how much. MorphoSHAP works across different models and datasets and provides explanations that people found easier to understand and prefer.
Open → 2609.25815v1

Bayesian belief layer enables controlled opinion shifts in AI agents

Bayesian Belief Layer for Controllable Opinion Dynamics in LLM Agents

Abstract: LLM agents in social simulation revise their opinions implicitly, in context: how open an agent is to persuasion can neither be specified nor verified, and collective outcomes inherit the model's training prior. We introduce Bayesian Chronicle Agents (BCA), a minimal belief layer separating \emph{what} an agent believes from \emph{how} it speaks. Each stance is a probability, updated by one Bayesian step per utterance heard. A single prior-strength parameter $κ$ encodes stubbornness, modeled after its role in Friedkin--Johnsen (FJ) opinion dynamics. We then sweep this parameter to yield three canonical regimes of opinion dynamics on demand (consensus, persistent disagreement, committed-minority influence), with persistent disagreement matching the FJ closed-form fixed points at $R^2\!=\!0.93$--$0.99$. We further show that prescribed $κ$ remains recoverable after the language round-trip, with perfect rank-order recovery across all four models. Explicit belief also makes simulation auditable: the layer surfaces systematic per-model stance biases that end-to-end simulation would silently absorb.

Fri 18 SeptMultiagent SystemsArtificial Intelligence
The gist
It's hard to know how AI agents change their opinions when they talk, because those changes happen inside their 'black box' brains. The authors introduce a simple system that keeps track of what each AI agent truly believes, separately from how it talks. This system uses probabilities that update logically every time the agent hears something new, and a stubbornness setting that controls how easily opinions change. This helps simulations show different group behaviors like agreement or persistent disagreement and lets people see hidden biases in the AI agents’ thinking.
Open → 2609.21997v1

LLM agent privacy exposure often missed by common evaluations

ASLEval: Measuring Privacy Exposure Displacement in LLM Agent Sessions

Abstract: Privacy evaluations of tool-using LLM agents often inspect a designated action, final response, or attacker report. These local proxies can miss unauthorized exposure elsewhere in a multi-step session and lack common ground truth across outlets, reports, and tool paths. We introduce privacy exposure displacement, the mismatch between a local evaluation proxy and target-grounded session exposure, and ASLEval, an authorization-aware framework that pre-registers a hidden target set, measures all declared visible exits, and reserves internal traces for diagnosis. Across multiple enterprise-style environments and independently implemented runtimes, we observe three recurring patterns. An expected-outlet-only view misses 46.9% of exposure recovered by the visible-exit union; attacker self-reports combine omissions with high false discovery; and schema-aligned internal evidence usually precedes visible exposure at the request/probe level. Reducing model-visible returns changes this path but can eliminate normal-task success. Independent human review supports the adjudication pipeline while identifying harder console and candidate cases. These findings motivate benchmarks that declare the complete visible boundary, ground claims in pre-specified targets and authorization, and report privacy together with task utility.

Wed 16 SeptCryptography and SecurityArtificial Intelligence
The gist
Privacy checks on AI tools that use multiple steps often miss hidden leaks of private information during their sessions. The authors introduce a way to measure these hidden leaks by comparing official privacy checks with what actually gets exposed. They built a system called ASLEval to track all private exposures, finding that usual methods miss almost half of the leaks. Their work suggests new ways to evaluate AI privacy that balance protection with task success.
Open → 2609.18864v1

Ai text watermarks are unverifiable and their effects vary by content type

Watermarks Without Verification: AI Text Watermarking After the EU AI Act

Abstract: On August 2, 2026, the obligations of Article 50 of the EU AI Act took effect, requiring generative AI providers to mark the content their systems produce and ensure it can be detected as AI-generated. Days later, Anthropic disclosed that every Claude model released after that date embeds a watermark based on SynthID-Text in all generated text, enabled by default with no user opt-out; Google has deployed SynthID-Text in Gemini since 2024. Users objected that the watermark degrades quality, particularly for code, that it secretly encodes identifying information, and, in mutual contradiction, that it is easily removable and inescapable; the vendor answered with assurances of unchanged quality, no identifying information, and robustness to light editing. In this work, we argue that neither the objections nor the assurances can currently be verified and that this unverifiability, rather than watermarking itself, is the substantive governance failure. We sort the contested assertions by what it would take to settle each and evaluate the open-source SynthID-Text implementation on two open-weight models, because no public tool can test the deployed systems. On prose, the measured effect of the watermark does not exceed that of changing the sampling seed. On code, the cost is three points of correctness on one model and below measurement on the other, while detection remains near chance, a limitation of detectability rather than quality. The remaining gaps trace to withheld access or missing institutions and we map each to a requirement: release of matched outputs, configuration disclosure, accredited audits, a shared evaluation protocol, and interoperable detection.

Wed 9 SeptComputers and SocietyArtificial IntelligenceCryptography and Security
The gist
New rules in Europe require AI systems to mark their text so people can tell it's AI-made. The authors looked at how well one popular watermark system works and found it hard to verify claims about its quality and invisibility. They tested the watermark on normal writing and computer code and found it had little effect on regular text but made code slightly less correct. They also pointed out that there aren’t enough tools or rules to check whether these watermarks work as promised. The paper suggests we need better transparency and ways to audit AI watermarks to trust them.
Open → 2609.09604v1

Flaws found in transformer explanation method with economic based fix

Unraveling the Real Working Mechanism and Inherent Flaws of GAE: A Method for Interpreting Transformer Processes from an Economic Perspective

Abstract: We observe a phenomenon that current algorithmic research in the field of explainable artificial intelligence primarily pursues better performance on several proxy metrics. On the one hand, these proxy metrics themselves are more or less flawed and cannot properly measure the quality of methods. On the other hand, metric-oriented research approaches often lead to the neglect of the rationality and interpretability of the methods themselves. Explainable artificial intelligence is abbreviated as XAI. The metric-driven research paradigm has resulted in a lack of interpretability of the relevant XAI methods themselves. Accordingly, there is a need for interpretability research on XAI methods, which can be playfully referred to as XXAI. This paper is one of our works on XXAI. This paper takes Generic Attention-model Explainability (GAE), a widely influential model interpretation method , or rather, XAI method that represents an important technical route, as the research object, and explores the real working mechanism and flaws of this method as well as the technical route it represents. Based on the conclusions of this study, it may be necessary to re-examine or verify GAE-related methods and their domain applications. We argue that GAE is an interpretation method that focuses on the attention process. After pointing out the working mechanism and flaws of GAE, we propose Cumulative Asset Holdings (CAH), a more reasonable Transformer interpretation method integrating both process-based and feature-based ideas from an economic zero-sum games perspective. In addition, it is worth noting that our method is applicable to models with special tokens, where existing methods may suffer from limitations. The model simplification research method and the analysis of additive operations adopted in this study may provide inspiration for other research works in XAI.

Mon 7 SeptArtificial IntelligenceComputer Vision and Pattern Recognition
The gist
Current methods for explaining how AI transformers make decisions often rely too much on imperfect metrics, leading to unclear explanations of how the methods actually work. The authors studied a popular explanation method called GAE and discovered some problems with it. They then proposed a new method named CAH that combines ideas from process and features, using concepts from economic zero-sum games to better interpret these models. This new approach also works well with special tokens, where other methods struggle.
Open → 2609.07213v1