Your paper timeline
Scroll AI takes the way you would scroll a great paper aggregator: quick signal first, deeper critique when something earns your attention, and challenges when a claim feels off.
698 papers in cs.AI
Trending mixes fresh papers with community signal.
0
cs.CLcs.AIcs.DL Clemencia Siro, Laura Hollink · Oct 22, 2026

Museum description generation is usually framed as a data-to-text task where richer metadata improves grounding, yet heterogeneous and unevenly documented catalogue records break that assumption. This paper introduces a two-phase framework—observational across 10,250 artefacts and controlled across 500 objects—to isolate how metadata quantity, field type, and image access shape what LLMs include, omit, and infer. The central finding is that field identity, not just field count, determines faithfulness: context fields are omitted while content fields trigger unsupported elaboration, and images can increase inference rather than grounding. The authors argue that aggregate reference similarity masks these failures and motivate field- and claim-level evaluation.

Metadata-conditioned generation is often framed as a data-to-text task in which additional input fields should improve grounding. Museum description generation challenges this assumption because catalogue records are heterogeneous, partially visual, and unevenly documented across geographic regions. We study how metadata composition shapes the generation of artefact descriptions through a two-phase framework. Phase 1 analyses natural metadata variation in a large museum collection, where field count, field type, image availability, and Place co-vary. Phase 2 introduces controlled field probes that hold object identity fixed while varying metadata quantity, field type, and image access. Our results show that metadata quantity alone does not explain generation behaviour. Field type determines whether models ground, omit, or infer information, while images can both support visual grounding and increase unsupported interpretation. More broadly, our findings show that metadata-conditioned data-to-text evaluation should assess field- and claim-level support, rather than relying only on aggregate input coverage or reference similarity.
0
cs.AIcs.LG Aman Behera, Payal Payal · Oct 22, 2026

The paper asks whether offline audits can reliably certify that an agent update will be safe once deployed. It formalizes the post-audit mirage by constructing matched safe and harmful lifecycles that expose byte-identical public evidence to the verifier while an isolated scorer records opposite deployment truth. The authors prove a non-identifiability theorem at this audit interface, instantiate it in an exact benchmark spanning authorization, scheduling, and shared-capacity environments, and propose a fail-closed monitor that uses fresh group-labelled harm outcomes to decide only when the evidence supports it. The core message is that correctness checks on fixed observations cannot substitute for missing deployment information.

Offline tests can fail to reveal whether an agent update will remain safe after deployment. We operationalize this post-audit mirage using matched safe and harmful lifecycles that expose identical verifier-visible evidence while an isolated scorer records opposite deployment truth. Our theorem applies standard observational-equivalence and indistinguishability ideas to this executable audit boundary and states the resulting error-abstention tradeoff. The Post-Audit Mirage benchmark makes that boundary executable across authorization, scheduling, and shared-capacity environments. IdentifiedRangeMonitor uses fresh group-labelled harm outcomes to return deploy, hold, cannot determine, or unsupported. Experiments show that monitoring can recover the missing distinction in favorable settings but may remain undecided for rare groups, small effects, or missing observations. Verifier-agent evaluation must therefore test both calculation validity and whether the available evidence supports the deployment decision.
0
cs.AIcs.HC Valentino Sacco, Saurabh Pandey, Alexander Florian Jercher et al. · Oct 22, 2026

Existing computer-use benchmarks conflate planning, reasoning, and execution, making it hard to pinpoint exactly where agents fail at precise visual control. PointerBench introduces a diagnostic suite of 1,500 static screenshot–instruction pairs that isolates fine-grained GUI grounding into three tracks: spreadsheet geometry, character-level text targets, and professional-application controls. The work matters because it reveals that even top frontier models drop sharply on thin structural elements and text carets, while specialist grounding models lag further behind, exposing substantial headroom before agents can reliably manipulate dense professional interfaces.

