Scaling Discovery Requires Forgetting

Why People Wanted It

A search agent can keep proposing candidates inside one continuous session, with the whole history in context. But continuing that session does not guarantee continued progress. Parallel agents and communicating teams can also plateau while each agent carries its own growing history.

The problem is not simply a shortage of proposals. Sharing a promising candidate does not clear the old attempts surrounding it. So the real question is how to renew exploration without throwing away the strongest solution found so far.

The Core Move

Divide search into rounds: at each boundary, discard every agent’s session and explored-candidate history, keep the team’s best candidate and its score, and restart everyone from that candidate with empty context and unchanged instructions.

The mechanism is specified as a verbal reset rule, not a mathematical update formula. The retained artifact carries progress into the next round; the sessions and candidate histories do not.

Quiz

At a team-wide forget, what is retained and what is discarded?

Each agent keeps its full history, and the best candidate is copied to a team lead.

Only the lowest-scoring candidates are retained to encourage exploration.

The best candidate is discarded, but peer conversations are preserved.

All sessions and explored-candidate histories are discarded; the team’s best candidate and score are retained.

$ check

Why a Candidate Can Carry Progress Without Its Search History

Here is the part that gets technical: forgetting separates the solution artifact from the two kinds of memory used to search for it.

The canonical example is an agent editing a code repository. A candidate is a commit containing a proposed solution. Its search state is an append-only record of candidate commits, judge scores, and feedback. Its session records the interaction that produced those candidates. Keeping the best commit is therefore different from keeping either its alternatives or the conversation that led to it.

The reducer controls both memory channels. Before a turn, it decides which candidates appear as files in the workspace and which session continues. Forgetting changes both decisions:

• The new search state contains only the best candidate, so earlier candidates no longer appear in the workspace.
• There is no past session to continue, so the next agent starts with empty context.
• The instructions remain the same; the reset changes accumulated search memory, not the task.

Clearing only the conversation would leave the old candidate record available. Clearing only the candidate record would leave the session conditioning intact. The specified reset clears both.

This is deliberately lossy. The rationale is that the best candidate already contains most of the useful progress, while the discarded states mainly record how that progress was made. That does not make failed attempts universally useless. It makes the candidate the chosen handoff between rounds. What happens when several agents must share that handoff?

Why Team-wide Forgetting Keeps Communication but Clears Baggage

Now the version for readers who want more of the machinery: communication and forgetting act on different parts of the search loop.

Within a round, agents work in parallel, each with its own session and search state. Before proposing, an agent gets access to peers’ candidate commits and their scores. This is asynchronous sharing of artifacts, not direct point-to-point conversation between sessions.

After an agent edits a candidate, the judge evaluates it. The harness appends the candidate, score, and feedback to that agent’s search state and records the turn in its session. Peers can then encounter that candidate before their own proposals.

Communication spreads candidate solutions, but it does not reset any agent’s growing session. At the round boundary, forgetting applies to the entire team: select the best candidate across agents, discard every individual session and search state, and seed every new search state with that same candidate.

The shared seed preserves the strongest artifact without preserving all the routes taken to reach it. It also does not guarantee diverse next proposals: agents receive the same starting candidate and instructions. How much exploration can a fresh context recover from that common starting point?

Minimal Causal Code

This illustrative loop uses PyTorch tensors for scores, but the important state is ordinary session and candidate records. The harness supplies the agent, judge, and score-comparison functions. Turns are serialized here to expose the updates; the team implementation runs agents in parallel.

import torch

# A record contains a candidate commit, its score, and judge feedback.
def evaluate(candidate):
    score, feedback = judge(candidate)
    return (candidate, torch.as_tensor(score), feedback)

best = evaluate(initial_candidate)

for round_budget in round_budgets:
    # Forget both memory types. Only the best record crosses the boundary.
    seed = best
    sessions = [new_session(instructions) for _ in agents]
    histories = [[seed] for _ in agents]

    for _ in round_budget:
        for i, agent in enumerate(agents):
            peer_candidates = [
                (record[0], record[1])
                for j, history in enumerate(histories)
                if j != i
                for record in history
            ]
            candidate = agent.propose(
                session=sessions[i],
                own_candidates=histories[i],
                peer_candidates=peer_candidates,
            )
            record = evaluate(candidate)
            histories[i].append(record)
            # propose records the turn in the supplied session.
            if score_is_better(record[1], best[1]):
                best = record

score_is_better follows the task’s scoring convention. The visible reset is the replacement of both sessions and histories; retaining best alone would not clear either memory channel.

What You Gain, and What You Lose

You gain fresh context and a clean candidate workspace without abandoning the best solution. Fresh context and search state are associated with more thinking tokens and much larger edits in the reported observations. Communication still lets agents encounter useful peer candidates within a round.

You lose the accumulated sessions, alternative candidates, and their recorded feedback as inputs to the next round. A useful warning from an earlier failure may disappear along with an unproductive direction. Keeping the best artifact preserves a result, not the reasoning behind it.

There is also a shared-seed tradeoff: everyone benefits from the team’s strongest candidate, but earlier alternatives are no longer available as separate starting points. Forgetting is not the same search with cheaper memory. It deliberately changes what the next search can remember.