How do you merge work produced by multiple coding agents?

The mechanical part is ordinary and the discipline is not to skip it. Take one change, rebase it onto the current state, run the full test suite, review, merge. Then the next one, rebased onto the result. Merging several at once, or merging each against the state it was written on, is where the trouble comes from, because each was developed against a base that no longer exists.

The failure that matters is the semantic conflict: two changes that touch different files, merge without complaint, and are incompatible in behaviour. One adds validation at the boundary while the other assumes the value was already normalised. Two independent implementations of the same helper, both correct, now both present. A field interpreted differently by two new readers. Nothing in the version control system knows about any of this, and the tests will only catch it if a test happens to exercise both paths.

This is why re-running the full suite after each rebase is not a formality. A change that passed on its own base is untested on the merged base, and the semantic conflict is precisely what appears in that gap. It is also why the order can matter: integrating the change that alters shared behaviour before the ones that build on it surfaces the incompatibility while it is still one change's problem.

The strongest preventive measure sits before the work rather than after it. Agreeing the interface between the pieces in advance — what each will own, what shapes they exchange, which one is responsible for a shared concern — removes most semantic conflicts by construction. Parallel work without that agreement is two independent designs that have to be reconciled during integration, which is the most expensive place to do it.

During integration, a specific check is worth doing manually: look for the same thing implemented twice. Two agents solving adjacent problems will each write the helper they needed, and both will merge cleanly. A search for the new function names across the merged result takes a minute and finds this reliably, whereas reading the two diffs separately does not, because each is individually sensible.

Finally, resist reconciling by having an agent merge the branches. It will produce something that compiles and passes, by choosing between the two designs in a way nobody decided. Where two changes conflict semantically, the resolution is a decision about which approach the system takes, and that decision should be made explicitly and then implemented, rather than discovered afterwards in the merged code.