Multimodal Large Language Models have shown promising performance in computer-use tasks, from planning user workflows to grounding natural-language actions to precise UI targets. Existing end-to-end benchmarks primarily emphasize long-horizon task completion, while GUI grounding benchmarks remain focused on conventional controls and a limited set of professional interfaces. We introduce POINTERBENCH, a diagnostic suite of 1,500 screenshot-instruction pairs probing three complementary capabilities: thin sub-element identification and geometric grounding in spreadsheets (POINTERBENCH-Sheets), character-level grounding in long-text documents (POINTERBENCH-Text), and mixed GUI grounding across 100 professional applications (POINTERBENCH-Pro). We carefully curate each task with pixel-exact target geometry and evaluate both general-purpose multimodal models and 39 specialist GUI grounding configurations. We find text grounding to be the most challenging setting, with Claude Fable 5, GPT-5.6 Sol, and the leading native specialist UI-Venus-2-9B achieving 69.6%, 53.4%, and 25.8% success on POINTERBENCH-Text despite respective 83.2%, 77.7%, and 54.5% average success across POINTERBENCH. These results reveal substantial headroom in fine-grained GUI grounding across frontier and specialist models. We publicly release the benchmark and evaluation code at https://github.com/warmwindOS/pointerbench.
0
cs.AI Zhefan Rao, Meng Chu, Xuan Zhang et al. · Oct 22, 2026

Dual Exam proposes evaluating Multimodal Agents and World Models separately under controlled conditions, rather than as a coupled system. The framework holds environment responses fixed to test Agents and fixes action interventions to test World Models across physical, digital, social, and scientific domains. By diagnosing component-level failures rather than assigning blame from end-to-end outcomes, it provides a principled basis for studying reliable interaction at scale. The evaluations cover 1,088 Agent items and 400 World Model cases, though the authors explicitly caution that the resulting profiles do not directly predict coupled performance.

World Models (WMs) can support Multimodal Agents (MAs) through simulated experience, while Agent trajectories can inform World Model refinement. Evaluating this interaction requires separate evidence about action selection and state evolution. We introduce Dual Exam, which tests Agents under fixed environment response mechanisms and World Models under fixed action interventions across physical, digital, social, and scientific domains. The Agent track compares 10 configurations on 1,088 items in 15 reporting categories. The World Model track contains 400 cases across eight scenarios; 15 configurations have full coverage and one covers six scenarios. GPT 6 Astra leads the case-weighted Agent Index at 31.3, and GPT-Image-2 leads the full-coverage WM Overall at 21.7. These scores use different tasks and metrics and are not directly comparable. A 150-case pilot of one coupled pairing records zero task successes and motivates component-level diagnosis. Results reveal uneven task performance and failures to preserve task-relevant state. Their value for predicting coupled success or sustained reciprocal learning remains to be established.
0
cs.AI Quoc Phong Dao, Binh Anh Nguyen, Linh Ngo Van et al. · Oct 22, 2026

Large language models increasingly expose detailed reasoning traces that help users but also provide rich supervision signals for unauthorized distillation by competitors. This paper proposes Conflict-Aware Logit Adapters (CALA), a lightweight training-time defense that attaches a small residual adapter to a frozen teacher and uses a virtual proxy-student ascent step to identify fragile imitation positions. By encoding anti-distillation perturbations into the model rather than imposing them at decoding time, CALA aims to preserve teacher utility and fluency without the online overhead of prior decoding-time approaches such as Antidistillation Sampling (ADS).

While reasoning traces improve model capability, they also provide supervision signals for downstream distillation. Initial efforts to mitigate this issue rely on decoding-time interventions, but they incur high inference overhead and can harm the teacher model's natural fluency. We propose Conflict-Aware Logit Adapters (CALA), a lightweight training-time defense. CALA attaches a small residual adapter to a frozen teacher model and trains only the adapter. A proxy student identifies positions where imitation is most sensitive, and the adapter perturbs the output distribution at these positions while remaining within high-probability regions. A conflict-aware optimization strategy balances anti-distillation and utility objectives, while regularization preserves the teacher's performance and fluency. At inference time, CALA incurs modest overhead and requires no auxiliary model. Experiments on reasoning benchmarks show that CALA substantially reduces successful student imitation while maintaining near-original teacher performance and generation quality. These results establish CALA as a practical and efficient alternative to decoding-time approaches.
0
cs.AI Yuannuo Feng, Yubing Ye, Wenshuai Yao et al. · Oct 22, 2026

