✓✓ Beats tuned baseline 2026

Geometric Feedback Compute Scheduler

Implementation & benchmark of arXiv:2607.13648 — Meeting Uncertain Threats with Feedback

Usefulness7/10

Difficulty5/10

Novelty7/10

Architecture Speedup Scalability Sample efficiency Moe routing Inference speedup Probability Stochastic processes Optimization

Source paper: Meeting Uncertain Threats with Feedback arXiv:2607.13648 ⓘ · analyzed Aug 30, 2026

AI-generated research hypothesis, automatically tested. Not peer-reviewed.

Idea description

Treat unresolved inference items as active threats and allocate a fixed budget of C module evaluations per round. Each evaluation has an item-dependent probability of completing the item, while the scheduler observes only completion or failure after the round. Use fair allocation when completion probabilities are unknown or nearly homogeneous, then switch to a marginal-success greedy policy as feedback estimates become reliable.

Formulas

$$\Pi:=\left\{\pi:\sum_{i\in\mathcal{M}}\left[\pi_t(\mathcal{M})\right]_i=C,\ \forall\mathcal{M}\neq\emptyset,\ \forall t\in\mathbb{Z}_{\geq 1}\right\}$$

$$[n]=\mathcal{M}_1\supseteq\mathcal{M}_2\supseteq\ldots\supseteq\emptyset$$

$$\mathbb{E}[L_i]=\frac{1}{1-q_i},\qquad \Pr(L_i\le k)=1-q_i^k,\qquad \Pr(L_i>k)=q_i^k$$

$$\Delta_i(a_i)=\Pr(\text{item }i\text{ completes on its next call})=q_i^{a_i}(1-q_i)$$

Mathematical statement

The paper models a feasible policy as an allocation rule satisfying $\sum_{i\in\mathcal{M}}[\pi_t(\mathcal{M})]_i=C$ for every nonempty active set $\mathcal{M}$ and every round $t$, where $C$ is the total number of effectors and $[\pi_t(\mathcal{M})]_i$ is the number assigned to active item $i$. The active sets form a random nested sequence $[n]=\mathcal{M}_1\supseteq\mathcal{M}_2\supseteq\cdots\supseteq\emptyset$. For item $i$, let $q_i\in[0,1)$ be the probability that one attempt fails and let $L_i$ be its number of attempts required for completion. The extracted paper states $\mathbb{E}[L_i]=1/(1-q_i)$ and uses $\Pr(L_i\le k)=1-q_i^k$, $\Pr(L_i>k)=q_i^k$, and $\Pr(L_i=1)=1-q_i$. In the neural adaptation, $i$ indexes an unresolved token, sample, branch, or latent trajectory; $a_i$ is its cumulative number of allocated module calls; and the probability that its next call completes it is estimated as $p_i=1-q_i$. A fair policy assigns $a_i$ as evenly as possible across active items. A geometric marginal-gain policy assigns the next slot to the item maximizing $q_i^{a_i}(1-q_i)$, the probability that this next attempt is the first successful completion attempt under the geometric model.

Implementation notes

Integrate this at inference time as a batch-level scheduler around an expensive module: an MoE expert call, verifier, recurrent refinement block, diffusion denoising update, or test-time reasoning step. Maintain an active set of items that have not yet met a stopping criterion. The scheduler receives a fixed per-round budget C and cumulative call counts a[i]. Estimate each item’s failure probability q[i] from a difficulty head or online feedback. For a confidence-based system, define success as confidence exceeding a threshold or verifier reward exceeding a threshold; update q[i] from observed failures and successes with a Beta prior, using p[i]=(s[i]+alpha)/(s[i]+f[i]+alpha+beta) and q[i]=1-p[i]. At every round, initialize a_round[i]=0. If estimates are unavailable, assign slots in round-robin order over active items, implementing fair allocation up to integer rounding. Otherwise repeat C times: compute score[i]=q[i]**a[i]*(1-q[i]) for each active item, assign one slot to argmax(score), and increment its temporary and cumulative count. Execute selected calls in a batch, update feedback statistics, and remove completed items. The geometric equations are the model assumption; q estimates, stopping thresholds, and calibration are empirical. First test on a small MoE language model or verifier benchmark, comparing round-robin, static confidence allocation, and greedy scheduling at equal total calls. Measure accuracy, average calls, p95 latency, and unfinished items by a deadline. Success means lower compute or tail latency at matched accuracy, particularly on heterogeneous-difficulty batches.

