This is the honest version of two years of multi-agent work: what was built, what the measurements said, and why the current system is one agent with two models rather than the orchestration layer I once thought was the point.
Phase by phase
Native subagents. The first instinct was parallelism: spawn a worker per task, let them run. It worked — and produced no evidence. When two workers disagreed, there was no trace to settle it.
Measurable workers. The fix was telemetry: per-worker traces, recoverable handoffs, tokens attributed to the worker that spent them. This made the next conclusion possible, because now overhead was visible instead of assumed.
Codex + OpenCode. Splitting planner and executor into two tools with two models looked like an architecture win. Per-call traces showed the planning and review layers costing more than the work itself.
Lifecycle experiments. Beads, BVR, and NTM added state machines, ticket routing, and formal lifecycle bookkeeping. Every one of them added coordination cost that the traces showed was not being repaid in quality.
Simplified roles. The current system: one agent (Codex as operator), a role-aware routing rule to GLM-5.3-Flash as workhorse with frontier escalation, and A2A as an optional discovery capability. Everything else was deleted, deliberately.
What the middleman tax actually cost
(The cost mechanism behind this section is owned by Why agent systems become slow, expensive and fragile; this article owns the architectural decision that followed.)
The current stack, dated
What follows names specific tools. They are the evidence, not the recommendation: as of 29 August 2026, the rig runs Codex as operator, OpenCode as fast executor, GLM-5.3-Flash as workhorse with frontier escalation, and A2A on loopback. The durable conclusion — role-aware routing beats model loyalty — will outlive all of these names.
What survived
Three things: measurement as a first-class citizen (per-call traces so every architectural claim can be checked), role-aware routing instead of model loyalty (cheap workhorse by default, frontier only for genuinely hard work), and A2A as a companion capability — agents that can discover each other without custom plumbing. Everything else — the orchestration layers, the lifecycle bookkeeping, the inbox protocols — was removed after the telemetry showed it cost more than it returned.
Field notes this consolidates
The long-form evidence lives in earlier articles, which remain valuable as the paper trail: what 551 Codex sessions revealed, the OpenRouter-backed AI team, making subagents measurable, one agent, two models, the A2A mesh, and Sol/OpenCode split. This article is the through-line.
Why this matters outside the terminal
If you build anything with AI tools, the subtractive arc is the useful part: every layer you add to make agents coordinate has a cost that is measurable, and most of them do not repay it. That finding applies to agency automation stacks as directly as it applies to coding agents.
Where to go next
- Why agent systems become slow, expensive and fragile — the mechanism behind the middleman tax
- What should be an agent — and what should be normal code? — the decision rule this journey produced