Diffusion language models generate tokens in parallel, but few-step decoding makes it hard to decide which predictions to commit at each iteration without losing future conditioning opportunities. SetCommit is a training-free coordinator that sits between the model forward pass and the decoder state update, selecting commitment sets by balancing per-token reliability against a heuristic local joint risk and allowing budget-neutral exchanges of vulnerable earlier commitments. On LLaDA-8B and Dream-7B, the authors report quality gains up to 7.4 percentage points and geometric-mean incremental speedups of $1.44$--$1.74\times$ across reasoning and code tasks at common quality targets.

Diffusion language models generate multiple token positions in parallel, but few-step decoding makes parallel commitment difficult: tokens that appear reliable individually may be jointly inconsistent, while premature commitments can prevent later context-dependent refinement. In this paper, we introduce SetCommit, a training-free method for coordinated parallel token commitment. Instead of selecting tokens independently by confidence, SetCommit selects a commitment set that balances token reliability against local joint commitment risk, preserving conditioning opportunities for subsequent denoising steps. It further performs budget-neutral local exchanges, replacing vulnerable earlier commitments when newly revealed context supports more reliable alternatives. SetCommit requires no retraining or architectural modification and is compatible with existing diffusion decoding strategies. Experiments with LLaDA-8B and Dream-7B on GSM8K, MATH-500, MBPP, and HumanEval show accuracy/pass@1 gains of up to 7.4 percentage points over native decoding at 32 model evaluations. At common quality targets, geometric-mean incremental speedups range from $1.44$ to $1.74\times$. Code is available at https://github.com/Kissmetothemoon/SetCommit.
0
cs.CLcs.AIcs.LG Asal Mehrabi, Mohammad Aliannejadi, Clemencia Siro · Oct 22, 2026

LLM-as-a-Judge is widely used for multilingual evaluation, yet prompting strategies are usually validated only in English. This paper tests whether those strategies transfer across judge models and languages by benchmarking nine prompting strategies with four open-weight judges on 27 languages and four tasks. The central finding is that judge identity dominates prompting effects, with strategy effectiveness reversing across models and collapsing in low-resource languages, underscoring that prompt design must be validated per judge and language.

LLM-as-a-Judge evaluation is increasingly applied to multilingual tasks, yet prompting strategies such as Chain-of-Thought and Role Conditioning are recommended based solely on English benchmarks. Whether their effectiveness transfers across judge models and languages remains unknown: prompt-sensitivity studies are largely English-centric, while existing multilingual judge studies fix the prompt template. In this work, we address this gap by measuring this interaction through a benchmark of 9 prompting strategies, 4 open-weight judges, 27 languages, and 4 tasks across 13 datasets, yielding over 1M pointwise scores on gold-reference outputs, validated against human judgments. We find that prompting strategies are not transferable: the choice of the judge model dominates the choice of prompting strategy, strategy effects reverse direction across judges, and stability degrades in low-resource languages, where these effects are concealed by aggregate reporting. These findings show that prompting effects in multilingual evaluation are conditioned on the judge, task, and language. Consequently, prompting strategies should be validated for the intended evaluation setting, and cross-study comparisons should account for both judge and prompt configuration.
0
cs.CLcs.AI Yijiang River Dong, Zexue He, Cheng Yu et al. · Oct 22, 2026

This paper investigates whether giving LLMs access to personal user memory actually improves responses from the user's perspective. The authors collect roughly 1,000 pairwise preferences from 87 participants judging responses to their own ChatGPT queries, with and without memory conditioning. Their central finding is that memory-augmented responses are not consistently preferred and can backfire, while off-the-shelf evaluators systematically overestimate the value of personalization. To close this gap, they introduce a rubric-based memory-aware reward model $R_{\theta}(q,y,M)$ that learns from real user judgments to predict when memory use is appropriate, achieving 72.8% accuracy on held-out participants versus ~59% for zero-shot LLM judges.

Memory enables language model assistants to maintain continuity across sessions and generate personalized responses, but knowing more about a user does not necessarily produce responses they prefer. Existing evaluations assess memory capabilities without directly establishing whether memory use benefits the user. To study this gap, we collect approximately 1,000 pairwise judgments from 87 participants using their own ChatGPT queries and personal memories. We find that memory-conditioned responses are not consistently preferred over responses generated without memory and in some cases, users strongly prefer the latter. Automatic evaluators also show limited agreement with users and favor memory-conditioned responses substantially more often than users do. Motivated by these gaps, we introduce a memory-aware reward model that learns from user judgments, achieving 72.8\% preference prediction accuracy and outperforming the existing baselines. Our findings motivate evaluation and optimization objectives that align memory use with the preferences of the people whose information is being used.
0
cs.AI Firuz Kamalov, Hana Sulieman, Ahmed El Sayed et al. · Oct 22, 2026

Generative adaptive tutoring systems risk trapping marginalized learners in remedial loops when LLM graders misread linguistic variation as conceptual error. Kamalov et al. formalize this 'algorithmic drift' as a coupled dynamical system, prove a bifurcation threshold $\epsilon^\star = 1 - p^\star/\sigma(\omega)$, and propose a Temporal Fairness Stabilizer (TFS) that periodically forces difficulty probes to break the feedback loop. The work reframes educational fairness as a longitudinal property of closed-loop control rather than a static deployment audit.

Generative artificial intelligence promises to democratize personalized tutoring, yet the longitudinal stability of adaptive systems remains under-theorized. Current ethical discourse focuses on static bias. This paper argues that a distinct threat lies in algorithmic drift: a feedback loop in which minor, demographically asymmetric observation errors compound over time into systemic inequities. We make three contributions. First, we formalize algorithmic drift as a coupled learner--tutor dynamical system. Second, we corroborate this theory with an agent-based Monte Carlo simulation in which either a transparent online tracker or an LSTM deep-knowledge-tracing network drives an IRT-based curriculum policy. Third, we introduce the temporal fairness stabilizer (TFS), a targeted intervention that periodically re-probes learner capability, and benchmark it against standard exploration baselines with explicit group-fairness metrics and replication-level inference. Within the modeled environment, TFS closes the achievement gap where generic exploration does not, and we characterize the conditions under which it succeeds. We separate what is established analytically, what is demonstrated in simulation, and what remains to be validated with real learners. Our results reframe algorithmic fairness in education as a temporal property of a closed loop rather than a deployment-time checkbox.
0
cs.LOcs.AI D\"orthe Arndt, Pierre-Antoine Champin · Oct 22, 2026

Notation3 (N3) Logic extends RDF with graph terms—entire graphs used as terms in triples—to support statements about statements and rule-based reasoning. This paper fills a long-standing gap by providing the first comprehensive formal semantics for these graph terms, introducing an abstract syntax and a two-layer semantics (basic entailment followed by N3-entailment for built-in predicates). The work matters because N3 has lacked a standardized model-theoretic account, leaving implementations like EYE and Cwm without a common semantic foundation.

Notation3 Logic was introduced as an extension of RDF allowing the user to express rules on top of triples and to make statements about graphs. The original proposal of the logic only came with an informal specification of its semantics which has been refined later on. While this refinement clarified the meaning of rules and implicitly quantified variables, it left the meaning of graphs used as terms - so-called graph terms - open. In this paper we aim to close this gap. We discuss in detail, how graph terms are used in Notation3, which formal requirements they need to meet, and provide examples to illustrate the difficulties when defining their semantics. We then introduce an abstract syntax for the logic and define its semantics in two steps: similarly to RDF's simple interpretations, we define interpretations and basic entailment for Notation3 which covers plain RDF triples but also triples containing graph terms. N3-entailment is then an extension of basic entailment which assigns meaning to the different special predicates of the logic like for example the implication symbol. N3-entailment is defined in a way that it can be extended whenever a new predicate is added to the logic. As Notation3 Logic is currently under development, we expect many predicates to be added. Our research provides and important step towards the full standardisation of the logic.
0
physics.soc-phcs.AIcs.CY Roberto Passaro, Ariel Flint, Romualdo Pastor-Satorras et al. · Oct 22, 2026

As LLMs move from isolated tools to networked populations, the structure of who interacts with whom becomes a key safety variable. This paper studies how network topology shapes convention formation and adversarial tipping in populations of up to $10^5$ LLM-derived agents playing the naming game. By placing policies extracted from four models on fully connected, heterogeneous, and sparse regular networks, the authors show that topology modulates convergence speed, can rescue stuck populations, and creates hub-shaped vulnerabilities that well-mixed estimates miss.