Verification

Beats tuned baseline

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

Stage 2 · Practical benchmark result: Significant win ✓

Methodology: 8 paired seeds, permutation test (p<0.05) against a learning-rate-tuned baseline. How verification works

How to read this: The implementation beat the baseline, but the claimed mechanism did not reproduce at benchmark scale. The gain may come from another effect; treat the cause as unresolved.

Stage 1 — Mechanism check agent confidence 9/10

Built and numerically verified the geometric scheduler. The core predictions were confirmed: completion-probability error was at most 0.00119, mean-attempt scaling error at most 0.17%, and greedy allocation matched exhaustive optima exactly on all tested cases. However, feedback greedy did not produce a practical win over fair allocation in the toy deadline benchmark; the mechanism is validated, but the inference-speed benefit remains unproven.

Agent confidence: 9/10

Baseline: Fair round-robin: completion rate 0.9354, unfinished 0.646, p95 completion round 9.875, mean calls/item 4.9465.
Idea: Feedback greedy: completion rate 0.9338, unfinished 0.663, p95 completion round 9.923, mean calls/item 4.9103. Oracle greedy: completion rate 0.9216, unfinished 0.785, p95 completion round 10.217.

Limitations: Only a small synthetic geometric model was tested; no real MoE, verifier, neural inference module, wall-clock latency, GPU execution, calibration study, or larger batch/deadline sweep was evaluated. The practical benchmark used oracle geometric probabilities for comparison and a simple Beta posterior for feedback.

How to run: python3 scheduler_experiment.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2607.13648) Sep 2, 2026

Beats the tuned baseline by 3.4% (p=0.0312, wins 6 / 8 paired seeds; metric: lower is better).

Benchmark: Dynamics forecasting
Model: rnn_small
Paired seeds: 8
Baseline mean: 0.0371
Idea mean: 0.0358
Effect (Δ): -0.0013 (−3.4%; negative = idea better)
Wins: 6 / 8 paired seeds
p-value: 0.0312 (permutation test, 20 000 shuffles)
Smallest detectable effect: n/a
Mechanism: Not confirmed ✗
Practical effect: Helps
Baseline tuning: swept over 3 configs

Limitations:

Only the built-in dynamics track and rnn_small model were tested. The scheduler’s refinement uses the benchmark’s scalar target combined with the latest observed omega/control as a proxy recurrent state, and no wall-clock latency or larger models were measured. The significant MSE improvement did not coincide with confirmation of the intended allocation mechanism.

How to run: python3 stage2_bench.py

Verdict computed by deterministic test code from paired-seed statistics — not by the language model.

Stage 2 — Benchmark Aug 31, 2026 latest Worked ✓

Agent confidence: 7/10

Implemented the geometric feedback scheduler on the structurally matched dynamics track using independently trained identical rnn_small systems and equal recurrent-call budgets. Across 8 paired seeds, the idea reduced test MSE by 0.00126555 (3.41%), won 6/8 pairs, and achieved permutation p=0.0312, meeting the benchmark significant-win criterion. The mechanism signature was not confirmed because high-residual items received fewer calls in this setup, so the gain is promising but mechanistically ambiguous.

Baseline: dynamics/rnn_small, mean test MSE 0.0370592, std 0.0105672, best lr=0.006, epochs=4, C=6, rounds=3.
Idea: dynamics/rnn_small, mean test MSE 0.0357936, std 0.0099339, lr=0.006, epochs=4, C=6, rounds=3, threshold_pct=50, alpha=beta=1; paired delta=-0.00126555, 6/8 wins, permutation p=0.0312.
Mechanism signature: Predicted higher allocation for unresolved/high-residual items; observed high-minus-low calls per item=-0.04, confirmed=false.

Benchmark result