01 / Plan
Scheduling the work
What should run at once, what depends on what, and what needs a longer time horizon?
The next layer of software automation
From coding agents to
Concurrent Delivery.
Coding agents automate implementation. The next frontier is automating coordination: deciding what runs together, managing shared state, integrating changes, and knowing what's safe to ship.
01 / Coding agentsAutomate creation
02 / Concurrent DeliveryAutomate coordination
The coordination challenge3 interactive views
Different clocks.
One shared system.
The work is parallel. Dependencies, decisions and releases are still connected.
A concurrent workflowIllustrative / not live data
01 / Overlap
Tasks start and finish on different clocks. Progress overlaps; dependencies don’t disappear.
Concurrency is a design choiceNot a worker count ↗
The central tensionMore work in flight. One shared reality.
01 / The problem space
Concurrency creates leverage.
And new friction.
The interesting question isn't how many agents you can run. It's what happens when their work touches the same code, state and decisions.
02 / Isolate
Sharing the world
Separate code is easy. What about shared databases, ports, services, and environments?
03 / Coordinate
Coordinating intent
How do agents manage overlapping ownership, interfaces, and mutable state?
04 / Integrate
The integration queue
What happens when changes are produced faster than the system can merge them?
05 / Verify
Proving it's safe
Who verifies combined outcomes, evaluates risks, and decides what can ship?
06 / Remember
Remembering why
How do decisions, evidence, and intent survive agents, branches, and time?
And it doesn't stop
at engineering.
As the factory gets faster, product can make more bets, customers can shape their own variants, and human vs. agent cost changes what is worth building. Meanwhile, competitors—and open source—can catch up faster. Delivery becomes a business decision as much as an engineering system.
02 / The landscape
Different problems.
Competing approaches.
Pick a delivery tension. Compare the mechanisms being tried, what they protect, and what they cost. Follow the projects to their original sources.
Choose a tension
04 / IntegrateA landscape of approaches
What should be tested together before it lands?
A green check on each branch is not a green check on their combination. The choices differ in what they assume about independence and what they spend on CI.
Emerging approaches03 approaches
01
Test a predicted future mainline
Merge trains verify cumulative states such as A, A+B and A+B+C before any of them reaches main.
Trade-off: Speculative checks consume CI and later checks may need to restart.
02
Declare the boundaries of independence
Scope-aware queues allow separate areas to move concurrently while still ordering overlapping work.
Trade-off: Scope maps can miss dependencies that cross a module boundary.
03
Move coordination earlier
Use contracts, ownership signals or merge-conflict forecasts before the changes arrive at the gate.
Trade-off: Earlier coordination reduces ambiguity but moves work into planning.
The comparison: test cumulative future states, declare independent scopes, or accept isolated risk. Those are different safety guarantees.
WHAT TO WATCHSpeculative CI runs invalidated by earlier failures.
Projects illustrate approaches; inclusion is not an endorsement. Try the source links to judge the claims.
Project index
Projects, not rankings / 30
A curated source index. Descriptions are based on public documentation, not hands-on benchmarks or rankings.
03 / Field notes
An argument is more useful
when you can test it.
Short essays built around specific engineering mechanisms, documented sources and a question that remains unresolved.
Featured essay / Integration5 min read ↗
Merge trains · Contracts · Prediction
The integration tax starts before the pull request.
Green pipelines on separate changes do not guarantee one working system. Where merge trains help, what they cannot decide, and where the cost moves next.
Read the essay
Isolation / 4 min readA worktree
is not a world.Separating source code isn't the same as separating databases, services, test fixtures and runtime state.Read the essay Decision history / 4 min readSave the decision,
not just the session.A task graph tells you what remains. A transcript tells you what happened. Where do the consequential decisions live?Read the essay
is not a world.Separating source code isn't the same as separating databases, services, test fixtures and runtime state.Read the essay Decision history / 4 min readSave the decision,
not just the session.A task graph tells you what remains. A transcript tells you what happened. Where do the consequential decisions live?Read the essay
Working essays, not performance studies. Examples are identified as hypothetical; claims link to public sources.
04 / Reading
Start with
the sources.
Good ideas have names, implementations and limitations. Six useful entry points into the conversations behind the landscape.
Selection is editorial, not a ranking or an independent performance assessment.
Suggest something missing010203040506
GitLab — Merge trains
Documentation · IntegrationSpeculatively tests combined future states (A, A+B, A+B+C), not simply isolated pull requests.
Mergify — Queue modes
Documentation · IntegrationSerial, parallel and isolated modes make different choices about throughput and risk.
BranchBox — Branch the runtime
Open source · IsolationMoves isolation beyond Git, toward running containers, networks, ports and databases.
Beads — Persistent task state
Open source · PlanningA dependency-aware issue graph that survives individual coding-agent sessions.
Loom — Predict conflicts earlier
Open source · CoordinationAn experiment in forecasting merge conflicts while parallel work is still happening.
AI21 — Budget-aware best-of-N
Research · Agent economicsA different question: when is another parallel candidate worth its compute cost?
The Concurrent Delivery digest
An occasional update.
Worth opening.
New tools, research worth reading, and arguments that changed our minds. A monthly email digest is planned; the working notes already have an RSS feed.
05 / Patterns (early)
Observe first.
Name later.
Tools are arriving faster than durable patterns. For now, we're collecting candidate mechanisms, examples, and counterexamples—not declaring a playbook.
Candidate
Isolate exploration, converge deliberately
Give parallel work separate state, and make shared integration a deliberate act.
Candidate
Anticipate integration while work is in flight
Use early signals to predict conflicts and test combinations before they land.
Early ideas — this section will grow more slowly than the tool landscape.
Help build the map
Found something
worth mapping?
Know a tool, paper, post, talk, or tiny experiment we should be tracking? Send the link and a sentence about why it's interesting. Contributions are welcome—even if the idea is unfinished.
Contribute to the field guide ↗
Looking for: Tools / Research / Essays / Counterexamples
One good link is enough to start.
One good link is enough to start.