As large language models (LLMs) are deployed in interacting populations, their collective behaviour depends not only on the models but also on who interacts with whom. Studies of convention formation in LLM populations have mainly tested well-mixed interactions. We place policies extracted from four LLMs on fully connected, random regular, and heterogeneous networks, with $10^3$ to $10^5$ agents playing the naming game. Topology affects how quickly consensus emerges, sometimes whether it emerges at all, and, in rare cases, which convention wins. Sparsest networks slow consensus up to twelvefold. Yet, by preserving correlations between persistent neighbours, they restore consensus in some cases that fail to converge under well-mixed interactions. Networks also govern vulnerability to adversarial attack. We measure the critical mass of committed agents needed to overturn an established convention. Tipping thresholds follow the same ordering across models and conditions: hubs $\leq$ random $\leq$ low-degree nodes. On the most heterogeneous topology, median critical masses are 3%, 16%, and 35%, respectively; targeting hubs requires one-sixth as many committed agents as random placement. For most models, networked populations are easier to tip than well-mixed ones, so well-mixed estimates can overstate robustness. Assessing the safety of multi-agent AI requires mapping who interacts with whom.
0
cs.AI Roger X. Lera-Leri, Filippo Bistaffa, Athina Georgara et al. · Oct 22, 2026

Optimisation-based decision support systems recommend schedules or plans by solving mixed-integer programs, but end users often ask "why not X?" contrastive questions that are hard to answer reliably with pure LLMs. This paper proposes LLMxMIP, a pipeline that extracts irreducible infeasible subsystems from a constraint model, organises them into a structured graph of reasons, and prompts an LLM to generate a textual explanation. The work matters because it marries rigorous constraint reasoning with natural language generation to address a real oversight requirement in automated decision-making.

We focus on optimisation-based Decision Support Systems in real-world applications. In this context, we aim to provide contrastive explanations that answer users' questions about recommendations based on the solution of an optimisation problem, specifically a Mixed-Integer Program (MIP). Addressing this endeavour is crucial to ensure human oversight of the decisions implemented, as required by international guidelines on trustworthy and responsible automated decision-making systems. We propose a novel methodology that combines constraint reasoning techniques and Large Language Models (LLMs) to generate contrastive explanations for optimisation problems encoded as MIPs. Although LLMs have shown impressive capabilities in Natural Language processing, they can produce incorrect answers due to reasoning limitations. To overcome these limitations, we leverage constraint reasoning techniques to distil the information necessary to produce an explanation, which is then passed as input to an LLM as the so-called graph of reasons. Such a graph captures the semantics and the relationships among constraints of the optimisation problem. Results on real-world scheduling domains show that incorporating constraint reasoning improves explanations generated by the LLM. In particular, using the graph of reasons enables the LLM to produce natural-language explanations that include more relevant reasons while reducing errors compared to explanations generated without this structure.
0
cs.AIq-fin.RMstat.CO Mariia Kozlova, Roman Stepanova, Alexander Walzer et al. · Oct 22, 2026

Decision-support methods typically evaluate predefined strategies under uncertainty while neglecting the combinatorial architecture of available choices. This paper proposes multichoice modeling, a framework that jointly simulates interdependent decision configurations and uncertain futures, then uses variance-based sensitivity analysis and conditional distribution comparisons to identify influential choices and emergent strategies. Demonstrated on mortgage design, manufacturing upgrades, and M&A strategy, the work reframes decision support from evaluating fixed options to exploring and designing strategy configurations.

Decision support has become sophisticated at exploring uncertainty, but much less so at representing the architecture of the decision itself. As a result, the decision space is often narrowed before uncertainty is analyzed, leaving interactions among choices and the effects of alternatives they imply largely invisible. This paper introduces multichoice modeling, a framework for making large decision configuration spaces explicit and computationally explorable under uncertainty. Drawing on the logic of rugged landscapes, we conceptualize such problems as contingent performance landscapes, where interdependent choices generate configuration-specific outcomes whose value changes across uncertain futures. The computational framework combines multidimensional decision and uncertainty spaces in a single simulation. Further, variance-based sensitivity analysis is used for identifying influential choices, and conditional distribution analysis for comparing configuration-specific performance profiles. We demonstrate the framework through three case studies: a manufacturing process upgrade, M&A strategy, and mortgage design. By contrasting conventional uncertainty-only analysis with multichoice modeling, the cases show how opening the decision configuration space can reveal unexpected complementarities, near-best configurations with different risk profiles, and strategies that were not apparent as alternatives at the outset.
0
cs.SEcs.AI Jiajun Wu, Jian Yang, Yaxin Du et al. · Oct 22, 2026

