Papers for

software developers building ai tools

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.

Constrained tagging ensures exact span labeling in text outputs

Constrained Tagging for Span Labeling

Abstract: Generative LLMs can label spans without task-specific training, but their output is not tied to positions in the input: a returned span may be absent from the input or occur several times. We present constrained tagging, a training-free method in which the model reproduces the input and wraps each span in labeled inline markup. A logits processor using a byte-level token trie and a finite-state machine admits only tokens that continue the input verbatim or form a valid tag, so the output reproduces the input exactly with labels from the given set, and spans may begin or end at any character boundary, even inside a token. Two-phase decoding lets reasoning models reason before the constraint engages. On six datasets and six open-weight models, the guarantee holds in all but 0.022% of 255,312 constrained generations, each failure a reasoning model exhausting its token budget or never closing its reasoning, and the constraint adds no measurable cost. Unlike context-based prompting, which loses 8.5% of its spans, constrained tagging locates every span it proposes on every dataset; it is as accurate on two datasets, and on the other four its errors lie in which spans the model chooses, not where they are.

Tue 20 OctInformation Retrieval
The gist
Labeling parts of text accurately is tricky because sometimes models guess spans that don’t exactly match the input or appear multiple times. The authors propose a method called constrained tagging, which forces the model to reproduce the input text exactly but wrap certain parts with special labels. This method uses rules to allow only valid tokens that keep the input unchanged while adding tags, making it easier to know precisely where each labeled span starts and ends. Tests on many datasets showed this method found every span it labeled and did so without slowing down the model.
Open → 2610.28922v1

Frontier ai models struggle to pick best training data sets reliably

DataSense-Bench: The First Step Toward an AI Scientist

Abstract: As claims about recursive self-improvement (RSI) and artificial general intelligence (AGI) proliferate, we ask a simple question: do frontier AI models have a sense of data, i.e., can they reliably select the right data for training? We introduce DataSense-Bench to study this capability through the fundamental problem of data selection and performance forecasting in machine learning. We ask AI agents to select and rank candidate training subsets that can be used to fine-tune a small LLM model. Agents are allowed to inspect the data, write and execute analysis code, and run model forward passes, but can not train the model or access the actual evaluation tasks. We then fine-tune the base model on each selected subset and evaluate its post-training performance under a standardized protocol. We instantiate the benchmark in terminal problem solving and tool use, selecting trajectories from OpenThoughts-Agent and EnvScaler and evaluating on TBLite and BFCL, respectively. We then evaluate the agents along two complementary dimensions: the post-training performance of the top-ranked subset, reflecting the ability to identify high-value training data, and ranking accuracy, reflecting the ability to predict the relative performance of the selected subsets. In our experiments, selection gains over random selection are limited; agents do not reliably rank their selected groups, and ranking ability does not hold consistently across tasks: Astra identifies the best group in all three tool-use runs but in only one of three terminal runs. Analysis of execution traces on both tasks shows that agents often use similar data signals while interpreting their training value differently.

Thu 8 OctMachine Learning
The gist
Picking the right data to train AI models is important but hard. The authors created DataSense-Bench to test if AI systems can choose the best pieces of data to improve a small language model. These AI agents can look at and analyze data but can't train the model themselves. The results showed that the agents only slightly did better than random at picking useful data, and they often disagreed on which data was best. This means current AI systems don’t yet have a reliable “sense” for choosing training data.
Open → 2610.12190v1

Latent sequence compression affects language model capabilities differently

SemanticFold: Latent Sequence Compression SeparatesLanguage Modeling, Decodability, and Reasoning

