Perplexity's JOLT: 6.5x fewer training tokens than GRPO on MATH, if you have reference solutions

On October 21, 2026, Perplexity published a post with NVIDIA on JOLT (Joint On-policy Learning and Teaching), backed by arXiv paper 2610.10447 (v1 submitted October 7; authors Randy Ardywibowo, Arnav Dalal and Jiantao Jiao). The number that spread is "6.5x fewer tokens than GRPO on MATH". It's a real number, but it measures something more specific than the headline suggests.

The general idea matters to anyone doing small-scale RL post-training. Outcome-reward RL like GRPO gives a sparse signal: one scalar per rollout. JOLT adds dense, token-level guidance without hosting a separate teacher model. If it holds up, the same accuracy costs fewer rollouts and fewer optimizer passes, and that is the budget a single-GPU team actually spends.

What actually shipped

JOLT extends on-policy self-distillation (OPSD). One model plays two roles.

The teacher is the same weights, but with privileged information in context: verified answers on GSM8K, worked reference solutions on MATH. Plain OPSD stops there, and the paper names its problem: a privileged teacher can take shortcuts the student can't follow, so its guidance doesn't help. JOLT therefore also trains the teacher. The paper derives when a teacher's distillation update lines up with the student's own reward gradient, and turns that into a teacher objective: outcome reward on the teacher's own attempts plus KL regularization toward the student (β_T).

The student has no privileged context. It trains on its own on-policy rollouts with a reverse-KL distillation loss against the privileged teacher, weighted by β_S. Combined: J_JOLT = J_T + β_S · J_OPSD. JOLT+ also adds the student's group-relative outcome reward, GRPO-style.

Baselines were GRPO, OPSD and π-Distill, each with tuned hyperparameters. Plain SFT isn't compared. Perplexity says the code will be open-sourced "soon". As of today there is no repository.

Numbers that matter

What "6.5x" refers to: the paper's exact framing is that at a matched MATH accuracy of 63.44%, GRPO's observed checkpoint used 8.40M tokens, while JOLT's fitted curve gives 1.30M. The ratio is 8.40 ÷ 1.30 ≈ 6.5. The tokens are processed training tokens: unpadded prompt and completion positions processed during optimization. That count includes teacher-only context, cross-scoring passes and repeated optimization passes. It is not GPU-hours.

On completion (generated) tokens the gap is bigger: ~13x at the same point. Across target accuracies the ranges are 4.3 to 7.4x processed and 9.5 to 14.4x completion.

Final MATH accuracy, Qwen3-0.6B student, base ≈ 43.85%:

Absolute gains for JOLT+ over GRPO: GSM8K +1.5 pp, MATH +4.2 pp, LiveCodeBench v6 +3.0 pp, AppWorld +9.9 pp, Terminal-Bench 2.1 pass@1 +2.7 pp.

An illustrative budget translation (my arithmetic, not the paper's): if a GRPO run on your task processes 8.4M tokens to reach a target score, and the 6.5x ratio held, JOLT would need about 1.3M. On a single GPU with fixed throughput, that's the same ~6.5x reduction in optimization time. The time spent on generation would fall by more if the 13x completion ratio transferred, since rollouts usually dominate. Both are big ifs.

The JOLT side of the 6.5x comes from a fitted curve, not an observed checkpoint.

Technical meaning and trade-offs

The ratio is partly extrapolated. The JOLT side of the 6.5x comes from a fitted curve, not an observed checkpoint. The GRPO side has ±3.73 pp of run-to-run spread. I'd quote the range (4.3 to 7.4x) rather than a single number.

You need privileged information, not just a verifier. GRPO runs on any task with a reward function. JOLT's teacher needs something like reference solutions in context. That's cheap for MATH. For many production tasks you'd have to build it: gold traces, expert answers, or a stronger model's output. That last option brings back the separate-teacher cost JOLT was designed to avoid.

It doesn't win everywhere. Without the student reward term, JOLT beats GRPO on GSM8K, MATH and LCBv6. It trails GRPO and π-Distill on AppWorld and trails GRPO on Terminal-Bench. On agentic, long-horizon tasks, which is where sparse reward hurts most, the gains in the table come from JOLT+, which keeps GRPO's reward signal. My read: treat JOLT+ as "GRPO plus a dense auxiliary loss", not as a GRPO replacement.

It's a cousin of the reward-design problem. The teacher objective exists because a teacher optimized naively finds shortcuts. That's the same failure family I wrote about in ImpossibleRubrics: when the rubric is the reward.

What's relevant on a single H100

The paper doesn't state hardware, GPU count or framework, so I can't say what Perplexity ran this on. The MATH setup itself is small: a Qwen3-0.6B student, 150 training steps, batch size 8, four teacher plus four student rollouts per problem (GRPO used eight student rollouts), and completions up to 16,384 tokens. Because teacher and student share weights, you hold one model in memory rather than two. That's my inference from the method, not a measured claim.

Caveat: the teacher still adds forward passes with longer, privileged contexts. The paper counts those in processed tokens but doesn't give a per-step cost against GRPO.

What I'd do

Wait for the code before reimplementing. The loss is simple, but the teacher-update and scoring details are where implementations diverge. Pick a task where you already have reference solutions; if you don't, JOLT isn't for you yet.

Run GRPO and JOLT+ side by side at a fixed processed-token budget, with three or more seeds. The paper's GRPO variance means single runs won't tell you much. Log processed and completion tokens separately, using the paper's definitions, so your numbers line up with theirs. On agentic tasks, start with JOLT+, not plain JOLT.

What I couldn't verify

Hardware, framework and wall-clock time are not stated in the blog or the parts of the paper I read. I can't say whether the efficiency ratio holds beyond Qwen3-0.6B on MATH; the 6.5x is measured only there. The author list differs between the blog citation (more names, plus "Perplexity Research & NVIDIA") and the arXiv entry (three authors); I used arXiv for the paper attribution. No independent replication exists yet. All results are self-reported.

I'll revisit when the code is released and someone reproduces the MATH curve.

Sources

Primary: Perplexity: A good teacher meets the student where they are; arXiv 2610.10447: A Good Self-Teacher Meets the Student Where They Are: Joint On-Policy Learning and Teaching; arXiv 2610.10447v1 (PDF).