Somewhere on your team, somebody has already solved a problem the rest are still living with: a skill that makes review faster, a pattern that keeps agents on the rails. Convergence is the discipline of turning that solo win into team practice: surfacing it where everyone can see it, packaging it so others can pull it in, and making it cheap enough to try that saying yes costs an afternoon.
When a good change propagates, skills travel across your repos and the tooling starts compounding: tools that build tools. The improvement outlives the person who found it, and the next hire inherits it instead of rediscovering it.
The discipline takes its name from the framework's diverge-then-converge principle. The principle names the posture: let people explore, then fold what works back in before everyone's practice drifts apart. This discipline is that posture at team scale: engineers experimenting on their own is the divergence, and Convergence is how the team closes the loop.
Exploratory
Improvements stay in the head of whoever found them. Nothing is shared or tried widely.
- Enables
- The person who improves gets the benefit at no coordination cost, and which of their wins others reach for on their own tells you which are worth spreading. That is what propagation later gets pointed at.
- Deficiencies
- Wins stay siloed, the same lesson gets re-learned, and there is no path from one person's change to team practice.
- Cost to maintain
- Re-paying for improvements that never propagate.
Techniques
None yet. Manual and ad hoc.
Expert-led
One person shares their wins informally and others copy them when they notice.
- Enables
- Some spread. The people close to that person pick up what works.
- Deficiencies
- A single point of propagation, sharing that is ad hoc, and opt-in that depends on being in the right channel.
- Cost to maintain
- Their time evangelizing, on top of the work itself.
Techniques
- . Reusable prompt documents that encode a workflow, its rules, and its anti-patterns, so a task starts from a runbook instead of a fresh explanation.
- . Catalog documents that encode the choices already made for a domain: which libraries to use, how to structure things, and the anti-patterns to avoid.
Documented
A sharing ritual runs, a retro or a demo, and adopting what a teammate built is deliberately made easy.
- Enables
- Changes reach the team rather than one corner, what is available to try is visible to everyone, and convergence happens by agreement.
- Deficiencies
- It still relies on the ritual running and people choosing to opt in, so a win lags before the team adopts it.
- Cost to maintain
- Holding the ritual and curating the shareable artifacts.
Techniques
- . A recurring retro or demo where engineers surface what worked, so a win reaches the whole team instead of dying in one person's setup.
- . Reusable prompt documents that encode a workflow, its rules, and its anti-patterns, so a task starts from a runbook instead of a fresh explanation.
- . Catalog documents that encode the choices already made for a domain: which libraries to use, how to structure things, and the anti-patterns to avoid.
- . A low-friction, reversible way to try a new practice, so adopting a change is a small opt-in step rather than a project.
Structural
Sharing and propagation are built into the everyday tooling. A proven change reaches every project with easy opt-in by default.
- Enables
- Convergence without manual copying, trials and opt-in built into the system, and improvements that compound.
- Deficiencies
- Automated propagation can spread noise as signal, and it needs guardrails on what auto-adopts.
- Cost to maintain
- Building and tuning the propagation, plus reviewing what it spreads.
Techniques
- . Config plus install scripts that propagate a skill or doc from one place to every project, so an update in one repo lands in all of them.
- . Reusable prompt documents that encode a workflow, its rules, and its anti-patterns, so a task starts from a runbook instead of a fresh explanation.
- . Catalog documents that encode the choices already made for a domain: which libraries to use, how to structure things, and the anti-patterns to avoid.
- . A low-friction, reversible way to try a new practice, so adopting a change is a small opt-in step rather than a project.
Convergence rarely stands alone. Where it overlaps a sibling discipline, an investment on one side quietly depends on the other. The Improvement domain page lays these out in full.
- Convergence and Prioritization
Prioritization decides which change earns the team's energy; Convergence gets that change out of one head and into everyone's workflow. Pick the right bet and never converge on it and you have a correct decision quietly decaying unused, re-earned by hand each time someone new needs it. Converge hard with nothing ranking what spreads and you propagate whatever got tried last, noise moving as fast as signal.
Held together, they are the difference between a good idea becoming standard practice and a good idea becoming a story about the one engineer who had it figured out.
- Convergence and Evaluation
Convergence is a multiplier, and a multiplier only helps if what it multiplies was worth spreading. Evaluation is the check that makes that call: it holds a change against a real standard of good before the team commits to it everywhere.
Without that check, Convergence works perfectly on the wrong input, rolling out to every repo the change that merely felt faster, and the better your propagation the wider that mistake travels. The point of running them together is a team that standardizes on what was proven, not on what demoed best last week.
The agent has what it needs to act.
- CollectionGetting context in: gathering the artifacts an agent needs to orient.
- ManagementKeeping the context your agents read current as decisions and conventions change.
- DisclosureFeeding context in efficiently: routing the agent to the slice it needs, not a data dump.
The agent can only do what it should.
- CapabilityWhat the agent can do: the tools you connect, and the ones you deliberately withhold.
- DelegationWhat the agent should do: the responsibilities you hand over, and the ones you reserve.
- EnvironmentThe system the agent works within: the tests and gates its work must clear, and the points where a human takes over.
The human can see what happened.
- CaptureMaking sure every run leaves a raw record.
- AvailabilityPutting the record of agent work where your team can query and review it.
- TraceWalking back through a single run, end to end, with the reasoning alongside the decisions.
The team gets better over time.
- EvaluationMeasuring whether your processes work, by the numbers and by gut-check.
- PrioritizationChoosing what to change and where to invest next.
- Convergence (current page)Making a change stick across the team.