Learning to Allocate: Methods and Applications

• Learning to Allocate is a family of methods that adaptively distributes limited resources, labels, or compute under uncertainty.
• It employs techniques like learned per-agent parameters, censored-feedback, and reinforcement learning to optimize allocation decisions.
• Applications include online fractional allocation, anomaly detection label budgeting, multi-agent task assignment, and adaptive compute orchestration for large language models.

Searching arXiv for recent and directly relevant "Learning to Allocate" papers, plus acronym-disambiguation cases. Across the cited literature, “Learning to Allocate” denotes a family of methods that learn how limited resources, labels, teams, or inference-time compute should be distributed across competing options under uncertainty. The phrase appears in online fractional allocation with learned per-agent parameters, resource allocation with censored semi-bandit feedback, sequential label-budget allocation in anomaly detection, multi-agent task allocation with learned capability and requirement structure, and adaptive test-time compute orchestration for LLMs (Cohen et al., 2023, Montanari et al., 6 Feb 2026, Perini et al., 2023, Fu et al., 2022, Qin et al., 1 Jun 2026). At the same time, the acronym “L2A” is overloaded: in nearby literatures it can also mean “Learning to Augment,” “Learning To Attend,” “Learn2Adapt,” or “Learning-to-Approve,” so the surrounding domain is essential for interpretation (Zhou et al., 2020, Choudhary et al., 18 Mar 2026, Karagkioules et al., 2019, Feng, 2020).

1. Scope and problem families

The common structural feature across these works is an allocation variable that must be chosen repeatedly or amortized over many instances, together with a learning component that estimates latent utility, feasibility, uncertainty, or value-of-computation. Some formulations learn a compact parametric surrogate and then solve an optimization problem; others learn directly from online feedback; still others use inference-time adaptation without separate policy training. This suggests that “Learning to Allocate” is best understood as an umbrella term for learning-augmented allocation rather than a single algorithmic template.

The main problem families represented in the literature are summarized below.

Problem family	What is allocated	Representative paper
Online fractional allocation	Fractions of arriving items to agents	(Cohen et al., 2023)
Online resource allocation under censoring	Budget across arms	(Montanari et al., 6 Feb 2026)
Anomaly detection	Label budget between AL and LR	(Perini et al., 2023)
Multi-agent task allocation	Teams, agents, or VNF instances	(Fu et al., 2022)
Test-time scaling and inference	Solver calls, model choice, layers, heads, reasoning tokens	(Qin et al., 1 Jun 2026)

In the online-allocation line, the most compact formulation uses divisible items arriving online, agent-specific utilities or costs $p_{i,j}$, and a feasible allocation matrix $X=(x_{i,j})$ with $\sum_i x_{i,j}=1$. In that setting, the distinctive result is that a single positive scalar $w_i$ per agent is sufficient to drive near-optimal exponentiated proportional allocation for a broad class of well-behaved objectives, including makespan minimization, Santa Claus, Nash welfare, and $\ell_p$-norm objectives (Cohen et al., 2023). In a more explicitly sequential resource-allocation setting, a learner allocates a per-round budget $\bm{x}_t$ subject to $\sum_i x_{t,i}\le B$, while each arm’s reward depends on both an unknown Bernoulli activation parameter and an unknown threshold distribution; the resulting feedback is censored because failures do not reveal which latent mechanism caused them (Montanari et al., 6 Feb 2026).

2. Learning-augmented online allocation under uncertainty

A central theoretical line studies online allocation through compact prediction targets or online parameter estimation. In “A General Framework for Learning-Augmented Online Allocation” (Cohen et al., 2023), the key advice is a vector $w=(w_1,\dots,w_m)\in\mathbb{R}_{>0}^m$, with one learned parameter per agent. The online rule is generalized proportional allocation,

$$x_{i,j}=\frac{f(p_{i,j})w_i}{\sum_{i'} f(p_{i',j})w_{i'}},$$

with exponentiated proportional allocation as the special case

$$x_{i,j}=\frac{p_{i,j}^{\alpha}w_i}{\sum_{i'} p_{i',j}^{\alpha}w_{i'}}.$$

The paper proves existence and uniqueness of canonical parameters that equalize loads, gives a Sinkhorn-like iterative procedure for computing them, and shows that sufficiently large positive or negative $X=(x_{i,j})$0 yields near-optimal algorithms for maximization and minimization objectives, respectively. Robustness degrades linearly in a multiplicative prediction-error parameter $X=(x_{i,j})$1 for general well-behaved objectives, while makespan admits a stronger $X=(x_{i,j})$2 dependence (Cohen et al., 2023).

“Learning to Allocate Resources with Censored Feedback” (Montanari et al., 6 Feb 2026) studies a harder online setting in which each arm succeeds only if it activates and the allocated budget exceeds a random threshold. The clairvoyant benchmark solves

$X=(x_{i,j})$3

but both $X=(x_{i,j})$4 and $X=(x_{i,j})$5 are unknown, and the learner only observes success indicators and realized thresholds on successful rounds. The paper proves an information-theoretic lower bound $X=(x_{i,j})$6, introduces RA-UCB for known budgets and MG-UCB for unknown round-dependent budgets, and obtains $X=(x_{i,j})$7 regret in the general case and $X=(x_{i,j})$8 under stronger assumptions (Montanari et al., 6 Feb 2026). The technical novelty lies in separately estimating threshold parameters from successful observations and activation probabilities from debiased success frequencies, then embedding those estimates into an optimistic allocation oracle.

A related partial-feedback perspective appears in “Active Learning for Fair and Stable Online Allocations” (Bhattacharya et al., 2024). There, the planner allocates resources or bundles while observing feedback from only a selected subset of agents each epoch. The paper’s central device is dueling upper and lower confidence bounds: allocations are chosen optimistically, while the queried agent or coalition is selected using pessimistic surrogates that identify the most informative feedback. The resulting algorithms achieve sublinear regret for max-min fairness, envy minimization, and stable-assignment feasibility despite one-agent, two-agent, or $X=(x_{i,j})$9-agent feedback budgets, depending on the formulation (Bhattacharya et al., 2024). This line makes explicit that learning to allocate can include learning whose feedback to acquire, not only what allocation to output.

3. Label-budget allocation and selective supervision

A more specialized but conceptually sharp formulation appears in anomaly detection. “How to Allocate your Label Budget? Choosing between Active Learning and Learning to Reject in Anomaly Detection” (Perini et al., 2023) studies a single fixed budget that must be split between two incompatible uses of labels: Active Learning (AL), which requests strategic and therefore biased training labels, and Learning to Reject (LR), which requires random i.i.d. validation labels to estimate a rejection threshold. The total budget is modeled as

$\sum_i x_{i,j}=1$0

with $\sum_i x_{i,j}=1$1 rounds and $\sum_i x_{i,j}=1$2 labels per round. The proposed mixed strategy, ballad, initializes both sides with $\sum_i x_{i,j}=1$3 labels, then greedily allocates each subsequent batch to whichever side had the larger observed reward in its previous update (Perini et al., 2023).

The comparison between AL and LR is made through two reward functions. The default entropy reward is

$\sum_i x_{i,j}=1$4

while the cosine reward tracks changes in thresholded outputs. LR itself is implemented through ambiguity rejection using confidence

$\sum_i x_{i,j}=1$5

and a rejection threshold $\sum_i x_{i,j}=1$6 optimized on labeled validation data against the cost

$\sum_i x_{i,j}=1$7

Empirically, ballad yields overall average cost $\sum_i x_{i,j}=1$8, compared with $\sum_i x_{i,j}=1$9 for All-in-AL and $w_i$0 for All-in-LR, and the reward choice materially changes allocation behavior: cosine reward chooses AL in $w_i$1 of cases, whereas entropy reward chooses AL in $w_i$2 of cases (Perini et al., 2023). The broader significance is that allocation here is not over model parameters or hardware, but over a scarce supervision budget whose statistical role differs across downstream uses.

4. Multi-agent, robotic, and networked task allocation

In multi-agent systems, one prominent strand does not learn allocations directly, but learns the latent feasibility model that a downstream optimizer requires. “Learning Task Requirements and Agent Capabilities for Multi-agent Task Allocation” (Fu et al., 2022) assumes cumulative capability vectors $w_i$3 for agent types and task requirement vectors $w_i$4, so that task $w_i$5 is feasible when

$w_i$6

Given task-team performance data, the paper estimates $w_i$7 and $w_i$8 through row-wise linear programs, then inserts the learned constraints into a mixed-integer routing and scheduling model. The computational study reports prediction errors in the range of $w_i$9, and the abstract highlights that scenarios with 40 tasks and 6 agent types learn in around 12 seconds (Fu et al., 2022). This is an interpretable “learn-to-model, then optimize” version of Learning to Allocate.

A more end-to-end RL formulation appears in “A Two-stage Reinforcement Learning-based Approach for Multi-entity Task Allocation” (Gong et al., 2024). There, a manager allocates subsets of entities to tasks to maximize

$\ell_p$0

with dynamic task and entity attributes. The main architectural idea is a two-stage decomposition: a pre-assignment module uses similarity scores

$\ell_p$1

to assign each entity to a candidate task, and a selection module then chooses the final subset per task. The critic combines per-entity values using AMIX with parameters generated by a self-attention-based hypernetwork, which lets the system handle changing numbers of entities (Gong et al., 2024). The paper reports stronger performance than heuristic baselines such as genetic algorithms, particle swarm optimization, and symbiotic organism search across several dynamic environments.

In network orchestration, “Using Reinforcement Learning to Allocate and Manage Service Function Chains in Cellular Networks” (Santos et al., 2020) treats allocation as joint placement, scaling, and operational management of EPC virtual network functions across distributed data centers. The action is

$\ell_p$2

with $\ell_p$3 denoting create, delete, restart, or do nothing. PPO is trained against the reward

$\ell_p$4

so the learned policy balances packet preservation against energy cost (Santos et al., 2020). This paper is an early example of learning-based orchestration in NFV/SFC systems, even though its empirical validation is explicitly preliminary.

5. Compute allocation in LLMs

A recent expansion of the field reallocates inference or training compute rather than physical resources. “ATLAS: Agentic Test-time Learning-to-Allocate Scaling” (Qin et al., 1 Jun 2026) frames test-time reasoning as an allocation problem over solver calls and stopping decisions. An orchestrator $\ell_p$5 repeatedly chooses between

$\ell_p$6

while each explore action launches a fresh solver on the original problem and appends a structured candidate

$\ell_p$7

to the stateful trace. In the multi-model extension, the action becomes $\ell_p$8, so the system allocates solver identity as well as explore count (Qin et al., 1 Jun 2026). The paper reports 56.00 on HLE-Verified, 82.29 on LiveCodeBench, 85.75 on GPQA-Diamond, and 23.71 on BabyVision for ATLAS, with ATLAS-MM improving further on all four benchmarks (Qin et al., 1 Jun 2026). Although the orchestration policy is prompt-induced rather than RL-trained, it is explicitly presented as an allocation mechanism over test-time compute.

“End-to-End Dynamic Sparsity for Resource-Adaptive LLM Inference” (Chen et al., 26 Jun 2026) uses the phrase “Learning to Allocate” directly for budget-conditioned inference. A frozen LLM with LoRA adapters is augmented with input-aware, budget-conditioned gates for layer skipping, head pruning, and reasoning-token reduction. The runtime budget is a scalar

$\ell_p$9

and the unified objective is

$\bm{x}_t$0

The paper reports that a single model traces the compute-accuracy Pareto frontier on Llama-3-8B and Qwen-3-4B; at up to 34% realized layer sparsity, it stays within 0.6% of the dense baseline on GSM8K, with static or heuristic baselines dropping by 5–10% at comparable inference time (Chen et al., 26 Jun 2026). Here allocation is explicitly over depth, width, and reasoning length under runtime resource budgets.

At training time, “How to Allocate, How to Learn? Dynamic Rollout Allocation and Advantage Modulation for Policy Optimization” (Fang et al., 22 Feb 2026) allocates rollout budget across prompts in RLVR. The sequence-level derivation solves

$\bm{x}_t$1

yielding the variance-minimizing rule

$\bm{x}_t$2

In practice, DynaMO uses Bernoulli reward variance as a proxy for prompt informativeness,

$\bm{x}_t$3

and combines this dynamic rollout allocation with token-level advantage modulation (Fang et al., 22 Feb 2026). This extends L2A from inference-time compute orchestration to training-time sample allocation.

6. Acronym collisions, boundary cases, and conceptual limits

A persistent source of confusion is that “L2A” is not a stable acronym across machine learning. In domain generalization, “Learning to Generate Novel Domains for Domain Generalization” uses L2A-OT, where L2A = Learning to Augment, not Learning to Allocate; the method synthesizes pseudo-novel domains via optimal transport to improve generalization (Zhou et al., 2020). In long-context language modeling, “Learning When to Attend: Conditional Memory Access for Long-Context LLMs” uses L2A = Learning To Attend, with token-wise conditional global attention rather than allocation in the usual operations or control sense (Choudhary et al., 18 Mar 2026). In adaptive streaming, “Optimizing Adaptive Video Streaming in Mobile Networks via Online Learning” defines L2A = Learn2Adapt, an online convex optimization algorithm for bitrate selection (Karagkioules et al., 2019). In adaptive medical ML regulation, “Learning how to approve updates to machine learning algorithms in non-stationary settings” defines L2A = Learning-to-Approve, meaning online learning over approval policies with abstention rather than resource allocation (Feng, 2020).

The literature also contains allocation-adjacent systems that adapt their behavior without being learned allocators in a strict sense. “Phase-Adaptive LLM Framework with Multi-Stage Validation for Construction Robot Task Allocation” presents LTAA, an LLM-based framework that adjusts success-versus-balance emphasis across phases and uses validation with retries, but the paper explicitly states that it is not a conventional “learning to allocate” method based on policy optimization, demonstrations, or reward-driven training (Kaitha et al., 2 Dec 2025). This boundary case is informative: it shows that recent allocation systems may replace learned parametric policies with prompt-engineered, stateful reasoning, while still occupying much of the same application space.

Taken together, these papers indicate that “Learning to Allocate” is not a single canonical subfield with one standard formalism. It spans learning-augmented optimization, censored-feedback resource allocation, active-feedback acquisition, multi-agent task assignment, and adaptive compute orchestration. What unifies these formulations is the attempt to replace fixed allocation rules with adaptive mechanisms whose behavior is shaped by observed data, latent-parameter estimation, or stateful evidence accumulation.