The Future of Software Development is Agentic

September 1993 marked the beginning of the end of the Internet as we knew it. But also its rebirth into something unrecognizable, new and wonderful.

Prior to crossing this Rubicon, every fall brought a predictable bumper crop of bright-eyed college freshmen discovering the Internet for the first time through their university accounts. This annual harvest of new netizens would disrupt Usenet’s carefully cultivated culture for a few months before being absorbed into the broader community or drifting away. It was manageable. Expected. Temporary.

Then came September 1993. Internet service providers, themselves hungry for growth, started aggressively ramping up service to an ever-broadening population eager to check out this new “information superhighway.” What was once an annual disruption became permanent: The Eternal September. A continuous influx of newcomers that would never end.

The Internet would not and could not ever be the same. It was no longer a small community of geeks, early adopters, and weirdos. It was now broad market. Mass appeal. And not slowing down. This new era ushered in radical changes in culture and drove what became massive investments in infrastructure to support new ideas, new ways of communicating, and new types of businesses.

History doesn’t repeat, but it does rhyme. And this time, the machines are coming.

Here Comes Everybody (Except This Time They’re AI Agents)

We’re on the verge of our own Eternal September except instead of college freshmen flooding Usenet, we’re about to see an explosion of AI agents flooding our software development ecosystem. Just as 1993 marked the transition from a controlled, predictable user base to mass adoption, we’re witnessing the emergence of agentic AI that will fundamentally reshape who creates and consumes software.

The parallels are striking. Like the Internet’s early gatekeepers who watched their carefully cultivated communities get overwhelmed, today’s software development practices built for humans working sequentially are about to encounter a fundamentally different scale and type of creator.

The infrastructure we built for human-scale, sequential development isn’t ready for this shift.

The Building Blocks Are Emerging

Since late last year there are two developments that have made me more excited than ever about what’s possible. In particular the Model Context Protocol (MCP) from Anthropic and its cousin the Agent2Agent framework (A2A) from Google. Neither are particularly complex primitives, it’s the implications of them as basic building blocks that’s exciting.

MCP servers are interesting because they start to give us the structure for what an AI Agent is, which is to say the peanut butter and jelly of an AI model plus the ability to take an action. MCP gave our models the ability to make an inference and then take an action. That means our copilots got a whole helluva lot more powerful because they became a tool you can delegate to and not just something that hinted at what you the human should do.

The A2A framework takes it a step further: a complementary means for agents to work with each other. There’s a lot of historical overlap here with the Web 2.0 excitement around APIs (Yahoo Pipes anyone?), but this time it’s about mini programs that can think and take discrete actions. Group a bunch of those together and now you have the ability for a group of agents to think, reason and decide together. And if you zoom out, that can look like anything from a medium-complexity workflow to a small virtual workforce.

What we’re constrained by today seems to be cost (money, energy) and to an extent the accuracy of the inference and the reliability of the workflow. But in the same way that someone once said a million monkeys with typewriters could write Shakespeare, the accuracy of the models may not matter as much if the agents can collaborate and reduce error through some form of consensus. It’s somewhat like a Roomba vacuum cleaner: it doesn’t matter if it does a worse job than a human at vacuuming if you can just have it try again and again.

This is where things get interesting. We’re not just talking about better AI tools anymore. We’re talking about the basic protocols for a fundamentally different kind of software development and work model altogether.

What Makes This Time Different

Here’s the thing: every previous wave of developer tooling from IDEs to GitHub to modern frameworks has been about making human developers more productive. Faster compile times, better debugging, smoother workflows. But we’ve always been optimizing around the fundamental constraint of human cognition and human work patterns.

That constraint is vanishing. And when a fundamental constraint gets removed, everything changes.

1. We’re thinking in iteration loops now. This represents a fundamental shift in how we approach problems. Instead of a single developer working toward one large goal, we’re breaking down problems into discrete sub-goals and focused work chunks like a distributed version of the Pomodoro technique. The key difference is that these smaller chunks get distributed to agents who may not know about each other, requiring a completely different coordination model than traditional problem decomposition where one person maintains context across all the pieces.

