2025: The Rise of Agent-Drive Software

This was post I sent to the Windmill team to close out 2024

Since its launch in November 2022, ChatGPT has become one of the fastest-growing consumer products in history, sparking widespread adoption of chatbot technology. The impact on consumer behavior has been remarkable – millions of people now regularly turn to AI assistants for everything from writing help to coding guidance to creative brainstorming. 

This explosive growth led many industry experts to predict a similar revolution in business software, with traditional interfaces being replaced by conversational AI. Yet despite this enormous popularity, the promised disruption of the SaaS industry hasn't quite materialized. While many major SaaS applications have integrated chat interfaces, these implementations often feel superficial and haven't delivered the revolutionary changes many anticipated.

However, simple chatbots represent just one way to use Large Language Models (LLMs). By orchestrating calls in various ways, we can unlock entirely different capabilities. This is where the concept of Agents comes into play.  While the term has become so overused it’s become pretty meaningless from a technical standpoint, it remains a crucial concept for understanding the future of software.

As I envision the next generation of SaaS applications, I see fundamental changes coming in how software will be built and operated. Although the term Agents may not be perfect, it has become the de facto way to describe what I believe will be the essential building block of future SaaS applications. 

This essay isn't focused on the technical implementation of agents - there are plenty of other great resources for that. Instead, we'll explore how this new paradigm fundamentally changes how software works and how users interact with it.

Understanding Agents

Before we explore what this new software landscape might look like, let's describe what agents are. Here's how I define them:

There are two parts of this definition.

1. First autonomous means that the system is in control. With chatbots the “user” is asking the bot questions and is leading the conversation. With agents this is flipped on its head where the agent is running the show. This doesn’t mean users can’t guide, supervise and influence the agent but the agent decides when and how the user can interact with it. If chatbots are advanced lane assist in a car, agents are self-driving.
2. Second agents live within a specific environment. Agents have access to systems with data and information and can perform actions across those other systems. These could be databases, SaaS apps, computers, keychains and more. All LLMs have the concept of a context window but agents take this a step further. They can operate on their environment in a similar way that humans can.

Chatbots vs. Agents

Chatbots are pretty fast right now and you are expected to watch as they work. With agents the default user experience will be - go do something else and we’ll tell you when we’re done. 

Let’s look at the difference between Perplexity and Google Deep Research as they are doing research.

Perplexity shows a loading skeleton before showing the results. They prioritize speed and you see this screen for less than a second. 

Google Deep Research on the other hand doesn’t prioritize speed. It focuses on quality and shows the following screen

It specifically says “as soon as your report is ready, I’ll let you know. In the meantime, feel free to leave this chat”. This takes several minutes and they don’t expect users to watch as it works. 

Asynchronous vs. Synchronous

These two models mirror how we interact with people in real life. Think about a phone call - you're having a back-and-forth conversation in real time. That's exactly what chatbot interactions feel like. You ask something, they respond, you follow up, and so on.

But there's another way to work with people. You might ask a colleague to research something or fix a complex problem. You don't hover over their shoulder watching them work - you go do your own thing and expect them to let you know when they are done. Whether it takes 1 minute or 10 doesn't really matter.

This shift from watching to waiting might seem small, but it's actually profound. When you're not waiting for an immediate response, agents can do the deep work - research thoroughly, refine their approach, debug problems, iterate on solutions, and take meaningful actions. And you can go do something else.

Neither approach is inherently better - they just serve different purposes. I use Perplexity when I want quick answers - ask a question, get a response, move on. But with Google Deep Research, I'm looking for deep understanding. I'll kick off several research reports and check back later in the day when they're ready for me to dive in.

Cursor is another great example of this evolution. It’s an AI IDE for software developers. When it launched it had an amazing chat feature for discussing code. But then they launched Composer, which took an agent-driven approach. Instead of just chatting about code, Composer actually does the work for you.

The difference is clear in how you use it. With the chat feature, I'd ask "Can you find bugs in this code?" But with Composer, I’d simply say "Fix these bugs." It takes over - finding issues, planning solutions, writing code, and handling edge cases. While it works for a minute or two, I'll grab coffee or work on something else. It's a completely different way of working with your tools.

Agent-Driven Software

This agent approach isn't entirely new - I first saw it in action with Natbot a couple years ago. But back then, the base models weren't reliable enough to build real products around. Now, LLMs are faster, cheaper, and specifically fine-tuned for agent capabilities. 

Going into 2025 my expectation is that agents will be the key ingredient in a new approach to building software. Thus far most companies have focused on how they can layer AI on top of their existing SaaS applications. This leads to some marginal gains but isn’t the future.

