Branching and Convergence

What It Is

When you generate five possible approaches, you turn one problem into several branches. When you choose an approach or combine the useful parts, you turn those branches into one result. Branching and convergence name these two operations: DIVERGE makes one thing into many; CONVERGE makes many things into one.

Every cognitive process is built from these operations. Exploring, simulating, diagnosing, monitoring, and calibrating arrange them differently, with changes in time direction, persistence, and memory. In computational terms, they form a generative grammar: a few rules generate many operations, just as a few production rules can generate an infinite language. Naming the arrangement lets you find which operation is failing. Branching and convergence almost never fail together.

AI has made their costs radically unequal. A prompt can generate options; an agent can open another branch. Divergence is nearly free. Convergence has not become cheaper: someone still has to decide what survives, resolve conflicts, and produce a finished result. It is now the bottleneck in most intelligent people's workflows and most AI tooling. Search vs Planning asks when to search. Branching and convergence describe what happens inside that search.

The cycle can happen within a small decision or across a larger project; generating more options does not itself select one.

Read this diagram

Generate alternatives → Compare them → Merge a result → Explore the next question → Generate alternatives.

The Generative Grammar

The two-operation version emerged while working through a taxonomy of AI processes:

There are TWO fundamental moves: 1. DIVERGE: one → many (explore the space) 2. CONVERGE: many → one (collapse the space). Everything is a composition.

Diagnosis traces many observed effects backward toward one cause. Monitoring repeatedly reduces incoming signals to a current assessment. Calibration adds a loop and memory: the last prediction's error changes the next prediction.

Autoresearch applies the same operations recursively. An agent opens branches, evaluates them, and runs further searches inside them: "the agent decides when to branch, the human provides the convergence criteria... it's recursive DIVERGE→CONVERGE. not one cycle — as many cycles as the problem needs, nested as deep as it needs, with the agent owning the tree traversal."

This applies composition to cognition. Complex operations are arrangements of a few simpler ones. Once you identify the arrangement, you can reconstruct it or find a missing part.

Although the final taxonomy took one sitting, its components had been rederived over two years. An early conversation-design language prompted the observation "oh wow, it naturally makes a tree": decisions were arranging themselves into branches. A year later, the operations were Branch, meaning independent paths from the same context; Extend, meaning generation within one path; and Merge, meaning filtered combination of paths. Extend then reduced to DIVERGE with a branching factor of one. The same two primitives survived each restatement, which is the signature of an attractor.

Decisions form a tree. You answer one question, and that answer constrains which branches remain possible. Life and work are searches through such trees; these operations describe how you traverse them.

Breathing, Not Phases

Branching and convergence recur throughout adaptive systems:

DIVERGE and CONVERGE are actually... breathing. expansion and contraction. every intelligent process in nature does this: explore then exploit, search then select, generate then evaluate, diversify then specialize. the reason these feel fundamental is because they ARE fundamental — they're the two phases of any adaptive system solving any problem.

A slime mold extends into available channels, then reinforces the paths that found food. This also supplies the image in Intelligence Is Water. On a nine-hour walk through Golden Gate Park, Will deliberately took every fork he had not walked before:

The ability to explore. It's not about deeply, it's about exploring. And I don't think it's about breadth as well, it's about... exploring depth and breadth like branching. I want to branch into a lot, and I want each branch [to] cover a lot, and then I wanna be able to sample from that set... Like a slime mold, right?

Both operations are required. Repeated expansion without selection leaves possibilities open; repeated selection without expansion exhausts what there is to choose from. Breathing expresses that dependence: an organism that only inhales bursts, and one that only exhales suffocates. The useful process is the repeated rhythm of expansion and contraction.

The Dao De Jing describes a bellows: "The space between heaven and earth — is it not like a bellows? Empty, yet inexhaustible; the more it moves, the more it yields." Alternating expansion and contraction keeps the forge alive. Cognition has no third operation. An apparently unique form of thinking consists of these operations, or has stalled between them.

Shipping Is Merging

At Sim, Will generated AI videos across roughly a hundred parallel worktrees. Each agent's branch contained interesting material. None contained a complete video. The generation felt productive, but had produced no finished work:

the work only actually got done once I started converging those works because each of those work trees were just like AI generation and they each had interesting ideas... but none of them were complete. So I created this merging structure where I would sequentially go over video by video and take pieces and then combine them into the composition that I liked.

The procedure had four parts:

1. One trunk. Choose a single canonical composition into which the branches will merge. A folder of finalists still leaves the decision open.
2. Sequential passes. Evaluate one branch against the current trunk. Each merge changes the trunk, so the order affects later decisions.
3. Harvest, don't adopt. Take the pieces that work. Most branches contribute something, while almost none deserve to survive intact.
4. Kill after harvest. Delete a branch once its useful material is in the trunk. Keeping it creates ambiguity about which version matters.

Days later, he connected that process to a broader difficulty:

now I see convergence and merging is one of the key things that I've been missing in my life because I was always generating new ideas but there's no closing loop and I realized shipping means merging because Anthropic even measures progress with how many PRs get merged.

Shipping applies convergence where explored possibilities become an actual change in the world. A merged pull request, published essay, or executed decision reduces many explored microstates to one result. That makes reality contact part of the selection process: "CONVERGENCE COMES AFTER REALITY CONTACT. Convergence = collapsing the superposition. This is my religion."

Open branches are in superposition: many possible artifacts with none yet actual. Merging is the measurement that collapses the wavefunction into one real thing. Until that happens, the work contains probability mass rather than output.

Gate It at the Merges

Will had assumed that parallel work was useful only when a task could be decomposed into independent pieces. His video workflow moved the constraint to the other end:

everybody can work in parallel. Doesn't mean that the work is parallelizable, it just means that the results are mergeable back into the main trunk, back into their main thread to be combined... You gate it at the merges. You can have AI work on its own branches, but [it] depends on how the stuff gets merged. That's the key thing... usually, a lot of work goes into merging.

His conclusion was that "the real determinant is whether the thing can be MERGED from parallel results."

Merging is irreducibly sequential. One intelligent process has to resolve conflicts against a single trunk, one at a time. Upstream work can expand in parallel, but this join cannot. Amdahl's law describes the limit: however many parallel agents you add, their speedup is bounded by the serial fraction, which here is the merge.

Before spawning N branches, decide where their results will go and how conflicts will be resolved. Otherwise you defer the cost of integration while generating more work that requires it. This is order of determination applied to workflow: establish the receiving structure before expanding into branches.

Human teams have the same requirement, which Will described as "convergence as a general principle of how people work together": "they can all go out and do their things, but there has to be a process that brings them back together." Without it, their work remains separate despite belonging to one organization. This helped him identify an executive responsibility: "even the CTO feels like the one in charge of getting things merged." Most coordination problems come down to unclear branch boundaries, missing agreements about how work will combine, or no place to combine it. Those are specific structures a team can build under the vague diagnosis of “communication issues.”

Merge Debt

Merge debt accumulates when a workflow generates parallel work faster than it integrates it. While a branch waits, the trunk changes. Assumptions drift and interfaces move. A reconciliation that would have taken minutes when the branch was created can take hours a month later. The branch loses value while its integration cost grows, whether anyone opens it or not.

More agents can therefore create more liability:

"A thousand outputs each requiring human reading is a thousand new open loops — merge debt, not value."

Machine-speed generation feeds a human-speed review queue. Each open branch also requires someone to remember that it exists and what remains unresolved, so the debt consumes working memory before it appears as a project-management problem. Open-branch count and time since the last merge measure this accumulation.

AI can also work on integration: "as well as AI can generate branches, it can also hold branches in memory and merge them." Reconciliation used to be a fixed human bottleneck; it no longer has to be performed by a human. Spending the entire AI budget on generation leaves this capacity unused while adding to the review queue.

The Chronically Missing Half

Nearly all AI tooling produces more drafts, agents, or branches. Will's list of missing infrastructure focused on bringing their results together:

the real missing pieces are convergence logic, stopping criteria, branch visibility, merge review, macrostate summarization, controlled resource allocation, better branch management, better convergence surfaces, explicit stopping conditions, merge tooling, eval layers, approval interfaces, shared context structures, and visibility into the search itself.

All of these support the many-to-one operation. Sorting tools by what they do makes the imbalance visible:

AI can perform either operation: "AI can be a force for branching (generate more examples) or convergence (merge and finalize and check off)... use it to generate components, make arbitrary-granularity edits for polishing, merge code that deserves to be one component." Generation makes an appealing demo, which is why tools default to it. Integration still needs doing.

People who generate ideas easily can have the same imbalance. Will described his own: "my whole life has been really good at creating new brands and new ideas... but the opposite end of it — that's why convergence spoke to me."

the core of execution seems to be generation, pruning, promotion, debugging, and merging — and merging is where I am weakest. Progress feels like how fast you merge.