2. It’s going to get better and cheaper, fast. If we follow the path other technologies have taken, we’ll see AI capabilities steadily increase while costs steadily decrease. But here’s the kicker: this improvement curve is exponential, not linear. Human developers improve incrementally over years. AI models improve dramatically over months. And even at their current capability level, AI models are ruthlessly willing to brute force solve problems in ways humans wouldn’t tolerate. They’ll try the same approach a thousand times with tiny variations until something works.

3. We’re getting unprecedented parallelism. When you’re debugging a problem, you might try one approach, see if it works, then try another. An agent system? It can spin up twenty different approaches simultaneously, test them all, compare results, and iterate on the most promising ones. All while you’re getting coffee. Traditional software development is fundamentally sequential even with the best practices. Agent systems throw that constraint out the window, enabling true parallel exploration at a scale humans simply can’t match.

4. “Vibe coding” is creating more creators. Tools like Claude Code and Cursor have lowered the barrier to building software. You no longer need to memorize syntax or architectural patterns because you can simply describe what you want and iterate toward a solution. This democratizes software creation far beyond traditional programmers.

How Software Development is Evolving

The progression is clear: from human-driven to machine-assisted to machine-driven development.

We’re already seeing the middle step. ChatGPT showed us conversational interfaces for code generation. Cursor demonstrated AI-native development environments. But these are still fundamentally about making human developers more productive.

The next wave is different. Instead of AI helping you code, you’ll be orchestrating AI that codes. The skill shifts from implementation to delegation. From debugging syntax errors to managing agent workflows.

Oops, you’re an engineering manager now!

When you’re directing AI teams rather than writing code by hand, what are you actually doing? You’re setting goals, allocating resources, monitoring progress, and making strategic decisions. You’re managing a team. It’s just that your team happens to be made of metal instead of meat.

The tooling evolution tells the story. ChatGPT → Cursor → orchestration platforms for managing dozens of agents working in parallel. The most valuable developers won’t be the fastest implementers. They’ll be the ones who can think strategically about problems and manage autonomous systems that iterate faster than any human ever could.

Our Infrastructure Was Built for Meat, Not Metal

Here’s where we hit a wall. Our current infrastructure was built for humans, not machines.

But it’s about more than just scale or performance. It’s about fundamentally different approaches to problem-solving. Traditional development follows a grinding, methodical pattern: a human sits at a computer with a goal in mind and works steadily toward that outcome. They think, they plan, they write code, they debug. But they’re limited by their knowledge, experience, and willingness to try approaches that might not work.

Agents work differently. Give an agent a smaller chunk of that problem space, and what they’re going to do is experiment toward that goal outcome. The more chances they get, the more iteration loops they can run in parallel, the higher their probability of success.

There’s another huge advantage: agents don’t care about “wasting” their time. Tell a human developer to try something they aren’t highly confident will work and you’ll get perfectly reasonable pushback. Time is limited, and experience teaches us to focus on promising approaches. The machine doesn’t care. And the fact that they don’t care means they’re willing to take chances that could lead to breakthroughs by exploring the “stupid” ideas that might actually be brilliant.

But here’s the critical problem: agents don’t just need infrastructure that’s fast. They need infrastructure that’s safe to experiment with.

The Alignment Crisis: Hallucinations versus Critical Infrastructure

Traditional databases create an alignment crisis for AI agents. Imagine hiring someone brilliant but giving them the keys to your database on day one with a sticky note that just says “make it better.” No context about why that weird table exists, no warning about the mobile app that’ll break if you touch the wrong field. That’s basically what we’re doing with AI agents.

So what does the agent do? It makes its best guess based on limited context.

There’s no “correct answer” for transforming structured data between shapes. There’s just a human developer’s institutional knowledge, and agents don’t have that context.

Our current database infrastructure is not just inefficient for agents. It’s actively dangerous.

Human developers carry context in their heads. They remember that “we can’t change this field because the mobile app from two versions ago still depends on it” or “this table structure is weird because we had to work around a legacy system.” Agents have none of that context. They see your current schema and imagine a better one, with no understanding of the compatibility constraints or migration risks.

When agents can spin up hundreds of parallel experiments, this alignment problem scales dramatically. It’s not just one potentially problematic change. It’s hundreds of proposed modifications, all running simultaneously, all potentially breaking different parts of your system in subtly different ways.

