Branching and Convergence

What It Is

Branching and convergence are the two primitive operations underneath every cognitive process. DIVERGE takes one thing and makes many: generating options, spawning branches, expanding the possibility space. CONVERGE takes many things and makes one: selecting, pruning, merging, collapsing the space into a decision, an artifact, a shipped result. Everything that looks like a distinct mode of thinking — exploring, simulating, diagnosing, monitoring, calibrating — is a composition of these two moves.

In computational terms: this is a generative grammar, not a taxonomy. Two primitives plus a small set of modifiers (time direction, persistence, memory) generate the entire space of higher cognitive operations, the same way a handful of production rules generates an infinite language. When you understand a process as a specific composition of DIVERGE and CONVERGE, you can debug it at the level of the primitive that is failing — which matters because the two primitives almost never fail together.

Why it matters: the costs of the two primitives just went radically asymmetric. AI made divergence nearly free — every prompt is a branch generator, every agent a fork. Convergence did not get cheaper. It is now the scarce operation, the bottleneck, and — in most intelligent people's workflows and in most AI tooling — the chronically missing half. This article extends Search vs Planning: where that article asks when to search instead of plan, this one gives the internal anatomy of the search itself.

The Generative Grammar

The grammar was derived in a single sitting, working through a taxonomy of AI processes until the taxonomy collapsed into two moves:

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

The compositions are load-bearing, not decorative. Diagnosis really is convergence run backward through causality — many observed effects collapsing onto one cause. Monitoring really is a convergence operator left running: a persistent process that keeps collapsing a stream of signals into a single state assessment. Autoresearch — an agent researching on its own — is the grammar made recursive: "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."

The modifiers are worth naming separately, because they are the whole difference between operations that feel unrelated:

This is the same structural claim as composition applied to cognition: complex operations are not new atoms, they are arrangements of a very small set of atoms. If you can name the arrangement, you can rebuild the operation from parts — or notice which part is missing.

The grammar did not arrive fully formed; it converged (fittingly) across two years of rederivation. An early conversation-design language produced the observation "oh wow, it naturally makes a tree" — decisions spontaneously arranging themselves into branch structures. A year later the operations were formalized as Branch (independent parallel paths from the same context), Extend (generation within a path), and Merge (combining paths into one, with filtering). The final compression collapsed even those three: Extend is just DIVERGE with branching factor one. Two primitives survived every restatement — which is itself the signature of an attractor, a theme this article returns to below.

Decisions, then, are not a list you work through; they form a tree you traverse. You explore a decision space one question at a time, each answer spawning constraints that prune the remaining branches. Life and work are tree search, and the grammar is the instruction set of the traversal.

Breathing, Not Phases

Zoom out one level and the grammar stops looking like a piece of process engineering and starts looking like something older:

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.

The slime mold is the canonical image — the same one that anchors Intelligence Is Water. Intelligence as a fluid that branches into every available channel and then reinforces the channels that worked. Will rehearses this physically: on a nine-hour walk through Golden Gate Park he deliberately took every un-walked fork —

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?

The key property of breathing: neither phase is optional, and neither phase is the point. An organism that only inhales bursts. An organism that only exhales suffocates. The intelligence is in the rhythm — expand the space, collapse the space, repeat — not in either half alone. See rhythm.

The Dao De Jing reaches for the same image from the other direction: "The space between heaven and earth — is it not like a bellows? Empty, yet inexhaustible; the more it moves, the more it yields." A bellows is a machine made of nothing but alternating expansion and contraction, and it is enough to keep a forge alive. The claim of this article is that cognition is a bellows: there is no third stroke. Whatever you are doing right now that feels like a unique, unclassifiable kind of thinking is one of the two strokes, or a stall between them.

Shipping Is Merging

Here is the operational payoff, and the N=1 case study that produced it.

Working at Sim, Will generated AI videos at scale: roughly a hundred parallel worktrees, each an agent's branch, each containing interesting fragments, none complete. The generation phase felt like enormous productivity. It produced nothing.

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 merging structure is worth spelling out, because it is the template for converging any pile of parallel AI output:

1. One trunk. A single canonical composition that everything merges into — not a folder of finalists.
2. Sequential passes. One branch at a time, evaluated against the current trunk. No batch judgment; the trunk changes with every merge, so the ordering matters.
3. Harvest, don't adopt. Take pieces from each branch — the fragment that works — rather than crowning whole branches. Most branches contribute something; almost none survive intact.
4. Kill after harvest. Once a branch's value is extracted into the trunk, the branch is deleted. Its persistence would be pure ambiguity.

The generalization arrived days later:

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 is not a separate skill from thinking. Shipping is the CONVERGE primitive applied at the boundary between your branches and reality. A pull request merged, an essay published, a decision executed — each is a many-to-one collapse where the many is your explored microstates and the one is the state of the world. This is why convergence pairs with reality contact — as Will canonized it: "CONVERGENCE COMES AFTER REALITY CONTACT. Convergence = collapsing the superposition. This is my religion."

The superposition language is exact. While branches are open, your work exists in superposition — many possible artifacts, none actual. The merge is the measurement: it collapses the wavefunction into one real thing. Until the collapse, you have probability mass, not output.

Gate It at the Merges

The standard model of parallel work says: a task can be parallelized if it can be decomposed into independent pieces. Will's discovery inverts where the constraint actually lives:

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.

He had believed parallelism was only useful when a task could be decomposed into independent pieces; the corrected model is that "the real determinant is whether the thing can be MERGED from parallel results."

The merge is irreducibly sequential: one intelligent process has to resolve the conflicts between branches, one at a time, against a single trunk. Everything upstream can fan out; the join point cannot. This is Amdahl's law for cognitive work — your speedup from infinite parallel agents is bounded by the serial fraction, and the serial fraction is the merge. The practical corollary: before spawning N branches, build the structure that will receive them. Divergence without a designed merge surface is not parallelism; it is deferred waste. The ordering question — what must be pinned down before the fan-out — is order of determination applied to workflow.

The same law governs teams of humans, not just teams of agents. Will's articulation of "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." An organization without that process is a hundred private branches wearing a shared logo.

The Chronically Missing Half

Convergence is missing in two places at once, and the deficits compound.

Missing from the tooling. Nearly all AI tooling is divergence machinery: generate more drafts, spawn more agents, produce more branches. Will's audit of what agent infrastructure actually lacks reads as a convergence shopping list:

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.

Every item is on the many-to-one side. The industry built the inhale and shipped it. The imbalance is easy to see once you sort your own tools by primitive:

AI is not inherently a diverger — it can be pointed at either primitive. "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." The tooling defaults to divergence because divergence demos well; convergence is where the unglamorous work lives.

Missing from the person. The same asymmetry shows up in generative people, who are natively strong at branching. Will's own audit: "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." And more precisely:

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 failure mode has a specific texture: branches multiply, each accumulates real value, none closes. Drafts at 70%, prototypes that almost work, ideas that were genuinely good — a portfolio of open superpositions. And there is a counterfeit convergence to watch for, the 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.

Abandoning a branch feels like convergence because the branch count goes down. But abandonment discards the accumulated value; merging harvests it. The distinction is whether the many collapses into the one or merely disappears.

Why AI makes the sharp exit cheap

The two exits are opposites wearing the same costume, and AI subsidizes the wrong one. Graduated deliberate convergence is the slow collapse — fixing kinks section by section, approving each part, composing, shipping. Sharp exit is escape — declaring done, switching branches, letting the artifact sit at 90%. AI makes the second catastrophically cheap, because generation is so pleasurable and abundant that leaving a branch always offers a fresh one. That is the precise mechanism by which more AI can hurt you: AI produces state-space explosion, and if your loop-closing reflex is escape, more AI just means more abandonments.

The N=1 episode is a day spent failing to ship one video. The generation half was euphoric; the closing half triggered flight:

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.

Asked why polishing takes 3x the work, the honest answer was "not purely cuz of work but PATIENCE aka endurance for boredom and discipline (as in stick to the process)." The merge step is boring, and boredom triggers exit — which is why convergence never happens by intention and must be forced structurally. The design consequence Will drew the same evening: build AI systems that make you converge — "use AI beyond generation by focusing on sequencing, closure, and convergence." Guided SOPs, sequencing, closure support: discipline installed as tooling rather than summoned per branch. The stakes were personal — "this is another chance to redeem myself and fix a major flaw that I saw in myself and in my previous startup," the company that accumulated exactly those near-finished artifacts.

