Multivergence.com

Forkable State Gives AI Agents a Real Way to Try Before They Commit

Sun, 18 Oct 2026 00:00:00 +0000

Agents have started trying things before they commit. A coding agent sketches three plans for a refactor and keeps the one whose tests pass. A travel agent holds a train, a flight and a coach until the fares and the delays are in. A planner runs a few sequences of tool calls and takes the first that works. People do this too, of course. What’s new is that software is doing it hundreds of times an hour, and it needs somewhere to keep the alternatives while it decides.

Multivergence Launches as Open Source Forkable State for AI Agents

Sun, 18 Oct 2026 00:00:00 +0000

Multivergence 0.1 is out, open source under the Apache License 2.0. It’s a state engine for software that keeps several possible futures open at once: fork the state into branches, give each a weight, constraints and a deadline, let evidence thin them out, and promote the one that’s left. The code is on GitHub, and ready-built binaries for Linux, macOS and Windows are on the download page.

The first users in mind are AI agents that try before they commit. They fork a plan per approach, feed tool results back as facts and likelihoods, and promote the plan that survives. The explainer goes through why that job belongs in the state, where every agent can share it.

How Multivergence Was Tested With a Thousand Crashes and 86 Million Reads

Sun, 18 Oct 2026 00:00:00 +0000

A state engine for branching futures makes a handful of promises. A write to one branch never shows up in another. A promote happens completely or not at all, even if the process dies halfway. The same calls always give the same weights. Deadlines and constraints fire exactly when they should. And several processes can share one store without losing anything. Each of those got its own test, aimed at breaking it.

Why the Project Is Called Multivergence

Sun, 18 Oct 2026 00:00:00 +0000

The name is two halves of an idea. Divergence is the moment one state becomes several: an agent forks three plans and each goes its own way. Convergence is the moment they become one again: the evidence is in, two plans are dead, and the third becomes the state everyone works from. Multivergence is both halves, and the whole loop the engine runs.

It also says how many. A fork in version control is usually drawn with two branches. Here there are as many as the problem needs, each with its own weight. And it nods to the multiverse, many possible worlds alive at the same moment, which is a fair description of a store with a dozen live branches in it.

How a Coding Agent Tries Three Fixes at Once and Ships the One That Passes

Sun, 18 Oct 2026 00:00:00 +0000

A bug report comes in: Median([1 2 3 4]) returns 3, and it should return 2.5. A coding agent can usually think of more than one fix. The usual move is to pick the one it likes best, apply it, run the tests, and start over if they fail. Each failed attempt has to be undone by hand, and the working copy spends the whole time half changed.

With Multivergence the agent drafts all three fixes at once, each in its own branch, and lets the evidence pick. This case study walks through examples/fixes in the repository. The patches in it are real Go functions and the test suite really runs on them. Every number below is from its recorded output.

How an On-Call Agent Narrows Down an Outage With Weighted Hypotheses

Sun, 18 Oct 2026 00:00:00 +0000

At 14:02 an alert fires: checkout’s p99 latency is 4.8 seconds, against a normal 300 ms. Whoever is on call, a person or an agent, starts with a handful of suspects. The connection pool could be exhausted. The release that went out at 13:58 could be bad. A cache node could be failing, or the payment provider could be slow. Each suspect comes with its own fix, and picking the wrong fix costs time during an outage.

How an Agent Books a Venue With Four Holds Open at Once

Sun, 18 Oct 2026 00:00:00 +0000

Booking a venue for a team offsite is a waiting game. You ask a few places to hold the dates, and each hold runs out at a different time. Quotes come back over the afternoon and someone adds six people to the list; then the team votes. Somewhere in there a hold expires before anyone noticed, and the best option is gone.

Each hold is a possible future with a clock on it, which is exactly what a Multivergence branch is. This case study goes through examples/holds, where an agent keeps four holds open over two days. The figures come from its recorded output.

How a Dispatcher Keeps Four Delivery Plans Open Until the Van Leaves

