A process designed for agentic development from the start — economics that survive the end of subsidized tokens, human guardrails, mechanical governance, and evidence for everything.
Every frontier token you buy today is sold at a market-share price, not a cost price. Inference is priced below its fully-loaded cost — the models, the training runs, the data centres behind them are financed by venture capital and hyperscaler balance sheets betting that subsidized usage now buys lock-in later. You do not have to predict a bubble bursting to see the problem: prices that sit below cost eventually correct. The only open questions are when, and how fast.
Agentic development makes this an acute exposure rather than a background risk, because agents are the most token-hungry way software has ever been written. A single agentic task can burn hundreds of times the tokens of a chat exchange — and the industry's answer to every quality problem is to spend more: longer trajectories, more tool calls, more retries, more orchestrating agents, all running on frontier models in someone else's cloud. Token consumption per unit of delivered software is rising steeply, while the price per token is held artificially low. Two curves like that cannot both continue.
When the correction comes, it will not arrive as a polite annual increase. It arrives the way subsidy withdrawals always do: sudden repricing, aggressive rate limits, cheaper models deprecated in favour of expensive ones, "unlimited" plans quietly metered. Organizations that wired agentic development into their delivery pipeline on frontier economics will find the cost of building software has become a number someone else controls — after their processes, their tooling and their teams have grown around it. That is not a tooling inconvenience; it is an architectural dependency, and it is being taken on today, mostly unexamined.
Token cost is an architectural constraint, not a procurement problem. Design for post-subsidy prices before they arrive.
SwarmCoder is built as the pre-emptive answer. The architecture splits work by what it costs to verify, and prices each side accordingly. Judgment — the analyst, architect, reviewer, test author, judge — is a handful of small, structured frontier calls per story, enforced by a hard per-run cap; that cost scales with the number of tasks. Volume — the worker swarms that actually read your repository and write the code — runs on hardware you own; that cost scales with implementation tokens, and those are priced in electricity. Over 95% of the tokens in a run never touch a cloud meter.
The exposure runs down as well as up. Model selection is per-role configuration, so as local models improve, roles migrate off the frontier — the judge is already the obvious next candidate, since it only ever ranks a handful of candidates that have compiled and passed. The direction of travel is the opposite of the industry's: less frontier dependence with every release, not more.
The result is an asymmetric bet. If frontier pricing stays cheap, SwarmCoder costs a little less than the alternatives and you keep the traceability. If pricing turns real — a 10× correction — the capped judgment slice rises with it, the local 95% does not move, and the platforms built on ever-more-frontier become cost-prohibitive overnight. You give up nothing to be positioned for the second case.
Requirements documents and backlogs were both designed for teams of humans, and each is good at what it was built for: the document describes the system, the backlog sequences the work. Agentic development changes the shape of the problem. When machines generate the code, the scarce resource is no longer typing — it is human judgment, and a durable, trustworthy statement of what the system must do that a machine can be held against.
So SwarmCoder keeps one durable requirement layer and makes it non-rotting by binding every acceptance check to an executable test. The specification cannot drift from the system, because the build fails when it does. A requirement flips to implemented on evidence — the commit and the wording revision it passed against — not on anyone's say-so. Edit the wording and the evidence is automatically marked stale.
The requirement graph is the only source of truth. A story is a scheduled slice of it, not a second description of it.
A story carries no requirement content of its own. It claims check identifiers, not paraphrases, so there is no second wording to diverge. Requirements own meaning; stories own scheduling and state. In three years the requirements are still there and the stories are long gone.
The result is a living pool feeding frozen slices. Intake never closes, so the plan can always learn something new. But once a story claims its checks and starts, that slice is protected — the swarm builds against a fixed target. Editing a claimed requirement is allowed, and it is a deliberate act that shows you the consequences first: "2 passing checks go stale; S2 will be sent back." In-flight work is never churned silently, and the loop back is drawn honestly on the board instead of happening off-screen.
Every step of every agent session is recorded as data, not log lines — prompts, responses, tool calls, kills with reasons, token usage. The causal chain from prompt to commit stays intact and queryable, so months later you can answer:
A build that stops because the work is genuinely hard and a build that stops because a server blinked are not the same event — treating them the same is how agent systems waste money and your attention at once.
Twenty autonomous processes editing code and running builds is a security posture, whether you designed one or not. Repository contents are untrusted model input: a README, a test fixture or a dependency's install script can redirect a small model.
Policy is resolved from a tree the restrained party cannot write.
Agentic software development with full traceability — built on ZeroZ4j by Franz Schöning, Principal Enterprise Architect.