In the ever-evolving world of platform engineering, a fascinating shift is taking place. The concept of multi-tenancy, which has been a cornerstone of shared computing for decades, is undergoing a radical transformation. Traditionally, multi-tenancy has been about carving up resources to accommodate smaller and smaller units, from mainframes to virtual machines and containers. But with the advent of coding agents and parallel workstreams, the game has changed.
The assumption that a person produces one stream of work at a time is being challenged. Developers running multiple agent sessions are managing multiple changes simultaneously, each requiring its own unique environment. This has led to a new realization: the tenant is no longer the developer or even the agent; it's the change itself.
This shift has profound implications for capacity planning and resource management. With agents capable of generating a high volume of changes, the traditional model of planning by headcount is no longer sufficient. The demand for tenancy now scales with the number of changes in progress, not the number of developers.
The challenge lies in mispricing this new reality. A per-developer namespace, for instance, fails to account for the multiple workstreams an agent can manage. Shared staging environments serialize these workstreams, creating a bottleneck. Seat-based capacity plans underestimate the true demand, as they are based on headcount rather than the dynamic nature of changes in flight.
The solution lies in recognizing the change as the true tenant. Agents are interchangeable workers, and treating them as such leads to the same mistakes on a larger scale. It's the change that must be isolated, as it carries unique state and requirements. Each change needs its own environment, with access to the specific services and data it needs, while sharing the rest of the system.
This change-level tenancy has three critical requirements: near-free creation, isolation tailored to the change, and a lifecycle tied to the change itself. Platform teams that embrace these requirements are already running multi-tenant production services with success. The challenge is applying these principles to pre-production environments, where the rules are often reversed.
By treating each change as a tenant, platform teams can ensure efficient resource management. The change owns the services and data it modifies, while sharing the rest of the system. This approach, combined with automatic offboarding and accurate accounting, ensures that resources are utilized effectively and waste is minimized.
The practical shift for platform teams starts with measurement. Counting changes in flight at peak times, rather than seats, provides a more accurate picture of demand. Pricing the marginal tenant in terms of cost and setup time reveals where the old assumptions are still in play. By addressing these assumptions and applying the three requirements, platform teams can ensure they are prepared for the agent-native SDLC.
In conclusion, the shift from person-level tenancy to change-level tenancy is a necessary evolution in the face of coding agents and parallel workstreams. It requires a rethinking of traditional capacity planning and resource management strategies. By embracing change-level tenancy, organizations can ensure their platforms are optimized for the dynamic nature of agent-generated work, converting agent throughput into merged, valuable work.