Frontend coding agents are usually graded only on whether the requested target gets built, but real engineering demands that the rest of the site keeps working. ProductWebBench evaluates this second obligation—website continuity—through 400 frozen tasks where a simulated user reveals requirements stage by stage and every cleared gate remains armed for the rest of the run. Across 8,737 runs from 13 models, 28.2% of Change attempts that pass every requested-work check still fail a continuity check, showing that scoring a patch against the target alone is insufficient.

Frontend coding agents are usually graded on one question: did the requested target get built. Real engineering changes carry a second obligation, because the rest of the site has to keep working. We call that second obligation website continuity, and introduce ProductWebBench, a benchmark that scores both on living frontend repositories: 320 Change tasks over existing code and 80 long-horizon Build tasks. Every task freezes a repository snapshot, staged requirements, browser evidence and deterministic checks before evaluation, and enters only once a reference passes every check and plausible-wrong ones fail. A simulated user reveals the requirements one stage at a time, and every check cleared earlier stays armed for the rest of the run. Across 8,737 runs from 13 models the two come apart: of the Change runs passing every requested-work check, 28.2% still fail a continuity check -- a blank route, horizontal overflow, console errors -- and 10.8% push a browser state they had already passed back to failing. Because the same checks also run on the untouched repository, each regression carries exact provenance, not a post-hoc label: on the 586 runs where both readings exist, 18.3% are caught breaking a verified state. Interaction is a further blind spot, failing in 29.5% of runs whose static DOM already passes. ProductWebBench therefore scores a patch against the living system it lands in, not the target alone.
0
cs.CRcs.AI Yifan Wang, Dongliang Xu, Xiaoyong Li et al. · Oct 22, 2026

SecLog-Bench introduces a benchmark for post-detection cybersecurity log reasoning that requires LLMs to infer attack progress from scaffolded multi-source evidence and produce structured, evidence-referenced reasoning chains. The authors construct 29 reproducible attack scenarios spanning CVE exploits and multi-hop attacks, aligning host audit logs, application logs, and network traffic into stage-labeled evidence windows. Evaluation of eight mainstream LLMs reveals modest attack-stage prediction (best accuracy 44.44%) and unreliable reasoning (best SRF1 54.87%), demonstrating that final-label accuracy alone misrepresents true model capability.

Large language models (LLMs) have shown strong potential for cybersecurity, leading to growing interest in LLM-based automated cybersecurity log analysis. However, current datasets (1) are limited in scale; (2) rely mainly on single-source evidence; and (3) have only binary or multi-class attack labels, without dense annotations of the reasoning process. To address these limitations, SecLog-Bench has three key features. First, we build an extensible simulation platform that covers 29 attack scenarios, supports repeated execution and the integration of new scenarios, and enables scalable generation of cybersecurity logs with attack-stage labels. Second, we use multi-source logs, including audit logs, application logs, and network traffic, to jointly analyze cyber attacks. Third, we annotate each sample with the essential context for cybersecurity log reasoning and a structured step-by-step evidence chain. We evaluate eight mainstream LLMs on this benchmark for post-detection attack-progress reasoning. Results show that, when provided with scaffolded evidence, current LLMs exhibit modest capability in attack-progress reasoning, with the best model achieving only 44.44% accuracy and 45.07% Macro-F1. Their reasoning remains unreliable; i.e., the highest Stage Reasoning F1 (SRF1) score is only 54.87%. Moreover, even correct predictions may be accompanied by flawed reasoning, and reasoning quality is often misaligned with prediction accuracy.
0
cs.CLcs.AIcs.CY Avrile Floro, Tamara Dhorasoo, Nils Holzenberger et al. · Oct 22, 2026

This paper introduces a ground-level dataset of 121,536 ground–reasons pairs extracted from 86,464 French civil cassation rulings spanning 2016–2025. Using a deterministic, rule-based pipeline, the authors pair each legal complaint with the Court’s response and classify the pair into established doctrinal families, producing a descriptive grammar of civil cassation. The resource enables quantitative analysis of which grounds succeed, which legal texts are cited, and how both evolve over time, alongside an interactive consultation tool.