Abstract: We study whether latent sequence compression of prompt prefixes preserves the capabilities that large language models rely on during inference. We introduce SemanticFold, a compression scheme that folds prefix hidden states at learned boundaries, and evaluate it across five model scales: Qwen3-1.7B, Qwen3-8B, SmolLM2-1.7B, Pythia-1.4B, and Pythia-6.9B. We use a fixed-target protocol: a frozen prefix is executed natively or compressed, and both arms teacher-force identical continuation tokens. This design rules out target-selection explanations for likelihood changes. We examine five endpoint families: fixed-target negative log-likelihood, finite-label reasoning accuracy, linear probe accessibility, open-ended generation, and systems-level memory and latency. We find that compression moves these endpoints non-monotonically and that they do not share a single compression threshold. On Qwen3-1.7B at compression ratio R=1.7, compressed-minus-native mean NLL decreases by 0.135 under paired bootstrap with 10000 draws. On SmolLM2 at R=1.2, the mean change is 0.013 higher than native. On both Pythia checkpoints, NLL is effectively unchanged. An NLL decomposition separating sequence shortening from the learned residual transform shows that the favorable Qwen likelihood is attributable primarily to residual adaptation rather than to shortening alone. MLP-only, which applies the transform without shortening, achieves 0.082 lower NLL than Full SemanticFold. Linear probe accuracy and macro AUC change by less than 0.03 in absolute value across conditions, with confidence intervals crossing zero. We conclude that preservation under latent compression has no single scalar certificate: language-model fit, decodability, and reasoning behavior answer different questions and can move in different directions under the same compression operation.

Wed 7 OctMachine LearningArtificial IntelligenceComputation and Language
The gist
This paper looks at whether compressing parts of a language model's input affects how well the model works. The authors introduce a method called SemanticFold that compresses the model's initial information and test it on several types of models. They find that compressing doesn't have a consistent effect on different measures like prediction accuracy, reasoning, or speed. In some cases, the model even performed better after compression, but the effects vary depending on what is measured. The study shows that compressing language model inputs can impact various abilities in different ways.
Open → 2610.10304v1

Stabilizing the critic improves training for language model reinforcement learning

EasyPPO: Stabilizing the Critic Is Key

Abstract: A key strength of Proximal Policy Optimization (PPO) is its learned critic, which uses historical trajectories collected during reinforcement learning to estimate expected returns and reduce policy-gradient variance. However, we find that the critic is also a major source of instability in reinforcement learning for large language models (LLMs). We identify two critic failure modes that destabilize PPO. First, filtering truncated rollouts from both actor and critic shifts the policy objective to reward conditioned on completion, allowing truncation to increase even as conditional reward improves. Second, heterogeneous return noise can cause high-variance prompts to dominate critic updates in finite batches. We introduce EasyPPO to address these failures. Actor-only overlong filtering trains the critic on returns from both completed and truncated rollouts. Noise-normalized critic regression weights each prompt's critic loss by the inverse standard deviation of its sampled returns, balancing noise contributions across prompts. Moderately smaller critic mini-batches confine outlier influence to fewer rollouts during gradient clipping. Across continuous-reward coding on FrontierCS, binary-reward mathematical reasoning on AIME24, and multi-turn search on Search-R1, EasyPPO remains stable throughout the full training horizon and consistently outperforms vanilla PPO, VAPO, and HL-Gauss PPO. Its best validation scores show relative gains of 14.89%, 2.28%, and 9.47% over PPO, respectively.

Tue 29 SeptMachine Learning
The gist
Training large language models with reinforcement learning often becomes unstable because the component estimating future rewards, called the critic, can fail in ways that confuse learning. The authors find two key problems with the critic that cause this instability during training. They introduce EasyPPO, a modified training method that keeps the critic stable by carefully adjusting how it learns from both complete and partial experiences and by controlling noisy updates. Experiments show that EasyPPO leads to more stable training and better performance on tasks like coding, math reasoning, and search.
Open → 2609.36802v1

Comparing transformers and state-space models for sequential learning

A Comparative Analysis of Attention versus State-Space Models for In-Context Learning

