Concurrency, partial failure, and retry amplification decide what happens at 100 concurrent runs. A prototype running 5 produces too little of each for the difference to appear during development.
Akka supplies concurrency, supervision, backpressure, and recorded tool execution as properties of the runtime. The behaviour that decides the outcome at 100 runs is already in place at 5.
Five agents running at once touch a shared dependency five times. The connection pool has capacity free and the model provider stays inside its rate limit. Every tool call is answered. Nothing queues, so no code that handles queueing runs.
One hundred concurrent runs contend. Connections run out, the provider returns a rate-limit response, and calls that answered in a second answer in twenty. The system now depends on behaviour never reached while it was being built.
A prototype that works at five runs is evidence about five runs. The code that handles contention, partial failure, and duplicate execution gets written after the first production incident. Rework caused by earlier architectural choices consumes 20 to 40% of engineering capacity.
Akka provides that behaviour before the load arrives. Each agent instance processes its own messages one at a time, so its state needs no locking. Backpressure holds a fast producer to the rate its slower consumer can sustain. The runtime records whether a tool call executed, so a retry skips a call that already ran.
Esdiac rebuilt a distributed communications and payments network on Akka after the previous architecture stalled at 5,000 customers. The rebuilt system carries tens of thousands of users at 65% lower infrastructure cost.
The shared dependency fails first. Each agent is doing the same work it did at five runs, and the connection pool, the rate limit, or the tool behind them is what runs out.
More instances raise the load reaching the shared dependency. Capacity helps when the agent process is the constraint, and it makes contention at the dependency worse.
A rate limit is pressure arriving from upstream. The runtime absorbs it by slowing the work that depends on that provider. Code that answers a rate limit with an immediate retry converts the limit into a retry storm.
The agent logic survives. The scaffolding built around it to compensate for a missing runtime gets replaced.
Akka scales elastically to 10 million agentic transactions per second with scale-to-zero. Swiggy holds 5,000 predictions a second on a single model.