This paper presents a dataset of 121,536 ground-reasons pairs across 86,464 rulings of the five civil chambers of the French Court of Cassation (2016-2025). An appeal on points of law cannot itself be appealed and often decides a case for good. Understanding how the Court rules is thus crucial and can help lawyers who draft those appeals. Inside a ruling, every ground of appeal (a distinct legal complaint against the appealed decision) has its own answer from the Court. This answer is called the reasons and it belongs to one of a few doctrinal families. Using a deterministic pipeline, we pair each ground with its reasons and attach the pair to its family, according to the established French taxonomy. We obtain a descriptive grammar of civil cassation that shows which grounds succeed, which legal texts they refer to, and how both evolve over the decade. We release the dataset, the code and an interactive consultation tool.
0
cs.AI Deng Pan, Xue-Jian Gao, Junyi Fan et al. · Oct 22, 2026

Writing efficient kernels for Huawei Ascend NPUs is notoriously hard because AscendC code is scarce in LLM training data and operator deployment requires coordinating host-side tiling with device-side kernels. CANNBot-CAKE presents a full-stack agentic workflow that turns a natural-language request into a compiled, packaged, and benchmark-validated CANN custom operator. Its key ideas are a multi-DSL router that uses an item-response model to choose among four code-generation tracks, an evolution mode that iteratively refines kernels under a roofline model, and a cross-operator wiki (CAKE Book) that accumulates verified experience. On 53 CANN-Bench operators on Ascend 950PR, CAKE reports 100% standard-case and 98.28% hidden-case pass rates, with a mean score of 78.63/100.

Efficient custom operators are essential for modern deep learning workloads, yet developing high-performance kernels for Ascend NPUs remains slow, expert-intensive, and difficult to automate. Although AI agents now approach expert performance on GPU kernel benchmarks, current models remain less capable of generating AscendC kernels for NPUs, potentially reflecting the relative scarcity of relevant training data. We thus present CAKE, a CANN-native system for deployable custom operators that combines adaptive multi-DSL routing, separate Generation and Evolution modes, and reviewed knowledge reuse through CAKE Book and a Self-Evolving Agent. On 53 CANN-Bench v1.1 operators on Ascend 950PR, CAKE's aggregated results achieve $100\%$ case pass rate on the standard set (1,060/1,060) and $98.28\%$ on the hidden set (4,167/4,240), with an overall mean score of 78.63 out of 100 and an average performance speedup of $1.334\times$ over the baseline. Evolution then pushes correct operators further: EngramGateFusion cuts aggregate device time by $46.6\%$ over 20 rounds and roughly halves the mean roofline gap. These results offer a practical path toward closing Ascend's AI-for-kernel capability gap.
0
cs.GTcs.AIcs.DS Junhua Liu, Zhicheng Liang, Zejun Zhang et al. · Oct 22, 2026

LLM-native advertising introduces new auction-design challenges because an ad’s click-through rate depends on its context passage and earlier ads steal clicks from later ones under a first-click cascade. This paper studies truthful mechanism design when the LLM answer and its passage order are fixed before bidding, showing that a constant-factor welfare approximation is compatible with truthfulness even under this editorial-order restriction. The authors propose click thinning—randomly omitting earlier ads to equalize click services across positions—which turns welfare maximization into a tractable linear-fractional matching problem and yields an elegant optimal tradeoff between approximation, truthfulness, and computational efficiency.

