The software development world has always been a game of shrinking units. From mainframes to containers, the idea of 'tenancy' has evolved like a Russian nesting doll—each layer smaller than the last. But now, something radical is happening: the very definition of who (or what) needs isolation is changing. And it's not just developers anymore. It's the work itself. Let me explain why this matters more than you think.
Imagine a world where a single developer can juggle five simultaneous coding tasks, each requiring its own isolated environment. Sounds absurd? Not when you're talking about AI coding agents. These tools aren't just assistants—they're parallel workers, each running their own code sessions. Suddenly, the old model of 'one developer, one environment' becomes a bottleneck. This isn't just about efficiency; it's about redefining what constitutes a 'tenant' in our platforms.
What makes this particularly fascinating is how deeply it challenges our assumptions about human productivity. For decades, we've built systems around the idea that a person produces one stream of work at a time. But AI agents break that model entirely. A developer might run 20 parallel agent sessions, each generating changes independently. The result? A deluge of concurrent workstreams that traditional infrastructure can't handle. It's like trying to pour water into a sieve—it just leaks out.
Here's the kicker: the real unit of isolation should be the change, not the person. Think about it. When you make a code change, you're not just altering a line of text—you're creating a temporary universe where that change exists. That universe needs its own data, its own dependencies, and its own version of the system. If you don't isolate it, you risk contaminating other workstreams. And in the age of AI agents, where changes multiply like rabbits, this becomes a critical problem.
I've seen this firsthand in organizations that cling to the old 'per-developer' model. They end up with environments that are either too cramped or too wasteful. A 50-person team running 10 agent sessions each might need 500 isolated environments on a busy day. But if you treat each change as a tenant, you're not just scaling—you're reengineering your entire platform. It's not about giving every developer a private sandbox; it's about giving every change a private sandbox.
The implications here are massive. Traditional capacity planning, which budgets based on headcount, becomes obsolete. You can't plan for 50 developers when each might generate 20 changes a day. The math simply doesn't add up. And yet, the solution is elegant: treat each change as a self-contained tenant. Create it on demand, isolate only what's necessary, and tear it down when the change is merged or abandoned. No more waiting for a ticket to be filed, no more orphaned environments clogging your system.
What many people don't realize is how this shift affects the entire development lifecycle. The old model forced developers to serialize their work—queue up a change, wait for it to deploy, then move on. With change-level tenancy, you can parallelize everything. Imagine a world where a single developer's pull requests don't block others. Where testing happens in parallel, not in sequence. This isn't just about speed; it's about unlocking creativity.
If you take a step back and think about it, this is a cultural shift as much as a technical one. We've spent decades building systems around people, not processes. But AI agents are forcing us to rethink that. The future of platform engineering isn't about giving developers more tools—it's about giving changes more space to breathe. And the organizations that get this first will outpace the rest.
So what's next? I suspect we'll see platforms that automatically create and destroy environments based on the number of active changes, not the number of developers. We'll see databases that branch off on demand, not at fixed intervals. And we'll see teams that measure capacity in changes per day, not seats. The change is the new tenant, and the future belongs to those who embrace it.