The diagnostic is felt-level, and it is the fastest test in this article: when you close a loop, notice whether it feels like relief-by-escape or deliberate collapse. Relief means the branch released you; collapse means you released the branch into the trunk. If closing feels like relief-by-escape, you didn't ship. You fled.

One more refinement about how convergence actually proceeds: "convergence comes from reducing ambiguity rather than expanding the possibility space." Convergence is not "pick harder." It is the incremental removal of degrees of freedom — each resolved question, each pinned constraint, each merged fragment shrinks the space until one artifact remains. Discretization is a convergence tool: cutting a continuum into discrete states is a many-to-one collapse you perform on the representation itself.

An Agent Is a Search With a Termination Condition

The grammar yields a compact definition of the thing everyone is trying to build:

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.

Not "a smart AI thing" — "intelligence more like a slime-mold search process with a convergence loop."

Three components: a macrostate to fulfill (the goal expressed as constraints, not microstate instructions — see macrostate engineering), a search (iterated DIVERGE over the space of actions), and a termination condition (the CONVERGE test that decides the macrostate is fulfilled and collapses the loop). Remove the third component and you don't have a weaker agent — you have a diverger, an unbounded branch generator. The convergence condition is what makes it an agent at all.

The same move works on goals themselves: "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."

A goal stated as a target invites moralizing about willpower when you miss it. A goal stated as a constraint set defines a search: DIVERGE over configurations that might satisfy the constraints, CONVERGE on one that does, and let the configuration generate the output. Motivation problems become search problems, and search problems have complexity structure you can actually engineer.

Oscillation Is Convergence in Slow Motion

The grammar also resolves a biographical accusation. From the outside, Will's two years of project-switching looked like pivoting — taskbox, then unix box, then taskbox again; vocabulary changing every month. A collaborator watching the surface saw circles:

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.

Then the archaeological check: an April 2024 product suite, sketched at 1:34am on a flight, mapped one-to-one onto the system actually 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." The verdict, written into the worklog:

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

Mechanistically: a search process visiting many microstates of the same macrostate looks like a person changing their mind, because an outside observer only sees the sequence of visited states, never the shrinking of the space. Each "pivot" was a branch evaluation; each return was the attractor reasserting itself; the two years were the DIVERGE phase of one long breath. The test that distinguishes convergent oscillation from actual churn is whether the candidate states are drawing closer to a fixed point — whether there is an attractor under the vocabulary. If the same object keeps being rederived under different names, that is not instability. That is a search reporting its progress.

And the breath eventually turns. Having spent the divergent years, Will declared the phase change out loud — "this year is going to be the year of integration, merging all these divergent branches back into the main trunk" — and named the umbrella for his work after the missing primitive: "Convergence Labs. Things that converge — not just expand in capacity, but converging to actual reality." The person-level pattern is the grammar again: a long inhale is only retroactively justified by the exhale that collapses it into one trunk.

Failure Modes

Each row fails one primitive while performing the other. The debug move is always the same: name which primitive the process is currently starved of, and force that one. If you have one idea, you need DIVERGE. If you have forty branches, absolutely nothing you generate next is the bottleneck — you need a merge.

Running the Grammar

1. Name the phase. At any moment, know whether you are diverging or converging. Mixed mode is the worst mode: generating while judging produces timid branches, judging while generating produces sloppy merges. Keep the phases pure (this is the same separation argued in Selection over Design).
2. Give every diverge a converge appointment. A branch spawned without a scheduled collapse is a liability, not an asset. The braindump gets an edit pass; the exploration gets a synthesis deadline; the agent gets a termination condition.
3. Design the merge surface before the fan-out. Ask "how will these results combine?" before asking "how many can I run?" If the answer is unclear, the parallelism is fake.
4. Accept that the merge is sequential. Do not resent it or try to parallelize it away. Budget real time for it — usually more than generation took. Progress is how fast you merge.
5. Converge by removing ambiguity. Each session should pin degrees of freedom, not add options. Track the dimensionality of the remaining space, not the count of generated candidates.
6. Force convergence structurally. Will's observation: "the best shippers force convergence or have built structures in their habits for forcing convergence." Convergence does not happen by intention; it happens by forcing function — deadlines, demo days, merge reviews, publish schedules.