Sun, 18 Oct 2026 00:00:00 +0000

Route planning for a delivery van usually happens once, early, on the information there is at 07:30. Then the morning changes it. A late order comes in and a lane closes on the ring road; the ferry stops taking bookings at 08:20. A plan made at 07:30 doesn’t know any of that, and a planner that recomputes from scratch each time loses track of what it already ruled out and why.

About

Mon, 01 Jan 0001 00:00:00 +0000

Multivergence is a small state engine for software that has to keep several possible futures open at once. You fork the current state into branches, cheaply. Each branch carries a weight for how likely it is, constraints for what must stay true, and a deadline for when it stops mattering. Evidence thins them out, and the one that wins is promoted to become the real state.

Why the Project Exists

AI agents increasingly try several approaches before committing to one. Three plans for a refactor, two booking options, a handful of tool-call sequences. The tools they use for this were built for something else. Git worktrees and container snapshots are full copies with no idea which copy is more likely, when one should be abandoned, or what result would settle it. Keeping the alternatives in the prompt has no state at all.

Contact

Mon, 01 Jan 0001 00:00:00 +0000

The project would like to hear from:

People building agents that try several plans, bookings or tool sequences before committing, about what they branch on and what settles it.
Teams behind agent platforms and workflow tools that need branch-and-commit state.
Anyone working on logistics, reservations, simulation or game search who holds several possible futures at once.
Anyone with a question about the engine, the demo or the figures on this site.

Write to info@multivergence.com.

Download Multivergence

Mon, 01 Jan 0001 00:00:00 +0000

Each archive holds two commands, multivergence and multivergence-demo, with the license files and the README. The links always point to the latest release.

System	Download
Linux, x86-64	multivergence_linux_amd64.tar.gz
Linux, ARM64	multivergence_linux_arm64.tar.gz
macOS, Apple silicon	multivergence_darwin_arm64.tar.gz
macOS, Intel	multivergence_darwin_amd64.tar.gz
Windows, x86-64	multivergence_windows_amd64.zip

Checksums are in SHA256SUMS. Every release is listed on GitHub.

Install

On Linux or macOS:

tar -xzf multivergence_linux_amd64.tar.gz
sudo mv multivergence multivergence-demo /usr/local/bin/
multivergence version

On Windows, unzip the archive and put the two .exe files somewhere on your PATH.

Quick Start

Mon, 01 Jan 0001 00:00:00 +0000

This page runs one small scenario three ways: from the shell, from Python and from Go. An agent is booking a trip and has three plans in mind. A fare search and a disruption feed come back, a seat hold runs out, and one plan is left. Every output below is what the command really prints, with its clock fixed so the times match.

Get the multivergence command from the download page first, or install it with Go 1.24 or later:

Reference

Mon, 01 Jan 0001 00:00:00 +0000

A short reference for the Go library and the multivergence command. The full versions are in the repository: the API and every command, the exact rules for weights, constraints and deadlines, and the file format.

The Pieces

Trunk. The state that is real now. Its name is trunk.
Branch. A copy-on-write fork of the trunk or of another branch. Writes to it stay in it. A branch that changes 3 keys of a 10,000-key trunk costs about 4 KB.
Weight. How likely a branch is, next to the others. Its probability is its weight over the total weight of the live branches.
Constraint. A condition on one key, such as fare/flight <= 400 or hold exists. When it stops holding, the branch dies.
Deadline. When a branch stops mattering. It dies at the first change made at or after it, and reads show it expired from that moment.
Observe. Applies evidence: facts written to the trunk and every live branch, then constraints, then likelihoods multiplied in, then the weights renormalised, then an optional prune.
Promote. Makes a live branch’s state the trunk, drops every branch, and starts the next generation. It’s one record in the file.
Stale. A branch forked before a direct write to the trunk. Promote refuses it, since promoting would lose that write.

How Observe Works

One call, in this order, all or nothing: