ReGE Teaches Agents From Their Own Attempts: +9.9 pp Without Fine-Tuning

AI-model agents usually solve a task from scratch every time, as if earlier attempts never happened. Researchers at TIGER-Lab (Jiarong Liang, Yubo Wang, Zijie Liu, Yuxuan Zhang, Ping Nie and Wenhu Chen) propose fixing this with a framework called ReGE (Re-execution Guided by Experience). It turns logs of past attempts into a plan for a new one, without updating weights and without a stronger model. Across four benchmarks, accuracy rose by an average of 9.9 pp for GPT and 8.8 pp for Claude. GPT-5.6 Luna with ReGE matched the quality of the more expensive GPT-5.6 Sol.

A Coach Who Doesn't Know the Right Answer

The main implementation is called ReGE-Syn. First, the model tries to solve the task several times. Then the same model, acting as a "coach," receives size-limited execution records and the final artifacts of those attempts. It has no information about which attempt was correct. In a single call, the coach writes a self-contained guide that ties together the facts found for the task, suggested actions, and traps that earlier attempts already fell into.

Next comes the "student," a fresh instance that starts from the environment's initial state. It can follow the plan, adjust it, or skip it if real observations contradict it. Attempt generation, synthesis, and execution all run on a single base model, with no training and no strong teacher in the setup.

The difference between this approach and simply picking the best answer is fundamental. Failed runs are useful too: they show which buttons don't work, which queries return nothing, and where the model wasted steps.

Economics: 28% of the Price and 95–98% Fewer Tokens

The most striking result concerns cost. On a subset of 468 tasks, GPT-5.6 Luna with ReGE scored 67.4%, while the larger GPT-5.6 Sol without the hint scored 67.0%. Luna's cost came to 28% of Sol's price. In other words, part of the gap between the "junior" and "senior" model can be closed not by buying a more expensive model, but by reusing your own logs.

Separately, the authors compared ReGE-Syn with the agentic aggregator AggAgent on matching BrowseComp-Plus queries. Building the hint was 98.2% cheaper in tokens for GPT and 95.5% cheaper for Claude. Total tokens for building and execution (input plus output, excluding generation of the initial attempts) fell by 15.7% and 35.4%, respectively. The savings on gathering experience are not eaten up by the student working longer afterward.

Ablations on BrowseComp-Plus show two effects. Access to process information, rather than only final answers, is associated with fewer steps for the student. Joint synthesis produces a noticeably shorter guide than feeding in the raw history (Direct history) or a set of independent summaries (Independent summaries).

What Went Into the Experiment

• Benchmarks: Terminal-Bench 2.0 (terminal work), Spider2-Lite (text-to-SQL), AndroidWorld (Android control), BrowseComp-Plus (search and browsing). • Models: GPT-5.6 Luna, GPT-5.6 Sol (as a price and quality reference point), Claude Sonnet 5. • Average accuracy gain: +9.9 pp for GPT, +8.8 pp for Claude relative to a run without the hint. • 468-task subset: GPT-5.6 Luna with ReGE — 67.4%, GPT-5.6 Sol — 67.0% at 28% of the cost. • Hint building versus an adapted AggAgent: −98.2% tokens for GPT, −95.5% for Claude. • Total building and execution tokens: −15.7% and −35.4%. • Configuration: one coach call, no correctness labels, no parameter updates, no stronger teacher.

For engineers building agent systems, the takeaway is practical. If you already have parallel runs, such as a swarm of agents, you don't have to throw their logs away. You can condense them into one short instruction. No extra infrastructure is needed: a single call to the same model and a store for the records are enough. The most expensive part is the initial attempts themselves, and the paper does not include their cost in the token comparison. That makes the approach best suited to tasks that get run several times anyway, or in several copies. It is also a reasonable option for tasks where the cost of an error exceeds the cost of a rerun.

The method has a limit on where it applies: the student starts from the environment's initial state, so the task must be reproducible. For irreversible actions in real systems, the scheme would need to be supplemented with a sandbox. The project's code is available on GitHub, and the project page is hosted by TIGER-Lab.