Diagnostics

Quick reads on the state of your own breath:

• Open-branch count. How many started-but-unmerged things exist right now? Above some personal threshold, declare a merge freeze: no new branches until the count drops.
• Time since last merge. Not last idea, not last work session — last collapse into trunk: shipped, published, decided, closed. Weeks without a merge is apnea, whatever the activity level says.
• Ratio of generation time to merge time. If it is 10:1, you are not parallelizing; you are hoarding.
• Does every running search have a stated termination condition? If you cannot say what would make a project done — which macrostate fulfilled, checked how — you are not running a search. You are running a diverger.
• When you "finish" something, was it merged or abandoned? Harvested value compounds; escaped value evaporates. Count only the first kind.

Integration with the Mechanistic Framework

Connection to Selection over Design

Selection is what a converge step does. The sample→select→promote loop is this grammar instantiated as a creative strategy: DIVERGE generates the ensemble, CONVERGE selects and promotes. The two articles are the same mechanism at different altitudes — this one names the primitives, that one names the algorithm built from them.

Connection to Search vs Planning

Search-vs-planning decides whether to run the system; branching-and-convergence describes what running it looks like from inside: a tree of diverge steps pruned by converge steps. Planning itself is simulation — DIVERGE→CONVERGE with forward time — so even the planner is running the grammar, just in imagination.

Connection to Intelligence Is Water

Water branches into every channel and converges into rivers. The slime mold explores as a sheet and collapses onto the efficient network. The fluid picture is this grammar with the discreteness removed: divergence is flow into structure, convergence is the structure selecting which flows persist.

Connection to Macrostate Engineering

A macrostate is the convergence target expressed at the right resolution: many acceptable microstates, one required aggregate. Defining macrostates well is what makes convergence checkable — you cannot terminate a search whose success condition was never stated. See also statistical mechanics for the macrostate/microstate machinery itself.

Connection to Superposition

Open branches are uncollapsed states: real probability mass, zero actuality. The merge is the measurement that collapses them. Superposition is the right way to hold unresolved possibilities; this article is about the operator that ends the hold — and about what happens when you never apply it.

Connection to Reality Contact

"Convergence comes after reality contact." The ordering is a dependency, not a preference: converging before touching territory means selecting among branches using simulated fitness, which is how elegant wrong things ship. Diverge in simulation if you like — but collapse only on contact.

Connection to Compounding Artifacts

Only merged branches compound. An unmerged branch is stored potential that decays; a merged one becomes trunk that every future branch builds from. The accrual substrate is, structurally, a trunk that makes merges permanent.

See Also

• Selection over Design — the algorithm built on these primitives: sample, select, promote
• Search vs Planning — when to run the diverge/converge loop against reality instead of planning
• Intelligence Is Water — the continuous-fluid version of branching and channel selection
• Superposition — open branches as uncollapsed states; the merge as measurement
• Macrostate Engineering — stating convergence targets at the right resolution
• Order of Determination — which degrees of freedom to pin before fanning out
• The Braindump — a deliberately pure diverge phase
• Composition — complex operations as arrangements of few atoms
• Discretization — collapsing continuous spaces into decidable states
• Forcing Functions — how convergence actually gets forced in practice

Core Principle: Every cognitive operation is a composition of two primitives: DIVERGE (one→many) and CONVERGE (many→one). AI made divergence nearly free, so convergence — pruning, merging, terminating — is now the scarce skill and the real bottleneck. Parallelizability is determined by mergeability, not decomposability: gate it at the merges, and accept that the merge is sequential. Shipping is merging; a branch that never collapses into the trunk is probability mass, not output; and what looks like pivoting from outside is often a search converging from inside.

Expand the space, then collapse it. Anyone can inhale — the ones who ship are the ones who learned to exhale.