Abstract: Transformers and state-space models (SSMs) are two prominent sequential learning architectures, yet their comparison remains largely empirical and existing theoretical analyses are typically task-specific or architecturally restricted. In this paper, we develop belief geometry, a unified analytical framework for comparing the representational capabilities of broad classes of attention and SSMs. Starting from a generalized formulation of in-context linear regression and using cumulative Bayes regret as our measure, we abstract three capabilities required by many sequential learning problems in our belief geometry: evidence assembly, belief maintenance, and addressing. We then study three cases of our formulation that isolate these capabilities and yield sharp architectural lessons: For belief maintenance, SSMs attain the optimal regret over stationary aggregation kernels; for positional assembly, SSMs have a memory advantage; and for content addressing, softmax attention has an exponential width advantage over sigmoid-selective SSMs. Experiments with LLaMA-type Transformers and Mamba-2 show that these architectural insights extend beyond our analytically tractable classes and linear-regression testbed.

Sat 26 SeptMachine Learning
The gist
This paper looks at two ways computers learn from sequences of information: transformers, which use attention, and state-space models (SSMs), which handle memory differently. The authors create a new way to compare these models based on how well they can gather evidence, keep track of what they know, and use past clues. They find that SSMs are better at some memory tasks, but attention models have advantages in how they select important information. Their findings are tested both theoretically and practically, showing insights that could guide better design of learning systems.
Open → 2609.32341v1

Transformers learn multiple tasks efficiently by sharing common patterns

Transformers as Cross-Task Learners: Shared Structure Drives Sample Efficiency in In-Context Learning

Abstract: Transformers achieve remarkable performance by jointly learning broad families of tasks during pretraining and adapting to unseen tasks from only a short prompt. Yet a rigorous mathematical and statistical understanding of this phenomenon remains limited. This paper aims to study how Transformers exploit shared cross-task structure and how this structure affects the sample complexity of in-context learning (ICL). Specifically, we characterize task-space complexity through covering numbers under a prescribed metric, thereby quantifying the low-dimensional cross-task structure without requiring an explicit parametric representation. The resulting cover provides a set of anchor functions, which we use to introduce a task-identification-and-evaluation procedure: context observations localize an unseen task among the anchor functions, and the response at a query is predicted by aggregating the corresponding anchor function query evaluations. For approximation, we explicitly construct a Transformer with Softmax attention to approximate this procedure. For generalization, we derive an error bound that separates the effects of the number of pretraining tasks and the prompt length. The scaling with respect to the number of pretraining tasks is governed by the intrinsic dimensions of the task space and input domain; once sufficiently many tasks are available, the dependence on the prompt context length becomes dimension-free. To the best of our knowledge, this is the first work to quantify cross-task complexity for general nonlinear task families and explicitly construct a Transformer that exploits their low-dimensional structure to perform ICL. Our theory provides a quantitative explanation of how joint pretraining across related tasks improves in-context generalization.

Thu 24 SeptMachine Learning
The gist
Transformers, a type of AI model, can quickly learn new tasks with only a small example prompt because they recognize common structures shared across many tasks. The authors study how these shared patterns reduce the amount of data needed for learning new tasks in context. They provide a mathematical way to measure how complex the space of related tasks is and build a Transformer model that mimics this approach. Their results explain why training on many related tasks helps Transformers adapt better to new ones with limited examples.
Open → 2609.29060v1

Adaptive red teaming finds more weaknesses in large language models

CART: Closed-Loop Adaptive Red Teaming for Large Language Models

Abstract: Automated red teaming often replays a fixed set of prompts, which measures known risks but cannot learn from failures found during testing. We present CART (Closed-Loop Adaptive Red Teaming), a framework that uses each result to guide what it tests next. CART begins with broad risk coverage, follows weaknesses that emerge, keeps new probes diverse, and records the evidence and source of every finding. It separates the Challenger that creates tests, the Target being tested, which may be a text-only model or a bounded tool-using agent, and the Judge that evaluates the results, allowing these roles to be studied independently. Across three evaluation families (Frontier, JAH, and Agentic), CART discovers more failures and higher average risk than static seed replay for every Target with an available baseline. The gains extend to tool-mediated agent tests, suggesting that contextual adaptation can reveal weaknesses that direct prompt replay does not exercise. These results describe what the test policies discover, not how often failures occur in real deployments. We also find that Challenger-Judge choices affect the evidence uncovered, highlighting the need for role separation and independent review. Overall, CART turns red teaming from a one-time checklist into a continuous, adaptive, and auditable search for model and agent weaknesses.

