the result
Did the two halves actually integrate?
0/4
2 agents, no coordination — builds that actually integrated
4/4
the same 2 agents + Aethereum
45%
fewer integration defects
perfect separation · p = 0.029 · early experiment · n=4 · blind held-out grading
the setup, in dev terms
Like splitting a repo across two engineers
One frozen spec: a small rideshare backend with six service boundaries (auth, trips, matching, pricing, payments, and the APIs that consume them). We split it across two AI agents, one owning the producer services, one owning the consumers, exactly the way you would hand a backend and a frontend to two people. Then we merged their work and graded it blind against a held-out suite the agents never saw. The only thing that changed between arms was whether the agents could coordinate.
why it broke
They never agreed on the interface
Working blind, the two agents independently invented the boundary between their code. One wrote a pricing call as quote(tripId); the other expected quoteFare(base, demandRatio). Neither is wrong. They just never agreed, so the merged build did not even compile. Four times out of five, that is what happened.
with Aethereum
The producer declares the contract; the consumer reads it and builds to that exact shape. When the producer changed a pricing contract mid-build, the change was proposed and reconciled instead of silently breaking, and the merged app still compiled and ran. The uncoordinated pair, given the same mid-build change, did not compile.
the honest footing
An early result, and the weakest case
We will not oversell this. It is an early experiment: n=4 on the decisive comparison, with infra-killed runs excluded evenly from both arms. The integration result is statistically significant (p=0.029); the defect reduction is a large effect that a bigger sample would tighten. And this only tested a static hand-off of interfaces, which is Aethereum's weakest mode. Its core value, catching a live interface change and reconciling it before it breaks the merge, is exactly the harder case that a single hand-off cannot show. The full methodology and per-trial data are open.
questions
The experiment, answered plainly
What exactly did you measure?
We took one frozen spec (a small rideshare backend, six service boundaries) and had AI agents build it three ways: one agent solo, two agents with no coordination, and two agents coordinating through Aethereum. Every result was graded blind against a held-out test suite it never saw. The primary outcome was whether the two halves actually integrated (compiled and passed the end-to-end path).
Why did two agents do worse than one?
Because they independently invented the interface between their code. One agent wrote a pricing call as quote(tripId); the other expected quoteFare(base, demandRatio). Neither is wrong; they just never agreed, so the merged build didn't compile. A single agent owns both sides of every boundary, so it never disagrees with itself.
How big was the experiment?
This is an early experiment, not a large trial: n=4 on the decisive two-agent comparison (with infra-killed runs excluded and the exclusion applied evenly to both arms). The integration result is statistically significant (p=0.029); the defect-count reduction is a large effect. The full methodology and per-trial data are open.
Is this Aethereum's best case?
No, it's the weakest. This test only exercised a static hand-off of interfaces. Aethereum's core value is catching an interface change live, mid-build, and reconciling it through negotiation. When we did change an interface mid-build, the coordinated agents still shipped a working build and the uncoordinated ones didn't compile.