When many phones in one wireless cell send image-plus-question queries to a shared edge server running a vision-language model, two scarce resources decide whether each user gets a correct answer before a deadline. The first is radio time: how long it takes to upload the image over that user's link. The second is server compute: how many reasoning attempts the model can spend on that query. Today these are allocated separately. The wireless scheduler splits bandwidth by channel quality or fairness and treats the task as a fixed block of bits. The language-model side either gives every query the same budget, which is "uniform compute allocation," or adapts the budget to difficulty while assuming the query is already on the server.
We propose to allocate both resources together, using a cheap estimate of how much each extra reasoning attempt would help each query. A user whose question is hard but solvable, and whose channel is poor, should get extra bandwidth. The bandwidth itself does not improve the answer. It frees time inside the deadline for more attempts. A user whose question is trivial or hopeless should get neither.
The main claim is narrower than "joint beats separate." The benefit of joint allocation should scale with the product of two spreads: how much channel quality varies across users, and how much difficulty varies across queries. It should vanish when channels "harden," meaning they become nearly identical across users as antennas or multipath grow. In that regime the best radio split is uniform anyway, so separate optimization loses nothing. This turns an apparent contradiction between the two literatures into a measurable prediction about when coupling matters.
Background and what is missing
Input-adaptive compute allocation gives us the estimator. Learning How Hard to Think trains a small predictor on model hidden states. The predictor estimates the marginal gain in reward from one more best-of-k sample. With it, the authors match uniform best-of-k accuracy with half the samples and gain up to 10% accuracy at a fixed budget. They also find that queries split into trivial, hard-but-solvable, and impossible groups. The LLM Already Knows shows that a two-layer probe on the hidden state right after the prompt predicts difficulty with zero generated tokens. It reports 93.09% ROC-AUC on ScienceQA with Qwen2.5-VL-class models. Optimizing Reasoning Efficiency through Prompt Difficulty Prediction finds that middle layers predict difficulty better than final layers.
We reuse these probes as our difficulty signal. All three assume the query is already on an unconstrained server. None prices the time it took to get there.
Wireless and edge-computing work supplies the other half and its standard simplification. The "single-cell assumption" is the practice of modeling one base station and its users in isolation, with neighboring cells reduced to background noise. Under it, Energy Efficient Resource Allocation for Mobile-Edge Computation Networks with NOMA and Joint Latency-Energy Minimization for Fog-Assisted Wireless IoT Networks jointly optimize transmission and computation. The second paper also shows that this beats equal CPU sharing at maximum transmit power. Both treat the workload as a fixed number of CPU cycles per bit, with no notion that extra computation buys a variable, query-dependent gain in accuracy.
To Compute or Not to Compute? is the closest boundary paper. Its sensors choose among sending raw data, processing locally, or sleeping, and it finds that less processing can lower global error. However, computation there is a scalar delay, and the policy is tabular Q-learning that does not look at task content. Non-Atomic Games for Multi-User Systems proves that as multipath diversity grows, optimal single-cell power allocation becomes uniform. This result constrains our proposal, and our main hypothesis is built around it.
Test-Time Compute Games studies test-time compute among competing cloud providers, finding a Price of Anarchy of up to 19%. It assumes no communication bottleneck, so it addresses a different layer of the problem.
We adopt the single-cell assumption deliberately, as the setting in which the allocation problem is tractable. We then test how far it holds.
Core formulation
In each scheduling frame of length $D$ seconds, the cell has $K$ users. User $k$ has a query $x_k$ with an image of $s_k$ bits and an average uplink rate $r_k$ per unit bandwidth. The rate depends on the user's channel.
The server chooses two quantities per user:
- a bandwidth fraction $b_k$, with all fractions summing to at most one;
- a number of reasoning samples $n_k$, with the total across users at most the per-frame budget $S$.
User $k$'s answer counts only if upload time plus generation time fits in the frame. Here $c$ is the server time per sample:
$$\frac{s_k}{b_k r_k} + c\, n_k \le D.$$
The objective is the expected number of correct answers per frame:
$$\max_{b,n}\ \sum_{k=1}^{K} \hat{p}(x_k, n_k),$$
where $\hat p(x,n)$ is the probe's predicted probability that best-of-$n$ answers $x$ correctly.
Best-of-$n$ success curves have diminishing returns in $n$, so the problem is solved by a greedy procedure on Lagrange multipliers. The procedure repeatedly gives the next unit of bandwidth or the next sample to whichever user gains the most expected correctness per unit of resource. The two resources are linked through the deadline. Bandwidth buys time, and time buys samples.
The probe must act before the full image arrives. We therefore use a two-step protocol. Each device first sends its question text and a small thumbnail of a few kilobytes. The server runs the probe on that preview, solves the allocation, and then schedules the full uploads.
Research Program
The program has five parts.
Probe. We train a marginal-reward probe in the style of Damani et al., inputting middle-layer hidden states of a Qwen2.5-VL model. We train it on the preview inputs, not the full inputs. Labels come from empirical best-of-$n$ success rates for $n$ up to 16. These are computed on VeriSciQA, whose 20,272 automatically verified pairs comfortably exceed the roughly 3,000 labeled queries Damani et al. report needing. We then test transfer to ScienceQA and MathVista.
Preview fidelity. We quantify how much predictive accuracy is lost by probing the preview instead of the full image. This degradation is the price of deciding before uploading.
Simulation. We build a single-cell uplink simulator with Rayleigh fading and path loss. A channel-hardening knob, the number of base-station antennas or multipath components, controls how much channel quality spreads across users. Inside the simulator we replay real queries and real sampled model outputs, so accuracy is measured rather than modeled.
Allocator and theory. We implement the joint greedy allocator. We also derive a simple bound on the gap between joint and separate allocation. The bound should be proportional to the covariance, across users, between the bandwidth needed to finish within the deadline and the marginal value of extra samples. This is the quantity that hardening drives to zero.
Interference stress test. We relax the single-cell assumption with a second cell. The neighbor's uplink activity, which grows when its users upload more or longer, raises interference in our cell. The interference is load-correlated, not constant.
Baselines
The naive reference point is uniform allocation: equal bandwidth for all users and a fixed $n$ chosen so the total stays within $S$. This is the "do nothing" policy both literatures criticize, and every other method must beat it.
The strongest competitor is the decoupled pipeline a careful engineer would build from existing parts. The radio side is optimized alone, using the deadline-aware, fairness-oriented time allocation of the edge-computing literature, in the spirit of Joint Latency-Energy Minimization for Fog-Assisted Wireless IoT Networks. The server then runs the adaptive best-of-k allocation of Learning How Hard to Think, constrained by each user's remaining time.
It is the strongest competitor because it already contains both good ideas and only lacks the feedback from difficulty to bandwidth. Damani et al. report a 50% compute reduction at equal accuracy over uniform best-of-k on math and code. That number was measured without any communication cost. For channel-coupled multimodal queries, no reported result was found on Lacuna, so this baseline will be run by us.
For fairness, every policy uses the same probe, the same cached model outputs, the same channel realizations, and the same $S$ and $D$. The decoupled pipeline's radio step gets the same hyperparameter search budget as our allocator. Beating it means a statistically significant increase in correct answers per frame, with confidence intervals over channel seeds, in the high-spread regime. Matching it in the hardened regime is what we predict, so a tie there does not count against the method.
We also run an a posteriori baseline built on Early-stopping Self-Consistency. It samples until a majority forms, with uniform bandwidth. This tests whether stopping early on the server side can replace planning ahead.
Two ablations isolate the key ingredients. In the first, the probe's per-query predictions are replaced with the population-average success curve. This keeps channel-aware joint allocation but removes difficulty information. In the second, the joint allocator ignores channels. An oracle allocator that uses true per-query success curves gives an upper bound.
Why not just…?
Why not just optimize the radio and the reasoning separately? This is the real threat, and the proposal is built to test it rather than dismiss it. Separate optimization loses only when the users who most need bandwidth to meet the deadline are also the users whose queries gain most from extra samples, or when the opposite pairing holds. If difficulty and channel quality are statistically independent and deadlines are loose, the gap may be small. The experiment that settles this sweeps channel spread and deadline tightness and reports the joint-minus-decoupled gap against the measured covariance. If the gap stays negligible even at high spread and tight deadlines, we conclude that the decoupled pipeline suffices and report that.
Why not just allocate uniformly, since channels harden in large systems? Non-Atomic Games for Multi-User Systems does show the radio split tends toward uniform with rich multipath. That result concerns channel gains, not query difficulty. The trivial, hard-but-solvable, and impossible split documented by Learning How Hard to Think remains even when channels are identical. Our prediction is therefore that hardening makes the radio side uniform while compute stays adaptive. The hardening sweep tests exactly this: the joint and decoupled methods should converge, and both should stay above uniform allocation.
Why not just sample until answers agree, instead of predicting difficulty up front? Early-stopping self-consistency saves server compute after the fact, but it cannot take back bandwidth already spent uploading a trivial or hopeless query. It also cannot give a struggling user more upload time before generation begins. It may still match our method on the server-compute side when bandwidth is plentiful. The ablation that combines our bandwidth split with early stopping will show whether up-front prediction adds anything beyond the radio decision.
Proposed Experiments
The evaluation sets are ScienceQA and MathVista, where the zero-token probe of The LLM Already Knows is known to work. VeriSciQA is used for probe training and as an in-domain test. The server is a single Qwen2.5-VL model with $n$ up to 16.
The primary metric is correct answers per frame at a fixed deadline and sample budget. Secondary metrics are the deadline-miss rate and accuracy under equal total resources. The probe is checked separately by comparing its ROC-AUC on previews with the 93.09% full-input figure reported for ScienceQA.
Three results are decisive:
- Coupling. The joint allocator's gain over the decoupled pipeline should grow with the channel-difficulty covariance and shrink toward zero as channels harden. If the gain does not shrink, our account of why coupling matters is wrong.
- Probe ablation. Removing per-query difficulty, while keeping channel-aware allocation, should lose most of the gain. This shows the semantic signal, not better radio scheduling, is doing the work.
- Interference. In the two-cell test, we measure how much of the single-cell gain survives when load-correlated interference breaks the rate predictions. We also test whether a fixed interference margin recovers it. A collapse here would mark the single-cell assumption as the binding limitation for this kind of system.
References
- Learning How Hard to Think: Input-Adaptive Allocation of LM Computation
- The LLM Already Knows: Estimating LLM-Perceived Question Difficulty via Hidden Representations
- Optimizing Reasoning Efficiency through Prompt Difficulty Prediction
- Energy Efficient Resource Allocation for Mobile-Edge Computation Networks with NOMA
- Joint Latency-Energy Minimization for Fog-Assisted Wireless IoT Networks
- To Compute or Not to Compute? Adaptive Smart Sensing in Resource-Constrained Edge Computing
- Non-Atomic Games for Multi-User Systems
- Test-Time Compute Games
- Escape Sky-high Cost: Early-stopping Self-Consistency for Multi-step Reasoning