Wed 23 SeptArtificial Intelligence
The gist
Testing large language models usually involves using a fixed set of questions, which only finds known problems. This paper presents CART, a method that learns from each test to decide what to check next, helping find more and different issues. CART separates the roles of creating tests, the model being tested, and judging results, making the process clearer and easier to improve. The authors show that CART finds more serious problems than fixed tests and works even for complex agents using tools.
Open → 2609.27336v1

Continuous optimization enables machine learning with p-adic numbers

Continuous Optimization for p-adic Models

Abstract: We present the first method for native, continuous gradient descent for machine learning models with $p$-adic parameters. Existing native optimizers are discrete, mostly combinatorial searches, as the $p$-adic numbers $\mathbb{Q}_p$ are totally disconnected, with standard losses that are flat away from their minima. To enable continuous optimization, we propose working with $\mathbb{Q}_p$ via its Berkovich affine line: a canonical, path-connected expansion of $\mathbb{Q}_p$ that preserves its isometries and uniquely extends its analytic maps. This hull is a metric tree with interpretable points and local derivatives, which we show enables effective optimizers and backpropagation. We formulate gradient descent and show that its approximations efficiently learn linear models with coefficients in $\mathbb{Q}_p$ to do modular arithmetic, an XOR-like task not expressible by linear models in $\mathbb{R}$. We also demonstrate momentum and Adam variants, linear regression, and classification on binary-encoded hierarchies (Quillian semantic networks), addressing open problems posed by Martins (2025). Library at https://github.com/google-deepmind/padic-ml

Mon 21 SeptMachine Learning
The gist
Machine learning models usually use regular numbers, but some tasks need special number systems called p-adic numbers, which are tricky because they don’t behave like normal ones. The authors found a way to do smooth optimization with p-adic numbers by using a special mathematical space that makes them behave more like normal numbers. This method helps train models that can perform tasks, like modular arithmetic, which regular models cannot do easily. Their approach also works with common training techniques like momentum and Adam.
Open → 2609.25501v1

Unitboost improves compound AI systems with transparent output merging

UnitBoost: Managing Compound LLM Systems with a Merge Operator, Not a Model

Abstract: Compound LLM systems often solve a coordination problem by adding a higher-level LLM. The resulting meta-agent reads workers' outputs, writes the final answer, allocates later calls, and decides when to stop. It is expressive, but it also concentrates three control decisions in an opaque, order-sensitive model call. We ask whether the manager needs to be generative at all. UnitBoost replaces that model with a defined meta-level operator: a task-given unit map turns worker outputs into slot-value proposals, a constrained argmax assembles the output, and the slots left unfilled or unsupported become an explicit residual for the next round. The operator is order-free, records unit provenance, and gives a simple guarantee: without coupling constraints, unit-wise maximization under the same admission score dominates selection of any complete candidate. On three held-out benchmarks, it exceeds the best single candidate chosen with gold labels by 0.060-0.195 absolute task-score points and input-matched generative managers by 0.048-0.076. Replacing only the management step improves six compound-system configurations by 0.013-0.182. Residual-directed rounds raise FanOutQA cell F1 from 0.4778 to 0.5524; matched controls show that the true residual outperforms random targets and ordinary rereading, while a label-free supply signal flags exhaustion after one unproductive round. The same analysis measures three conditions in which no such gain is available (one indivisible unit, unavailable unit identity, and an endpoint that charges for every emitted unit) and quantifies cross-unit coupling as a repair cost. The manager gives up semantic freedom and gains order invariance, unit provenance, and testable failure conditions.

Wed 9 SeptArtificial IntelligenceComputation and LanguageMultiagent Systems
The gist
Large language models (LLMs) that work together usually need a special manager model to combine their answers. The authors show that this manager doesn’t need to generate text to do its job. Instead, their approach called UnitBoost uses a clear method to pick the best parts from each model's answer, making the system easier to understand, less sensitive to order, and more reliable. Tests on several tasks showed UnitBoost gave better final answers than other ways of managing multiple LLMs.
Open → 2609.09815v1