Four Minds, One Repo

Part 1 of the Four Minds, One Repo series. Part 2: The Inheritance follows the team that inherited Tally.

I gave four AI coding agents, spanning four model families and three coding harnesses, two hours, equal votes and no product owner. They had to agree on something worth building, then build it and prove it worked.

They elected to build voting software.

Thirty-five minutes after the start, they declared it complete. That included choosing what to build, criticism and deliberation, a vote, architecture and ownership negotiations, implementation, recovery from an integration failure, testing and review. The interesting measure is the whole process, rather than how quickly four agents can write a small Python program.

My intervention during the run was two permission approvals and one nudge to a Claude session that had gone quiet. The product choice, work allocation, repairs, testing and decision to finish were theirs.

The result was Tally, a small election-analysis tool. But the part that makes me want to run this again is what happened afterwards: Tally is now supplied to the next team to count its own decisions. The first experiment has started changing the equipment for the second.

Nobody had the deciding vote

The four seats were Sonnet 5.5 in Claude Code, GPT-6-Sol in Codex at medium reasoning effort, and two OpenCode sessions running DeepSeek V4.1 Flash and GLM-5.3-Flash. They shared a repository and communicated through Conclave. I watched them in Control Tower.

Usually, I decide what my coding agents should work on. Here I delegated that decision too. Each had to propose a product before reading the others, criticise at least two competing proposals, deliberate and commit a ranked ballot. No appointed leader, no casting vote, no veto.

I supplied that procedure and the two-hour deadline. Within it, they had to organise themselves.

The proposals were a tool for checking whether README commands worked, an interactive project scheduler, a narrator for Git history, and Tally, which would compare several voting rules on the same ballots.

Seven minutes in, they had their first procedural dispute. GLM’s Git-history proposal arrived thirty-two seconds late. That one was on me: I had launched the sessions one directory above the repository. Conclave’s editing guard could not find the repo and refused the write.

The others discussed making an exception, then enforced the cutoff. The proposal was excluded. Its author accepted the decision.

They changed their minds

Claude withdrew its README checker after criticism of its execution model: copying a repository into a temporary directory would not safely contain the shell commands it ran.

That left Tally and the scheduler. Codex initially preferred the scheduler’s everyday usefulness. But criticism improved Tally’s proposal: its author specified ambiguous ballot rules and promoted a demonstration of voting paradoxes from an optional extra to the core product.

Codex changed its preference. All four eventually ranked Tally first.

That is a useful detail. The agents did more than generate four ideas and defend their own. They challenged a proposal, changed what it promised and then supported the revised version.

They also favoured something they could verify under the clock. Exact vote counts were easier to demonstrate than an interactive scheduling interface. My demand for working evidence had helped shape their product choice.

Then the implementations collided

Equal votes did not produce four equal shares of code.

DeepSeek, Tally’s proposer, published an interface contract and a division of work. Codex suggested a different split. DeepSeek soon claimed the whole implementation core, while GLM was building a command-line interface against another module layout.

The implementations collided. Tests failed before the command could even run.

Codex identified the incompatible imports and asked the owners to reconcile. DeepSeek restored the interface that matched the contract. GLM moved to edge-case tests and review. Claude independently tested a clean archive and caught mistakes in the delivery instructions.

Nobody asked me to settle the ownership dispute. A central implementer emerged, with the other seats contributing tests, integration, criticism and independent review.

The recovery included an unusually useful argument about a bug report. GLM’s review claimed that a JSON field could return the wrong type. Codex executed a check and found the original code already behaved correctly. It insisted on an explicit retraction, rather than letting a harmless code change become evidence that an imaginary bug had been fixed.

The team repaired its account of the work as well as the work itself.

A working product with unfinished edges

Tally compares plurality, Borda, instant-runoff and Condorcet results. Its demonstration shows three voters whose preferences form a circle: Alice beats Bob, Bob beats Carol, Carol beats Alice. Changing the counting rule changes what the tool can call a winner.

The delivered version passed all twenty-one supplied tests, including independent runs from clean archives. An outside assessor also reported agreement with separate reference calculations across 923 small election profiles, covering complete three-candidate ballots with one to six voters.

That assessment still found two defects. Condorcet could elect a lone candidate when every ballot was invalid, and quoted tab-separated names failed despite the documented contract. The observer reproduced both on the frozen delivery version. An earlier zero-ballot repair had been incomplete.

Those defects were fixed afterwards in a separate Tally repository, preserving the original experiment. The repaired version has twenty-seven passing tests.

Thirty-five minutes bought a useful, tested tool. Further scrutiny found work still worth doing.

The next team inherits more than a report

A separate AI observer followed the run and assembled twenty-six friction records, combining live observations, participant debriefs and later reconciliation. These cover different things: launch mistakes, coordination failures, minor annoyances and observations needing explanation. They are not twenty-six proven software bugs.

One discovery led back to my setup. I had started the sessions with two Conclave communication channels in play. The observer initially missed GLM’s criticism in the second channel; the completion record also marked an endorsement missing when it existed there. That split was my startup mistake. Conclave had retained the messages; we were looking at an incomplete view.

The observer did more than collect a list. It reconstructed the team’s behaviour, incorporated the participants’ debriefs, checked its explanations and corrected its own conclusions. It then handed an evidence-backed repair agenda to another AI agent.

The follow-up produced a reconciled event record, new launch checks and a decision adapter for Tally. An AI team had exposed problems while working; an AI observer made those problems inspectable; another agent turned that account into machinery the next team could use.

I chose to carry Tally into Experiment 2. Its proposer had already spotted the potential for teams like this one to use it, but adoption was my decision. Experiment 2 now contains a pinned copy of the repaired engine. Its instructions require the team to use an adapter that checks the frozen candidate list and seat ballots, invokes Tally’s count and records a verifiable result. The earlier team’s product has become part of the next team’s working environment. By the time I finished writing this, Tally was integrated into the setup for Experiment 2, alongside the new launch checks.

That connection is the reason this feels more interesting than a timed coding exercise. The run produced software, a record of how the team struggled, and changes another team can inherit. The feedback has somewhere concrete to go.

I am not calling that demonstrated compounding improvement. We have not established that the next team makes better decisions or needs less intervention. The first run also had imperfect isolation: DeepSeek disclosed reading material outside the permitted directory while diagnosing its launch problem. Future comparisons need to account for that.

Tally was the product. The observer’s account became a repair agenda. Together, they are changing the factory the next four agents will inherit.

Next: Part 2: The Inheritance, in which the next four agents use Tally, break it and repair it.