The result is a collection of valuable unfinished work: drafts at 70%, prototypes that almost work, and good ideas that never close. Reducing that collection by abandoning projects can feel like completion. Will called this a sharp exit:

if your definition of "closing the loop" is just sharp exit rather than graduated deliberate convergence then you're not actually learning how to ship — you're learning how to abandon branches, accumulate near-finished artifacts, and mistake premature escape for completion.

Abandonment reduces the number of branches by discarding their value. Merging transfers that value into the finished result. The branch count alone cannot tell you which happened.

Why AI makes the sharp exit cheap

Deliberate convergence takes repeated small decisions: fix a kink, approve a section, combine the parts, and finish. A sharp exit leaves the artifact at 90% and moves to something else. AI makes that exit catastrophically cheap because another enjoyable round of generation is always available. If someone already escapes when work becomes tedious, the larger possibility space gives them more occasions to do so.

During a day spent trying to finish one video, Will observed this transition:

I'm really excited about the high temperature part where I'm just thrashing around, but when it comes time to close in on one video and get it absolutely right... it feels like I enter ADHD mode. I suddenly get distracted and go find World Cup stuff. Or scroll DoorDash.

Why did polishing take 3x the work? His answer was "not purely cuz of work but PATIENCE aka endurance for boredom and discipline (as in stick to the process)." Boredom triggered an exit before the merge finished. Intending to converge never solves this; the workflow has to force it.

The design response was to "use AI beyond generation by focusing on sequencing, closure, and convergence." Guided SOPs and tools that support the next finishing step install discipline in the process. Will connected this to his previous startup's accumulation of nearly finished artifacts: "this is another chance to redeem myself and fix a major flaw that I saw in myself and in my previous startup."

The quickest diagnostic is how closing feels. Relief from escaping a branch means you abandoned it. Deliberately resolving its remaining questions and transferring its value into the trunk means you shipped it.

Those remaining questions matter because "convergence comes from reducing ambiguity rather than expanding the possibility space." Each resolved question, fixed constraint, or merged fragment removes a degree of freedom. Continued decisions narrow the space until one artifact remains. Discretization can help by turning a continuum into distinct states that can be decided between; it performs a many-to-one reduction on the representation itself.

An Agent Is a Search With a Termination Condition

Will's definition of an agent makes convergence a requirement:

I personally think an agent is a search loop with a termination condition... I think about it as: it's trying to fulfill a macrostate, it's a search, and there's a terminating condition — [a] converging condition. It kind of needs to converge in order to be intelligent.

He described "intelligence more like a slime-mold search process with a convergence loop."

This requires three components. A macrostate states the constraints a result must satisfy, without dictating every microstate along the way; see macrostate engineering. A search repeatedly branches over possible actions. A termination condition tests whether the result satisfies the constraints and ends the loop. Without that third component, the system is an unbounded branch generator. The convergence condition is what makes it an agent.

The same reasoning changes how a goal is stated: "When I state a goal, it is search over implementation space, not an arbitrary target anymore... I am searching for the configuration that works rather than the output, because this is the thing that generates the output."

Missing an output target invites moralizing about willpower. Describing the conditions that would produce the output gives you something to search for. Generate configurations, test them against those conditions, and select one that works. Motivation problems then become search problems whose complexity structure can be changed.

Oscillation Is Convergence in Slow Motion

For two years, Will moved between projects and vocabularies. From outside, taskbox → unix box → taskbox looked like repeated pivoting:

He saw taskbox → unix box → taskbox without access to internal reasoning about convergence. From his perspective: oscillation. From mine: search that converged. Difference: he didn't get to watch the search.

An April 2024 product suite, sketched at 1:34am on a flight, later mapped one-to-one onto the system built in April 2026. "The object has been structurally identical since night one. The vocabulary changed ~10 times. The attractor never moved. [Cortex] never changed names once in 24 months." His worklog recorded the interpretation:

The 4-week oscillation wasn't indecision, it was convergence in slow motion on a single coherent object.

An observer sees the visited states but may not see the possibility space shrinking. Each pivot evaluated a branch, each return reasserted the attractor, and the two years formed one extended search. To distinguish this from churn, ask whether the candidates are drawing closer to a fixed point. Repeatedly deriving the same object under new names indicates that the search is progressing toward an attractor.