Generative AI assistants are becoming an advertising medium, embedding sponsored content in their answers. This setting departs from classical position auctions in two ways: an ad's click-through rate depends on the passage that hosts it, and because users stop at their first click, earlier ads take clicks from later ones. This competition for clicks makes truthfulness delicate: a higher bid can reshape the allocation and put a competitor ahead of the bidder, reducing the bidder's clicks. Existing mechanisms either attain a constant fraction of the optimal welfare (advertisers' total click value) but are not known to be truthful, or are truthful but their welfare guarantee degrades as the number of passages grows. We achieve both even when the answer and its editorial order are fixed before bidding. Assuming each ad's click-through rate when reached is known and unaffected by omitting other ads, we give a computationally efficient mechanism that is truthful in expectation and attains at least half the optimal welfare under free reordering. Our key idea, click thinning, omits ads at random, showing earlier ads less often so that each ad's overall click probability no longer depends on the order of the ads. Welfare maximization then reduces to a tractable matching problem, and solving it exactly with VCG-style payments makes truthful bidding optimal in expectation. Characterizing the click probabilities that omission can achieve sharpens the approximation factor from $2$ to $2-(1-\delta)^{K-1}$ when at most $K$ ads are shown and each click-through rate is at most $\delta$. This factor is the best possible for any order-preserving rule, even one that ignores incentives and computation, so truthfulness and computational efficiency incur no additional worst-case loss.
0
cs.AI Prajvi Saxena, Sabine Janzen, Wolfgang Maass · Oct 22, 2026

The paper diagnoses a critical split in how LLMs handle Theory of Mind: explicitly recognizing an agent's belief versus applying that belief to predict behavior or evaluate actions. It argues that aggregate ToM benchmarks conflate these skills and hide severe applied deficits, then tests whether the gap reflects a capacity limit or merely latent competence that can be recovered via prompting, in-context learning, or lightweight parameter adaptation. The work is motivated by the deployment of LLMs in socially sensitive roles where surface-level mental-state recognition is insufficient for trustworthy interaction.

As large language models are deployed in high-stakes roles such as therapy, education, and personal assistance, their social cognition must be assessed reliably. Current Theory of Mind (ToM) benchmarks report aggregate scores that conflate two distinct competencies: explicit ToM (recognizing what someone believes) and applied ToM (using that belief to predict behavior). Building on this distinction, we investigate the gap and its recoverability using four structurally diverse benchmarks. Aggregate reporting obscures uneven competence: on SimpleToM, Llama-3.1-8B scores 51.5 percent overall while recognizing mental states at 99.4 percent and predicting behavior at only 28.9 percent. To assess recovery, we compare structured prompting, matched in-context learning, and our proposed Belief-State Test-Time Training (BSTTT), which adapts lightweight parameters on answered support questions through action reconstruction. Across Qwen2.5-7B, Llama-3.1-8B, and GPT-oss-20B, recovery depends on the model, task, and intervention. On SimpleToM, reminders combined with BSTTT improve Llama's behavior prediction by 40.8 percentage points; reminders account for most of the overall improvement, with BSTTT adding 1.3 to 5.5 points beyond reminders across models. Contextual examples often outperform weight updates, while BSTTT remains stronger in specific model-benchmark settings. Temporal belief tracking remains difficult despite partial recovery. These findings show that aggregate ToM scores can overstate applied competence while hiding performance recoverable through targeted assistance. We recommend decomposed reporting of explicit and applied accuracy alongside intervention comparisons that establish which failures are recoverable and under what conditions.
0
cs.AI Ricardo Maia Avelino, Mennatallah El-Assady, Tom Van Mele et al. · Oct 22, 2026

Early-stage structural design is an iterative, creative process that balances form, force, and material. This paper proposes a proof-of-concept workflow connecting a large language model agent to a COMPAS-based structural modeling API via a Model Context Protocol (MCP) server, enabling natural-language generation and editing of semantic building elements. By producing explicit graph-based artifacts rather than generic meshes, the work aims to reduce modeling friction and move toward human-AI co-design in structural engineering.

Recent advances in large language models and agentic workflows offer a new paradigm to early-stage structural design translating design intent into structural models. Although text-to-3D approaches have demonstrated that natural language can be used to produce visual, mesh-based geometric models, structural design requires domain-specific geometric arrangements and semantically rich data types. This paper introduces a proof-of-concept workflow for prompt-to-structure generation using an AI agent connected to a COMPAS-based structural modelling API through a Model Context Protocol (MCP) server. Through controlled modelling operations, the agent creates and modifies a graph-based structural data model composed of explicit building elements. The resulting artifacts can be inspected, modified, serialised, and further connected to downstream AEC workflows. The approach is demonstrated through selected prompt-to-structure examples and by progressive and editable design sequences that resemble typical iterative structural design workflows. The results are preliminary, but demonstrate the possibility of combining natural language, agentic workflows, and domain-specific structural data structures as a first step toward AI-assisted structural co-design.