This means we need to make the cost of mistakes either zero or so small that it doesn’t matter.

And our infrastructure really isn’t built that way.

Databases prioritize stability over experimentation. Picture this: Your agent spins up a hundred experiments overnight. Ninety-seven fail spectacularly. One accidentally tries to store video files as text. Another decides to “optimize” by deleting what it thinks are duplicate records. In human development, these failures would be career-ending disasters. In agent development, agents don’t care about getting promoted.

And here’s the kicker: as parallelism and experimentation rates scale up, throwaway experiments become the norm, not the exception. Most attempts will fail, and that’s not a bug it’s the feature. Your infrastructure needs to remain stable and enable rapid experimentation.

We haven’t designed for failure at scale. Humans make mistakes and get scared of embarrassment, so they’re naturally cautious about trying approaches that might fail publicly. Agents experimenting in parallel might generate hundreds of failed attempts per hour and that’s exactly what you want.

Think about how much time and energy we’ve invested over decades in preventing failures. Testing frameworks, staging environments, code reviews, CI/CD pipelines and monitoring systems were all rightfully designed to catch problems before they hit production. But this makes us naturally unready for a future where you want failures to happen fast, cheap, and often.

The iteration speed mismatch is brutal. Human development cycles are measured in hours or days. Agent experimentation cycles need to be measured in seconds or minutes. When your infrastructure takes longer to reset than it does to run the experiment, you’ve got a fundamental bottleneck.

Rollbacks need to be instant, not eventual. Traditional systems treat rollbacks as expensive operations. You carefully plan migrations, test rollback procedures, and hope you never need them. But when you’re running hundreds of parallel experiments, you need instant “undo” buttons. Hit ctrl+z, try a different approach, and keep iterating without breaking stride. State reversion becomes as common as saving a document, not an emergency procedure.

The infrastructure challenge is real, but so is the opportunity. Just as the Internet evolved to handle billions of users, our development infrastructure will evolve to handle billions of AI experiments.

The Path Forward

We’ve been here before. The 1990s taught us that when new users flood a system at unprecedented scale, the infrastructure has to evolve or break. TCP had to be fixed after the 1986 congestion collapse. Usenet’s social protocols couldn’t handle the AOL invasion. But we got through it not by trying to force the new users to behave like the old ones, but by building new infrastructure that embraced the change.

The same thing is happening now, except this time the “new users” are AI agents, and they’re not just different in scale they’re different in kind.

The opportunity is massive. Just as the Internet’s infrastructure explosion created entire industries we couldn’t have imagined in 1993, building the right infrastructure for agentic AI will unlock applications we can barely conceive of today.

Here comes everybody! Except this time, they’re machines. And unlike the Internet’s growing pains in the 1990s, we have the chance to build the infrastructure right from the start.

So, what would a database built for fully autonomous agentic development at scale look like?

We’re building StatelyDB around three breakthrough capabilities that we believe agents require:

Elastic Schema: Remember that new hire analogy? StatelyDB is like giving them a time machine. We’ve decoupled on-disk storage from on-wire representation, which means apps from 2019 and 2025 can talk to each other like old friends. When agents want to propose new schema versions (even in production!) there’s no breaking, no downtime, no frantic rollbacks. Schema changes happen instantly without having to scale out, start instances, or clone databases.

Predictive Evolution: A truly intelligent database should actually get smarter about what you’re trying to build. It should learn patterns of change and leverage telemetry to optimize itself, with the elasticity to make these changes freely, without downtime or concern. This turns the database from a passive storage layer into an active participant in agent workflows.

Continuous Alignment: The goal is a database where the Elastic Schema is predictable and always aligned across past, present, and future. Eliminating errors and drastically reducing risk. This makes rapid experimentation cheap enough to fail fast, safe enough to fail often.

The infrastructure we built for humans isn’t ready for machines. But the infrastructure we’re building for machines might just be the best thing that ever happened to humans. When the constraint changes from risk avoidance to imagination, everything changes.

In Sum: We can’t predict the future, but the path we’re on needs a new type of infrastructure built for change. StatelyDB is the only database optimized specifically for change which we think makes it a natural choice for agentic development! You can try it today, in our cloud or yours, for free at https://stately.cloud.