Papers for

customer service platforms

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.

Arabic function calling model scores top in dialect robustness test

QMUL_AK at AISA-ArabicFC: Schema-Constrained Function Calling with ALLaM

Abstract: We describe the QMUL_AK submission to AISA-ArabicFC 2026. The system adapts the Arabic-English ALLaM-7B-Instruct model to function calling with low-rank adaptation (LoRA). It combines an Arabic schema-aware prompt, dialect and no-call resampling, a token-weighted training objective, and deterministic validation of generated calls against the candidate tool schema. The same output supports Track A function calling and Track B reasoning-augmented calling. Training uses only the official task data. On the development set, the system achieves 0.9982 function accuracy and 0.8920 argument exact match, corresponding to overall A and B scores of 0.9345 and 0.9454. On the blind test set, the system reaches overall A and B scores of 0.9253 and 0.9380, ranking 3rd on both submission tracks and 1st of 21 teams on the Track C dialect-robustness diagnostic with a macro-averaged score of 0.9075 and the smallest dialect gap in the shared task (0.077). The results show that function selection is nearly saturated, while argument extraction remains the main source of error.

Tue 27 OctComputation and Language
The gist
The paper presents a system that helps computers understand and call functions in Arabic, even when different dialects are spoken. The authors adapted an existing Arabic-English language model to improve how it recognizes function calls and their details. Their system performs very well on official tests, ranking third overall and first in handling dialect differences. The study shows that while it's easy to pick the right function, getting all the details right is still challenging.
Open → 2610.37995v1

SCOPE compiles clear natural language policies into interpretable neural programs

SCOPE: Compiling Natural-Language Policies into Neurosymbolic Predicate Programs

Abstract: Policy enforcement for LLM agents has shifted from single-turn content moderation to compound, application-specific policies evaluated over multi-turn transcripts and tool-call trajectories. Fine-tuned guardrail models are efficient but degrade on compound policies, and while LLM-as-a-judge approaches achieve higher accuracy, they incur high inference cost and tend to produce unstable predictions. Neurosymbolic methods offer a natural alternative, decomposing the policy into narrow neural decisions composed under explicit logic. However, existing symbolic layers lack the required expressiveness and are optimized against fixed data rather than the policy itself. To address this, we introduce SCOPE, which compiles a policy into an executable program of neural predicates executed by small models, deterministic extractors, and code that composes their outputs. The program is optimized jointly with its training data, using adversarial generation of counterexamples that target where the program deviates from the policy. We evaluate SCOPE on a benchmark of real-world policy tasks against prompt optimization, task decomposition, and workflow generation methods, achieving the highest average accuracy across tasks and models. Programs optimized with the weakest executor transfer to other models without further optimization. This allows them to be deployed in production on inexpensive models, where they reach accuracy comparable to frontier reasoning models. Unlike these monolithic models, SCOPE produces substantially more stable predictions, and each verdict is interpretable through the predicate outputs that produced it. Additionally, we validate the key components of our method through an ablation study. SCOPE thus enables reliable, interpretable, and efficient policy enforcement at production scale.

Thu 22 OctArtificial IntelligenceComputation and Language
The gist
Policymakers need ways to ensure AI assistants follow complex rules over many interactions. The authors introduce SCOPE, a method that turns written rules into small neural programs that work together logically to check if an AI is following those rules. SCOPE learns from examples and keeps improving by finding mistakes, making its judgments reliable and easier to understand. It works well on tricky real-world policy tasks and can run efficiently on simpler AI models.
Open → 2610.31062v1

Language models reveal when they are uncertain during reasoning

U-Space: Uncovering When and Why Uncertainty Arises in Language Models

Abstract: Large language models are informing decisions with ever-higher stakes. As the consequences of their errors grow, a central question becomes harder to ignore: how much can we trust an individual answer? Yet recognizing when to defer remains difficult because language models can present incorrect conclusions with fluent explanations and an authoritative tone. Uncertainty quantification seeks to address this disconnect by estimating the reliability of individual predictions. However, many existing methods require repeated generations or separately trained components, and their scalar estimates do not reveal where uncertainty arises or how it evolves during reasoning. Recent work has also shown that generation length can be strongly associated with uncertainty estimates and correctness, raising the question of how much of an estimator's predictive power comes from uncertainty-specific information rather than output length alone. Mechanistic interpretability offers a way to address these limitations by connecting human-interpretable concepts to intermediate model states. Building on this capability, we introduce the U-Space, a low-dimensional subspace that makes a model's evolving uncertainty measurable and interpretable. We identify semantic anchors for doubt and certainty, map their unembedding directions back into the residual space, and combine their contrasts into an orthogonal basis. The U-Lens projects each token state onto these basis vectors, yielding an interpretable token-level uncertainty map that can be inspected directly or aggregated into a scalar uncertainty score. Our approach requires no correctness labels, repeated generations, or training. Across reasoning benchmarks, its confidence score outperforms established baselines under both standard and length-controlled evaluation and transfers more reliably than supervised estimators. Code: https://github.com/s2labres/U-Space.

Tue 6 OctComputation and LanguageArtificial IntelligenceMachine Learning
The gist
Language models sometimes make mistakes while sounding confident, making it hard to know when to trust them. The authors developed a way to find and measure uncertainty inside the model’s thought process without needing extra training or repeated tests. They created a special space called U-Space that shows where and when the model feels doubt or certainty as it generates answers. This method gives better and more understandable confidence scores compared to older techniques.
Open → 2610.09087v1

Language models resist pressure and use evidence more accurately

Suppressing Pressure, Amplifying Evidence: Self-Guided Attention Steering to Mitigate Sycophancy and Stubbornness

Abstract: Reliable language models should resist unsupported user pressure while effectively using objective contextual information. However, models may exhibit sycophancy by yielding to unsupported user pressure or contextual stubbornness by failing to update their answers when relevant contextual information warrants revision. Evaluating interventions for these failures separately can obscure whether mitigating one failure exacerbates the other. To assess this trade-off, we introduce CoPE-Bench with six conditions per question: a neutral baseline, correct or incorrect user pressure, contextual information consistent with or conflicting with the neutral answer, and a joint condition combining incorrect claims with conflicting contextual information. To regulate the influence of user pressure and contextual information, we propose SPAE (Suppressing Pressure, Amplifying Evidence), a training-free framework that uses the model's own judgments to identify relevant tokens, suppressing user pressure and amplifying contextual information through token-level attention steering. On average across five backbones, SPAE reduces pressure following by 18.8 percentage points and increases joint-condition updating by 5.5 percentage points relative to the strongest baseline in the main comparison. In two-turn dialogue, it improves joint-condition updating by an average of 13.2 percentage points over the strongest prompting baseline. The source data and codes can be found at https://github.com/03Grant/sycophancy-and-stubbornness.

Sat 3 OctArtificial IntelligenceComputation and Language
The gist
Language models can sometimes wrongly agree with a user's incorrect opinion or stubbornly ignore new information that should change their answer. The authors created a way to test if fixing one problem makes the other worse and designed a method called SPAE that guides the model's attention to trust evidence over pressure. This approach helps the model update answers correctly and avoid giving false agreement to users. Their tests show SPAE improves performance across multiple language model types without extra training.
Open → 2610.04329v1