Microsoft Research's Fork-and-Flush Keeps the Files and Wipes the Chat: 66 Percent Higher Normalized Average Score at Equal Compute

Illustration of the fork-and-flush result. On a solution map a dashed gray path shows one run refining inside idea basin A, while orange fork branches with fresh chat context reach the higher-scoring basin B. A bar panel shows normalized average scores at equal compute across 13 tasks: 0.47 for a single run, 0.54 for best-of-4 and 0.78 for fork-and-flush, and notes the method held the highest mean score on 12 of 13 tasks. — Original diagram of the fork-and-flush mechanism and its measured effect; the 12-of-13 figure is the count of tasks where the method had the highest mean score. Scores and the idea basin framing come from Cai, Ziakas et al., arXiv:2610.07447, as reported by The Decoder on Oct. 12, 2026.

Long agent sessions rarely fail loudly. They settle. A new Microsoft Research paper argues that the settling is measurable, that it survives context compaction, and that one measured escape is to delete the conversation while keeping the work.

Fork-and-Flush: Escaping Idea Basins in Autoresearch Agents was submitted to arXiv on Oct. 5, 2026 by Ziyang Cai and seven co-authors. The Decoder reported the results on Oct. 12, 2026, describing a Microsoft Research study of autoresearch agents: systems that repeatedly propose a candidate solution, evaluate it, and refine the next attempt from feedback.

Eight runs, one task, scores from 68.3 to 100.0

The Decoder’s report makes the problem concrete: eight independent runs of the same agent on the same task finished at scores ranging from 68.3 to 100.0, and those gaps persisted even with substantially more compute. That is not a story about a weak model; it is a story about search.

The authors’ explanation is idea basins. They embedded candidate artifacts by functional similarity, plotted the solutions, and found that a single run’s solutions almost always stayed inside one small region of that map. The agent then spends a large share of its remaining budget polishing inside a region that a sibling run already beat. Crucially, the pattern persists even when agents periodically compress their conversation histories: the summary still carries the reasoning that pinned the run to its basin.

The Decoder, Oct. 12, 2026: the captured viewport shows the site header with logo, Log In and Subscribe buttons, the Plus and AI research badges, the headline, the Matthias Bastian byline and Oct 12, 2026 date, the header artwork credited to Nano Banana Pro prompted by THE DECODER, only the first line of the opening paragraph, and a Top Stories sidebar; the idea-basin and fork-and-flush sections sit below the captured viewport. · Original source

The intervention: keep the files, flush the chat

Fork-and-flush is two moves. Fork: split the agent into K parallel branches, each inheriting the accumulated workspace and every generated file. Flush: each branch starts with an empty chat context. After a fixed horizon, the agent continues from whichever branch scored highest. The arXiv abstract is explicit that the workspace is inherited and the chat context is not.

A branch that keeps the parent transcript tends to walk back into the same basin, because its own prior reasoning steers the next step. A branch that keeps only the files is no longer steered by that transcript: in the paper’s measurements fresh context restores diversity in the search, although it does not guarantee escape on any given task. The conversation is gone; the code, the data and the saved results are still on disk.

Flow diagram of one fork-and-flush cycle for a coding CLI: a plateaued long run, writing the goal and score to a file, forking K branches, flushing the chat while keeping files, and continuing from the best-scoring branch. A shared workspace bar underlines that code and saved results survive every flush, and an example fan-out shows three branches with scores where the best is kept. — Original operator diagram of the fork-and-flush cycle described in Cai, Ziakas et al., arXiv:2610.07447 and reported by The Decoder. The three branch scores are illustrative; the normalized averages quoted at the bottom are the paper's reported results.

The researchers tested the method on 13 long-horizon tasks, including polyomino packing, job-shop scheduling, cryptanalysis, compressing a CIFAR classifier and optimizing a VLIW kernel. Individual runs lasted from several hours to more than 100 hours, driven by GPT-5.6-terra and GPT-5.5 through the GitHub Copilot CLI.

Method, equal compute, 13 tasks	Normalized average score	Normalized std dev	vs single run
Single run	0.47	0.26	baseline
Best-of-4	0.54	0.21	about +14.9 percent
Fork-and-Flush	0.78	0.16	+66.0 percent

Two details matter more than the headline percentage. Fork-and-flush took the highest mean score on 12 of the 13 tasks, and normalized standard deviation fell from 0.26 to 0.16, so the variance that turns a long run into a lottery got smaller. The flushing-only ablation is reported separately on a different evaluation set: across 11 tasks, against its own single-run baseline of 0.45, clearing the chat without branching moved the score to 0.55, about +22 percent. The two aggregates use different task sets and baselines, so they cannot be subtracted; the ablation shows flushing alone carries a real share of the benefit without decomposing the combined gain.

Why a better model may not fix it

The team also asked whether capability removes the effect. Using MAX-3-SAT instances across Qwen3.5-4B, 9B and 27B, run-to-run variance traced an inverted U, peaking on problems at the edge of the model’s ability. Easy instances almost always succeed, hard ones almost always fail, and the middle is where runs diverge. That pattern held across the three sizes tested; it is not a universal proof across frontier models. The authors argue open research problems sit at that boundary by definition, so they expect it to shift toward harder problems as models improve rather than disappear.

What you can do this week

None of this is a product toggle. It is a scheduling decision, and it maps onto harnesses you already run.

Put the state a fresh session needs into files, not chat. A flush only costs you what you failed to write down.
Fork on a plateau, not on a failure. If the score has not moved for a fixed horizon, that is the signal.
Give every branch the same budget and one scorer. Equal compute is what makes the 66 percent normalized-score gain a fair comparison, and a script that prints one number is what makes keep-the-best non-negotiable.
Isolate writes and budget the fan-out: one checkout per branch, the worktree ownership rule, because K parallel branches on one login is a rate-limit question before it is a research question (parallel sessions inside the usage limit).

The file that survives the flush is the whole method in operator form:

# GOAL.md - the only context a flushed branch receives
Objective: maximize packing density on the 12-piece set.
Score: run "python score.py out/" and read the density line.
Best so far: 0.812, saved in out/best/
Tried and rejected: greedy row fill (0.74), plain random restart (0.77)
Untried next: anneal the residual gaps; allow piece rotation

Compaction summaries are lossy and still carry the reasoning that trapped the run; a goal file carries only what a fresh agent needs to start. If you already lint compaction output, this is the stronger version of the same discipline (context engineering playbook, agent-owned compaction policy).

Caveats before you copy the numbers

These are research results on autoresearch-style tasks with an automatic scorer, not a promise about interactive product work. A task with no cheap scalar score cannot run keep-the-best without a human judge, and the human becomes the bottleneck the method was designed to remove. Wall-clock also differs from compute: K branches finish sooner only if they actually run in parallel.

Attribution deserves precision too. The Decoder describes the work as a Microsoft Research study and the arXiv listing names the eight authors; the Microsoft Research blog index fetched on Oct. 13, 2026 does not yet list a Fork-and-Flush post, so the arXiv paper remains the document to cite.

Your agent’s transcript is not only memory; it is also a constraint. Sometimes the most valuable thing you can hand a long run is a fresh conversation and the files it already earned. If you run overnight agents behind merge gates, the flush is a new lane to schedule, not a new tool to buy.