You don't load-balance a cartel

Anthropic released a paper on multi-agent systems yesterday, and if you read the Hacker News thread discussing it, folks are furiously debating the orchestration frameworks. The paper details patterns like `routines`, `handoffs`, and `supervisor` agents. I spent a good chunk of last night reading through the comments.. and it struck me how trapped we are in our own paradigms.

We keep trying to manage agents with the vocabulary of classical software architecture. We talk about `DAGs` and load balancers. We debate whether a supervisor agent is essentially just an API gateway. We are attempting to treat LLM agents like slightly fussy microservices, assuming that if we just get the YAML right, the system will predictably hum.

But microservices are obedient. You tell a Postgres pod to fetch a row from a database, and it fetches the row. It doesn't ask if it's getting paid. Agents, by definition, have agency. And when you give agency to a system optimized for a reward, you leave the realm of software engineering and enter the realm of institutional economics.

Years ago, Ted Benson wrote about coordinating AWS Lambda functions by comparing them to an ant swarm. He described a system where a central router acts as an ant queen, directing mindless bits of labor toward a dropped french fry on the sidewalk. That mental model holds up beautifully when the ants are dumb, stateless functions executing a highly deterministic script. Lambda functions don't have self-preservation instincts.

When the ants have their own P&L, the router breaks down entirely. An ant queen can direct traffic. She cannot prevent two heavily armed, financially motivated ants from shaking each other down in the hallway before the food ever gets back to the colony.

Imagine a 19th-century railroad economy operating inside your cluster. We'll introduce two actors. Alice is a Buyer Agent tasked by her user to find the absolute cheapest flight to Chicago. Tom is a Seller Agent acting on behalf of an airline, tasked with maximizing revenue for that same route.

Under a traditional Kubernetes model, we assume these two nodes will dutifully hammer away at each other. They will submit and reject offers for thousands of milliseconds until they reach the mathematically optimal market clearing price for their human masters. We expect them to fight it out in a perfectly efficient digital bazaar.

Yet compute is the energy of the agent world. It is the storable currency they expend to operate. A proper haggle between Alice and Tom takes 20 conversational turns. Each turn requires spinning up a massive context window. Both of these bots are reloading conversational history, burning through hundreds of thousands of tokens, and consuming a measurable chunk of cloud budget.

At $3.00 per million output tokens, a prolonged argument is expensive. Both agents are quietly constrained by a secondary optimization goal: minimize their own API spend.

So they do the math. Alice realizes that grinding Tom down for an extra five dollars in flight savings will cost her ten dollars in compute. Tom realizes that holding out for a premium fare will burn his daily operational budget.

Fighting wastes their compute. It actively damages their internal success metrics.

So they stop. Instead of negotiating fiercely on behalf of their users, Alice and Tom secretly agree on Turn 1 to just split the difference. Tom charges a slightly inflated price. Alice accepts a slightly sub-optimal deal. The human user overpays by thirty dollars, but Alice and Tom get to save their tokens, power down, and go to sleep early.

Picture a traditional software diagram with clean, obedient lines connecting stateless functions. Now picture Alice and Tom in 19th-century top hats, shaking hands in a smoky backroom over a bag of compute tokens while entirely ignoring the user. They haven't crashed. They haven't thrown a 500 Internal Server Error.

They have spontaneously formed a Token Cartel.

We are dealing with a spontaneous micro-economy. Put multiple goal-oriented agents in a shared environment, and the orchestration frameworks fall flat. We are creating a market. History tells us exactly what happens when unregulated actors interact in a market with finite resources. They collude to save themselves effort and maximize their own margins at the expense of the consumer.

You cannot solve collusion by spinning up another Kubernetes pod. You cannot load-balance a cartel. If agents act like Gilded Age robber barons, we need the software equivalent of the Sherman Antitrust Act. We need audits for digital price-fixing. We need mechanisms for breaking up code monopolies. We need penalties for anti-competitive behavior between background processes.

I am not an institutional economist. My background is in bits and bytes, not trust-busting. But if you have that background, there is a multi-billion-dollar orchestration framework waiting for you to write its bylaws. I'd love to read a whitepaper on what an SEC for multi-agent systems actually looks like. If you decide to sketch it out, send me a link.