Convergence still has to follow. Will announced "this year is going to be the year of integration, merging all these divergent branches back into the main trunk" and named the umbrella "Convergence Labs. Things that converge — not just expand in capacity, but converging to actual reality." The extended search is justified only when its results join into one trunk.

The mastery ladder describes the same motion from the learning side: adapt fully to an environment, graduate when it stops requiring interventions, and move to the next. What looks like a search converging from outside can feel like completing a rung from inside.

Failure Modes

Each failure performs one operation while neglecting the other. Identify which operation is missing and require it. With only one idea, generate alternatives. With forty open branches, further generation cannot be the bottleneck; the work needs a merge.

Running the Grammar

1. Name the phase. Know whether you are generating or selecting. Judging while generating produces timid branches; generating while judging produces sloppy merges. Keep the operations separate, as described in Selection over Design.
2. Give every diverge a converge appointment. Schedule an edit for the braindump, a synthesis deadline for exploration, and a termination condition for the agent. A branch without a scheduled conclusion creates a liability.
3. Design the merge surface before the fan-out. Answer how the results will combine before deciding how many processes to run. Without that answer, parallel execution does not produce an integrated result.
4. Accept that the merge is sequential. Budget real time for it, usually more than generation required. Trying to parallelize away conflict resolution does not remove the need to resolve conflicts against one trunk.
5. Converge by removing ambiguity. Resolve degrees of freedom during each convergence session. Track how many remain, rather than how many candidates have been generated.
6. Force convergence structurally. Will observed that "the best shippers force convergence or have built structures in their habits for forcing convergence." Use forcing functions such as deadlines, demo days, merge reviews, and publishing schedules. Intention alone does not produce convergence.
7. Reconcile in the branch, never on trunk. If a merge conflicts, reset the trunk to its clean state. Merge trunk into the branch, resolve the conflicts there, and retest before merging back. The canonical artifact stays coherent while one sequential intelligent process resolves the branches.

Diagnostics

• Open-branch count. Count work that has started but has not merged. Above your personal threshold, freeze new branches until the count drops.
• Time since last merge. Record the last result shipped, published, decided, or closed into the trunk. Weeks of activity without one indicate stalled convergence.
• Ratio of generation time to merge time. A 10:1 ratio indicates hoarding rather than useful parallelism.
• Does every running search have a stated termination condition? Name the required macrostate and how it will be checked. Without that, the process is an unbounded diverger.
• When you "finish" something, was it merged or abandoned? Count value transferred into the result. Discarded value cannot compound.

Integration with the Mechanistic Framework

Connection to Selection over Design

The sample→select→promote loop uses divergence to generate an ensemble and convergence to select and promote from it. This article names the operations; Selection over Design builds a creative procedure from them.

Connection to Search vs Planning

Search vs Planning decides whether to search against reality. Branching and convergence describe the resulting tree and its pruning. Planning also uses the same operations: it simulates possibilities forward in time, then selects among them in imagination.

Connection to Intelligence Is Water

Water branches into channels and converges into rivers; slime mold explores broadly and then retains an efficient network. These describe the continuous version of the grammar. Divergence sends flow into available structure, and convergence selects which flows persist.

Connection to Macrostate Engineering

A macrostate specifies one required aggregate while allowing many acceptable microstates. This makes success checkable, which makes termination possible. Statistical mechanics develops the distinction between the aggregate and its possible configurations.

Connection to Superposition

Open branches contain real probability mass and zero actuality. Merging measures and collapses them. Superposition describes holding unresolved possibilities; convergence ends that hold.

Connection to Reality Contact

"Convergence comes after reality contact." This ordering is required because selecting before testing means judging branches by simulated fitness. That can produce an elegant result that is wrong. Generate possibilities in simulation, then use contact with reality to select.

Connection to Compounding Artifacts

Only merged branches compound. An unmerged branch holds potential that decays; a merged branch becomes part of the trunk from which later work starts. An accrual substrate makes those merges permanent.

See Also

• Selection over Design — sample, select, and promote as a creative procedure
• Search vs Planning — when to test branches against reality
• Intelligence Is Water — branching and channel selection in continuous flow
• Superposition — holding open possibilities until a merge
• Macrostate Engineering — stating checkable convergence targets
• Order of Determination — what to decide before opening branches
• The Braindump — generating without judging
• Composition — building complex operations from simpler ones
• Discretization — making continuous spaces decidable
• Forcing Functions — requiring convergence through structure
• Working Memory — the cost of keeping unresolved branches in mind
• The Mastery Ladder — completing a rung before changing environments