Instead of layering chatbots on top of existing software, to fully realize the potential software needs to be rebuilt from the ground up with agents at the core. In this world, agents are the primary drivers of software, not users. The UI for users should be built around these agents to influence and guide them. This shift from user-driven to agent-driven software reshapes how software works.

Let's take CRM software as an example. The way many CRM companies have tried to add AI to their product is to layer on chatbots on top of their existing interface. So inside of a CRM, this could look like being able to text some number saying "Hey, can you update the opportunity for Dunder Mifflin? It's going to close in two weeks for about $20,000 of ARR” This is a nice improvement because it can understand natural language, and I don't have to log into clunky CRM software, but fundamentally it doesn’t change how CRM works. 

The Agent-Driven approach to building CRM would look nothing like this. You wouldn't use a chatbot to fill out forms; instead, you would rethink. Why are we even filling out these forms in the first place? Most likely, you'd end up in a solution where agents read email conversations and watch meeting recordings and then just know when the Dunder Mifflin deal is likely to close and for how much money. No one needs to fill out anything and the system can be much smarter then just relying on a single person to decide these numbers and dates.

This is the type of rethinking that will happen for every vertical and for every use case. The underlying technology is finally good enough and expect this to reshape how people use software. There are three key characteristics that I expect to see as common patterns in agent first software.

Input Optional

Agent-driven software will work for you. Most SaaS software today can be described as “you get what you put into it”. With agent-driven software you shouldn’t have to do anything to get value out of the product. 

Andrej Karpathy coined the phrase “Input optional product” and it will become a standard paradigm. 

Users should have the ability to edit, steer and guide but they shouldn’t have to do anything. For example in the CRM examples users should be able to manually set an ARR if they have knowledge the agents don’t but this should be optional. In Windmill we have this exact pattern with weekly accomplishments - users don’t have to respond. 

I vividly remember at Yext how much time and effort was spent telling (and yelling) at sellers to fill out the fields in Salesforce correctly since execs wanted accurate numbers. With agent-driven software this should no longer be necessary.

Anticipatory

Since input is optional, it will become incredibly important for SaaS apps to reach out to you users with the right message, with the right UI at the right time. Generative UIs will certainly play a role in this but it’s more than just what it looks like. With our CRM example when do you want the CRM of the future reaching out to sellers. If input is optional and they don’t have to do anything when is the right time to reach out and what tasks do you want to engage them with. Instead of a single platform with a standard UI, agent-driven software will engage with users with micro interactions. 

For example right before a meeting with a customer you might get a briefing about what you need to know. Or maybe there is some ambiguity about something on a call and the agent wants your feedback on what you think. There is still a lot to be figured out here but agent-driven software will work behind the scenes and anticipate the right time to engage. 

At Windmill, we are taking this anticipatory approach to continuous feedback. Instead of a once a year cycle for feedback or waiting on employees to ask for feedback, Windmill tries to anticipate the exact right time to reach out with the right message over Slack. When the timing is right the response from users is night and day better. 

Deep Integrations

In order for agent-driven software to live up to this promise it needs to be deeply integrated into the environment. For the CRM example if the agents don’t have access to the emails and call recordings then it would be impossible for it to get any sense of what’s going on. This is of course where we have spent much of the last year investing at Windmill. We have a strong foundational data platform we can now leverage with increasingly intelligent agents. 

SaaS apps of the last decade have consolidated around a standard structure of navbars and forms. Next generation apps will look very different. It remains to be seen what the standard of agent-driven software will be and we are still in the early innings but the patterns will be defined over the next few years. 

Opportunity for Windmill

Now how does this relate to what we are doing at Windmill? While tech twitter loves talking about agents, most users will never have heard of the term and shouldn't need to care. What they should care about is software becoming 10x easier to use and 10x more useful - that's what really matters.

Generational software companies require a few critical ingredients to be created. An incredible team is of course a requirement, but I'd argue the most important ingredient is timing. The greatest software companies were created when new technical capabilities unlocked new paradigms. Personal computers, the internet, and mobile each launched waves of generational companies. AI and especially agents will fuel the next wave of transformative companies.

Now is the perfect time to rethink how software works and what the right user experience looks like for the next decade. And we're in the perfect spot to take advantage of this shift.

It won't be easy - we definitely aren't the only ones who see this opportunity. But I'm increasingly confident we have the timing right, which is the one thing we can't control. Everything else is in our hands. We'll need to move extremely quickly and execute to seize this opportunity, but we are in the right place at the right time. Let's do it.