ReGE: one coach call distills failed agent runs into guidance — gpt-5.6-luna matches its pricier sibling at 28% of the cost

A team at Waterloo, UNC Chapel Hill, and UBC reports that a single "coach" call over an agent's own earlier attempts produces guidance that makes the same base model measurably better — an average of +9.9 points for GPT and +8.8 points for Claude across four agent benchmarks, with no fine-tuning and no stronger teacher (arXiv:2610.33861). In the paper's headline comparison, the cheaper gpt-5.6-luna guided by its own recorded experience reaches 67.4% mean success against 67.0% for the pricier gpt-5.6-sol, at 28% of its cost including the cost of generating the source runs (full text).

What shipped

ReGE ("Re-execution Guided by Experience") is a framework for turning recorded agent attempts into guidance for a fresh run. It has two variants: ReGE-Syn, which synthesizes all attempts into guidance in a single model call, and ReGE-Sel, which forwards one judge-selected trajectory as the guidance. The paper focuses on ReGE-Syn.

The pipeline has three stages, all using the same base model with the same weights:

1. Source pool. The model runs the task K times, producing a pool of attempts. Each attempt is rendered programmatically into a bounded text block — step-ordered commands and reasoning narratives, followed by final artifact paths and contents — truncated to cap input length. No per-trajectory LLM summary is generated before the coach sees the records, and benchmark correctness labels are withheld from both coach and student. Raw per-step observations are dropped.
2. Synthesis. One coach call reads the instruction plus the rendered source pool and emits self-contained guidance: an execution-ordered plan that ties concrete findings to proposed operations and pitfalls, with exact paths, values, commands, and format requirements. The guidance has to stand alone — the student never sees the source attempts.
3. Student rerun. A fresh student starts from the task's initial environment state and follows, adjusts, or skips the guidance against its current observations. Files and environment changes from the source attempts do not carry over; the benchmark grades the state or output of the new run.

Nothing is trained: source generation, synthesis, and execution share one model. The paper's stated motivation is testing whether a lower-priced model guided by its own attempts can match a higher-priced one.

The numbers, as reported in the paper:

• Accuracy: ReGE improves mean task completion by 9.9 percentage points (GPT) and 8.8 (Claude) versus unguided execution, averaged over Terminal-Bench 2.0, Spider2-Lite, AndroidWorld, and BrowseComp-Plus.
• Cheap model, expensive-model results: on a subset, gpt-5.6-luna with ReGE hits 67.4% average success versus 67.0% for gpt-5.6-sol, at 28% of its cost including source-pool generation (the K source attempts).
• Token savings: on matched BrowseComp-Plus subsets, ReGE-Syn cuts guidance-construction tokens by 98.2% (GPT) and 95.5% (Claude) relative to an adapted AggAgent baseline. Even though student execution itself uses more tokens, combined construction-plus-execution usage falls by 15.7% (GPT) and 35.4% (Claude), counting input plus output and excluding source generation.

The paper's Table 1 contrasts ReGE-Syn with five aggregation methods: Self-Consistency (0 aggregation calls, no trajectory info), Self-MoA (1 call, no trajectory info, no student rerun), Reflexion (iterative reflection calls), agentic PDR (K aggregation calls), and AggAgent (iterative, no student rerun). ReGE-Syn is the only one combining single-pass synthesis, trajectory information, and a student rerun with exactly one aggregation call. Aggregation calls count model calls that combine source attempts; the single fixed call versus AggAgent's iterative process is the structural contrast behind the 98%-class construction-token reduction the paper reports on the matched subsets.

The ablations reported in the abstract are directional. Access to process information (the step-by-step record) is associated with fewer student steps, and joint synthesis produces substantially shorter guidance than either passing the raw history directly or independently summarizing each attempt before combining.

The evaluation setup: Terminal-Bench 2.0 (89 tasks, 30 agent turns), Spider2-Lite (135 instances, read-only SQLite, up to 18 SQL calls), AndroidWorld (text-only T3A agent with a step budget of 10× task complexity; 114 templates totalling 342 instances on GPT and 114 on Claude), and BrowseComp-Plus. Guidance is supplied alongside the agent's own observations — for AndroidWorld, through the native task-guideline interface.

Why it matters

The headline implication is that a smaller, cheaper model plus its own execution history can close the gap to a pricier sibling — 67.4% versus 67.0% at 28% of the cost, per the paper. If that holds, the lever for practitioners is not only which model you rent but whether you are reusing the runs you already paid for.

• It needs no training. No parameter updates, no stronger teacher, no fine-tuning — the same model's logs become text that a fresh attempt reads alongside its observations.
• The aggregation is one call. Where iterative methods (Reflexion-style reflection, AggAgent's iterative merging) spend many calls combining attempts, ReGE-Syn does it once — a single fixed-cost coach call versus an iterative process.
• It is a natural fit for parallel agent fleets. The authors explicitly suggest consolidating the execution records of parallel agent systems such as swarms: instead of discarding K parallel runs, synthesize them into guidance for the next round. A fleet's logged failures become a cheap, no-training memory of the task.

The mechanism has a built-in safety valve: because correctness labels are withheld and the guidance is "self-contained," the student cannot blindly trust it. It must verify proposed operations against the current environment, and the coach's mistakes are checkable rather than baked in.

Caveats

All of the above numbers are the authors' own, from a preprint that has not been peer-reviewed, and none of it is independently reproducible:

• The paper names the code repository github.com/TIGER-AI-Lab/ReGE, which currently returns a 404. No artifacts are released anywhere to check the claims against (repo as named).
• The paper hedges the guidance-construction-token reduction and the ablation claims with "with observed success" — twice in the abstract, once more in the introduction — meaning the 98.2%/95.5% figures are computed over successfully executed runs, not all runs. The 15.7%/35.4% combined-token figure carries no such qualifier in the accessible text.
• Of the paper's public text, only the abstract, introduction, method, and part of the setup are accessible; the per-benchmark results table, the ablation tables, and the Table 5 cost breakdown that supports the "28% of cost" figure sit behind that boundary. The paper does not state which subset the 67.4/67.0 comparison uses, and the Claude model names are not given in the accessible text. Treat 9.9pp/8.8pp as averages whose composition is currently unverifiable.
• "28% of its cost" is a favorable framing in one specific sense: it includes the source-pool generation for the cheap model, per the figure caption. What that fraction is relative to a single unguided luna run is not stated in the accessible text.
• Nothing here has been independently replicated, and there is no external commentary to triangulate against — the preprint was submitted on 24 Oct 2026.
• Whether the coach propagates errors from the source attempts is mitigated only by the student's verification step; the paper does not quantify how often guidance-confident but wrong recommendations slip through in the accessible sections.

None of this makes the mechanism uninteresting — single-call synthesis and the no-training constraint are useful design choices. The correct reading: a promising, cheap agent-memory pattern with strong reported numbers and no public receipts yet.

Sources

• arXiv abstract page: https://arxiv.org/abs/2610.33861v1
• arXiv full-text HTML (used for intro, method, Table 1, setup): https://arxiv.org/html/2610.33861v1
• Code repository as named in the paper (currently returns HTTP 404): https://github.com/TIGER-AI-Lab/ReGE