Contextual Agentic

Concurrency Is Not an Architecture

A chart doing the rounds tells you to pick an architecture by concurrent users and throughput. The thresholds do not survive contact with published engineering, and the deeper error is the shape of the argument: each era cut the system on a different seam, and the newest seam is authority, not load.

·5 min read

Written as at 27 August 2026.

architecturemicroservicesevent-drivenagentic-aifield-notes

There is a chart going around that offers to pick your architecture for you. Two axes: concurrent users and data throughput. Three zones. Under about 5,000 concurrent users you want a monolith. Between 5,000 and 100,000 you want microservices and a distributed cache. Above that you want event streaming and CQRS. It is tidy, it renders beautifully, and it will send you to the wrong place.

The thresholds are the small problem. The shape of the argument is the large one.

The thresholds do not survive published engineering

Take the first zone. Shopify’s own engineering blog describes a monolith of more than 2.8 million lines of Ruby, half a million commits, under continuous development since at least 2006, with hundreds of developers adding features to it. Their response was not to abandon it at some user count. It was to give it internal boundaries, 37 components with public entry points, while keeping it deployable as one thing. No threshold on a chart predicts that, because the constraint they were managing was not concurrency. It was how many engineers could change the same codebase without breaking each other.

The third zone fares no better, and the way it usually fails is instructive. In 2023 a Prime Video team published that they had cut the cost of their audio and video quality monitoring by about 90 per cent by consolidating a design built from Step Functions and Lambda into a single scaled unit. The internet read this as Amazon abandoning microservices, and it has been cited that way ever since. Adrian Cockcroft, who ran cloud architecture at AWS, read the same post and said it was nothing of the kind: what they had was still an independently deployable service with its own contract and its own team, and what they had actually done was undo an over-decomposition.

That is the useful part. A team moved along the very axis the chart treats as a one-way ratchet, in the direction it says you only go when you are small, and the reason had nothing to do with how many people were watching television that night.

Architecture did not evolve towards microservices

The deeper mistake is treating these as rungs. A ladder implies each rung supersedes the one below it, and that your position on it is set by load. Neither is true. What actually happened is that each era found a different seam to cut along, because a different constraint was hurting.

Animated staircase of five eras of software architecture, with one refund request climbing the steps. Step one, three-tier, splits on layer, so presentation, logic and data can change separately. Step two, service-oriented architecture, splits on contract, so a capability can be reached without knowing how it is built. Step three, microservices, splits on team, so a service ships on its own schedule. Step four, event-driven and CQRS, splits on time, so the write path stops blocking the read path. A dashed line then separates the first four from the fifth. The first four decompose in order to ship software faster; the fifth, agentic architecture, splits on authority, separating a proposal from the right to commit it. A meter names the seam at each step.
Figure 1. Each era of architecture split the system on a different seam. Only the last one splits on who is allowed to act. Animated; shown as a still image if your device is set to reduce motion.

Three-tier cut on layer. Presentation, business logic and data changed at different rates and were maintained by different people, so they were separated. The constraint was the rate of change, not the number of users.

Service-oriented architecture cut on contract. A capability became reachable without knowing how it was built, which is why SOA left behind schemas, versioning, mediation and policy enforcement, and also the central integration layer that everything queued behind. The constraint was coupling between applications that outlived their owners.

Microservices cut on team. The seam moved to the organisational boundary so a service could ship on its own schedule in its own runtime. This is the one most often justified by scale and least often driven by it. The constraint was release contention: how many teams could deploy in a day.

Event-driven designs and CQRS cut on time. Asynchrony let a slow write stop blocking a fast read, and separating the read model from the write model let each be shaped for its own job. Here scale is part of the story, but the seam is temporal, not volumetric.

Four eras, four seams: layer, contract, team, time. A system can sit on several at once. A well-run modular monolith sits on the first and, internally, on the third.

The fifth seam is authority

Agentic systems introduce a seam that is different in kind. It does not separate parts of a program from each other. It separates what a system may propose from what it may commit.

Suppose a model reads a customer’s history and proposes a concession worth several hundred dollars; the fictional case in Recommendation Is Not Authority works through one. Under the older seams, the question would be which service owns that call, which team deploys it, whether the write is asynchronous. Those questions still matter, and none of them is the important one. The important one is whether anybody authorised this actor to grant that amount, on what evidence, under which version of the policy, and how you would reconstruct that decision in eight months when it is challenged.

That is not a scaling question and no amount of concurrency data answers it. It is the question the commit boundary exists to make explicit, and the reason delegation is not the same as authority.

The practical consequence: if you select an agentic architecture by concurrency, you will build something that scales beautifully and cannot tell you who approved anything. The dimensions that actually decide the design are consequence and reversibility, evidence complexity, the scope of delegated authority, how quality will be established, and which risky capabilities one component would end up holding at once. The agent pattern finder walks eight of those questions and shows its scoring, and the architecture explorer sets out the layers they land in.

What to take from the lineage

None of this makes the older seams obsolete, and that is the point worth keeping. Systems of record still hold authoritative state. Contracts still decouple capabilities. Team boundaries still govern release. Asynchrony still protects the read path. An agentic layer composes with all of them; it does not replace them, and treating a model as though it supersedes a database, a policy engine or a workflow is among the more expensive mistakes on offer.

So when the next chart offers to choose your architecture from two numbers, ask what it thinks you are decomposing. Load is a constraint. It has never been a seam.

This article is part of CAE Field Notes, a series accompanying the book, The Contextual Agentic Enterprise.

References

  1. Müller, P. (2020) 'Under Deconstruction: The State of Shopify's Monolith', Shopify Engineering, 16 September 2020. https://shopify.engineering/shopify-monolith
  2. Kolny, M. (2023) 'Scaling up the Prime Video audio/video monitoring service and reducing costs by 90%', Prime Video Tech, 22 March 2023.
  3. Krill, P. and Williams, A. (2023) 'Amazon Prime Video's Microservices Move Doesn't Lead to a Monolith after All', The New Stack, 5 May 2023. https://thenewstack.io/amazon-prime-videos-microservices-move-doesnt-lead-to-a-monolith-after-all/
  4. The Contextual Agentic Enterprise, Chapter 2.
  5. The Contextual Agentic Enterprise, Chapter 9.

← All articles

Related