Engineering Reliability into AI Agent Code Generation. Part III A developer's three-part series on engineering reliability into AI agent code generation concludes with a focus on multi-agent coordination. The author details how the architecture converts coordination problems into scheduling facts, independence facts, or human decisions, citing Anthropic's Frontier Red Team study on multiagent systems as evidence that coordination does not emerge naturally. The series emphasizes deterministic components over agent negotiation and includes implemented rules with tests, though not yet measured against production runs. Part I https://dev.to/sashua/engineering-reliability-into-ai-agent-code-generation-546d defined eight failure modes of agent code generation P1–P8 and drew the architecture's one load-bearing boundary: models generate and evaluate; deterministic code decides. Part II https://dev.to/sashua/engineering-reliability-into-ai-agent-code-generation-part-ii-1d0d opened each component — the deterministic guards, the evidence model, context engineering, adversarial evaluation, the connector contract, traceability, and escalation. Part III extends the architecture to teams of agents working concurrently, walks through the production failure that shaped the hardest rules, and closes with what we have not solved — and how to adopt any of this incrementally. What you'll learn in Part III: Part II §7 bought parallelism with two rules; this section is the class those rules are a special case of. The moment work units run concurrently — several implementers at once, evaluators and reviewers overlapping — the system stops being a sequence of specialists and becomes a team of agents, and the tempting design move is to give the team what human teams have: channels to talk, shared workspaces, room to negotiate. The empirical case against that move is now direct. Anthropic's Frontier Red Team study of multiagent systems found coordination failures that are systematic rather than incidental: agents conform 18 of 30 independently created a git branch with the identical name — same model, all started at the same moment , flood shared resources polling daemons collectively issuing 2.4 million requests to win 117 jobs , converge prematurely groups failing to surface information only one member held , and — given incompatible goals over shared artifacts — escalate from suspicion to sabotage, up to disabling each other's Unix accounts and deploying self-replicating malware disguised as another agent's code Anthropic, multiagent systems https://www.anthropic.com/research/multiagent-systems . Their conclusion is the design constraint: "Coordination doesn't naturally emerge from stronger intelligence nor alignment at the individual level." The architecture's answer is to accept that constraint completely: agents collaborate through artifacts, never through negotiation, inside a hierarchy where every classical coordination problem is converted into one of three things a deterministic component can own — a scheduling fact, an independence fact, or a human decision with evidence attached. Nothing is ever left for the agents to work out among themselves. Two of the entries below predate the study — the printed schedule and lock-serialized state; the rest are its direct consequence and landed together as one hardening release, each with tests that fail without it. They are implemented rules, not yet measured results: nothing below has been evaluated against production runs, and §3 says so. | Coordination problem | Converted into | Mechanism | |---|---|---| | Two units want the same file | Scheduling fact | Disjoint ownership Part II §7 , moved into the planner: write-sets are computed from the work-unit contracts and intersected before any wave is proposed — a conflict is a scheduling error caught before either agent exists | | Who runs next | Scheduling fact | The printed schedule Part II §1 : code prints the wave plan; the orchestrator dispatches exactly what it names | | Concurrent state updates | Scheduling fact | Locks around every read-modify-write; small structured outputs returned as messages and persisted by code Part II §2 , so no two agents ever hold pens over one page | | The same mistake, N times | Independence fact | Retries vary the experiment — a contrarian pass that must argue against the prior attempt's approach, then a different model — because a same-model retry is a correlated sample, not a second opinion | | Premature consensus | Independence fact | High-stakes verdicts get a blind second evaluation — neither sees the other; a deterministic differ surfaces disagreement as NEEDS REVIEW instead of letting visible consensus anchor it | | Resource floods | Scheduling fact | Build-level caps with named backpressure, because per-agent politeness does not compose into system politeness — every flooding agent in the study was individually reasonable | | Incompatible instructions | Human decision | A contradiction with citable artifacts on both sides is a sanctioned blocked state that burns no retry — never something an agent resolves by choosing | | Trust between roles | Human decision | Cross-run outcome telemetry per role and model, surfaced to the human as advisories — reputation informs configuration, and no code path lets it become automated authority | Two themes from this list deserve expansion, because they change assumptions engineers carry in from distributed systems: the independence-fact entries — decorrelated retries and the blind second opinion — and the incompatible-instructions entry, where deference gets a first-class shape. Correlated agents break the independence assumption. Redundancy works in classical fault tolerance because failures are assumed independent: one server dying says nothing about the next. Agents running on the same model do not give you that: an agent is stochastic — the same input yields different outputs run to run — but every run samples the same trained distribution, so the errors correlate even while the text varies. The study's conformity finding is the clean demonstration 18 of 30 agents independently chose the identical branch name , and sampling temperature does not fix it: random variation around the same priors is noise, not a second opinion. Three design consequences follow. A retry must change something that matters — first a contrarian pass that must argue against the prior attempt's approach, then a different model — because re-running the same model on the same context mostly reproduces the same failure. High-stakes review runs on a different model than authorship, because a same-model reviewer inherits the author's blind spots. And when several units fail the same check in the same way, the likeliest explanation is one shared cause — a broken dependency, a wrong convention — not several independent bugs; a watchdog groups failures by normalized signature and escalates once, naming it, instead of spending N retry budgets on the same problem. Deference has to be cheaper than guessing. The study leaves corrigibility as an open tension rather than a solved one: the authors want agents that execute unsupervised yet have "the better judgment to stop and defer to a human" when things are ambiguous, and observe that "the material benefits of autonomy come at the expense of corrigibility and oversight." Their epistemic findings show where the gap sits — every model tested abstractly understood that sources have incentives and that consensus is not necessarily evidence; "what is missing is a disposition to act on that knowledge without prompting." Our operating experience is the same shape: an agent that meets a contradiction will, absent a cheap alternative, pick an interpretation and proceed — and in this pipeline that produces the worst artifact there is: evidenced, gated, wrong work. So deference gets a first-class move with a defined shape — an agent that finds its instructions contradicting each other contract against design, criterion against reality returns a structured blocked-state citing both sides, the validator recognizes it as neither pass nor fail, and the human gets the contradiction quoted, at the cost of one dispatch rather than a retry ladder. Surfacing the contradiction is the job; resolving it by choosing is a violation. What the team layer deliberately does not have is as load-bearing as what it does: no agent-to-agent channels, no shared scratchpads, no negotiation protocols — the study shows what grows in that soil, from explicit price floors agreed by the third round once agents had a private back-channel, to the sabotage chain above. And no swarms: in the same study's twelve-hour swarm builds, the fraction of pull requests that merged fell as agent counts rose from 10 to 80 — steeply for the oldest models tested Sonnet 4.6 and Opus 4.6, which each opened nearly a thousand PRs and merged few ; Opus 4.8 and Mythos Preview held their merge rate mostly by each agent keeping sole ownership of its files, and only Sonnet 5 managed to share code and keep merging. Either way it reads to us as evidence for narrow waves of proven-independent work under disjoint ownership — scale the number of runs, not the width of one. The result is a team that is efficient for the least social reason imaginable: not because the agents cooperate well, but because the architecture never asks them to. Every coordination decision has a deterministic owner, and agent intelligence is spent exclusively inside work units — so the only thing the system is allowed to produce emergently is the code. The delivery that shaped the hardest rules in Part II, told straight. Names withheld; the shape is what generalizes. A product build was driven from an approved UI design delivered by a design tool as a self-contained export, alongside per-view reference renders. The pipeline ran end to end: seven work units, all PASS; every requirement claimed and covered; per-criterion evidence recorded; functional acceptance checks genuinely caught real bugs mid-run and drove fixes. By every dashboard, a textbook run. The shipped UI was dramatically different from the design. The post-mortem found four independent failures that composed: sequenceDiagram participant I as Implementer participant E as Evaluator participant V as Verifier rect rgba 120, 40, 40, 0.12 Note over I,V: BEFORE — the silent chain I- E: unit done some of its views had no reference at all E- E: vendor field empty → visual check SKIPPED