BYOA
How Bring Your Own Agent will change the business of software.
I’ve been on a real agent kick here over the last couple of months. But then again, so has the entire world.
That ends today.
Yeah, no. I’m going to keep writing about agents.
Today I want to focus on an important shift I believe is happening in the relationship between agents and software1. Ever since agents entered the discourse, the prevailing narrative has had two parts:
Agents can build software on demand, permanently shifting the build-vs-buy equilibrium towards build. Buying software will be a thing of the past, making software a bad investment.
Software vendors that hope to survive must become “AI native” by embedding agents within their platform.
What if I told you2 there was a third way—one that means great things for both agents and software?
Bring Your Own Agent
Every Friday, I send a weekly update to investors and friends of the company. And each update includes a little blurb I call This Week I Learned (TWIL).
Last Friday this was my TWIL:
When I said “a little early”, I meant about 36 hours early.
On Sunday, Dharmesh Shah, CTO of HubSpot, wrote on LinkedIn that B2B software companies should be creating an “agentic version” of their software—one built around a thoughtful agent user experience (his term: “AUX”).
While I’d like to say “great minds think alike” that seem like too much credit. Let’s just say that between Dharmesh and me, one of us is slightly more influential and accomplished than the other. But hey, together we’re worth just over $1.1B!
Anyway, he ended with this:
Being agentic is not just about agents running *on* our platform, it's about agents *running* our platform (being able to operate it).
And herein lies the 3rd way.
Think about it. Do you really want to pick and choose specialized agents from a bunch of different “AI native” vendors? Do you want to be responsible for coordinating and enabling them across different systems? No, that sounds like a full-time job. Instead, you’ll bring your own agents (BYOA). And they’ll use software for you.
These agents will be customized for your company’s internal processes and context, but they’ll be built on a set of general purpose agentic platforms. These will come from a few providers. Today Anthropic is in the lead with Claude Code and Cowork while OpenAI is playing catch up with Codex. I’m confident Google and Microsoft will spend whatever it takes to be in the mix.3 Maybe OpenClaw is the open source alternative. Hell, maybe Apple will end up owning agents for consumers if they finally get Siri right.4
Right now that landscape is chaotic. There are emerging standards—MCPs and skills—with varying levels of support as vendors jostle for both growth and lock-in. If you’re old enough to remember it, it feels a lot like the browser wars. (More on that in a moment.)
While it’s obvious that BYOA turns the “build embedded agents” narrative inside out, it also changes the “agents make software obsolete” narrative.
Agents will build a lot of software. Creating a v1 has never been easier. That said, the fundamental software R&D story hasn’t changed. Maintaining, debugging, improving, scaling, operating—99% of expenses incurred during the working life of real5 software—still exist. Even if all those things can be reduced to nothing but token costs6, software vendors can still amortize those costs across more customers while getting operating efficiencies from scale. It’ll still usually be better to buy than build.
It follows, then, that in a BYOA world agents will consume more software than they build. If we consider that agents can work 24/7, it stands to reason that they’ll probably consume more software than humans ever could. To me, that sounds like a bull case for both agents and software.
This only works if software companies wake up to Dharmesh’s point (and mine). If you want a shot at the bull case, you’ve got to give up on the idea of owning an agentic workflow inside your software and start thinking about how you make your software available to agents and humans alike.
That means rethinking how we build, deliver and sell software.
The 5th wave of software platforms
I don’t think agents represent the end of software. Instead, I think they’re the next great software platform.
Every generation or so we get a fundamentally new platform for delivering software. Each wave creates new markets, rewards new approaches and (creatively) destroys models that used to work. Consider this progression (dates very approximate):
Early Days (1950 - 1970) - The era of mainframes (like the IBM 704 above). Software really only ran on specific hardware. To be a software developer was to be a hardware developer. The only thing that really mattered was making this incredibly expensive hardware do something useful.
Operating Systems (1970 - 1990s) - This is the era that birthed the PC and the operating systems we still know (if not love): Windows and Mac7. Building software no longer required building hardware; it meant targeting one of these OSes. Success meant owning distribution (mostly with physical media), making your software work on limited hardware and making it usable by normal people who suddenly found themselves with computers in their house. This wave never really ended. It’s just been largely fixed in place for 25+ years.
Browsers (2000 - Now) - Around the turn of the century, a bunch of technologies came together to make browsers a way to deliver software. This is when I started my career. It was a mess. The technology was incredibly limited, browsers were incompatible, the developer tools sucked. However, it was worth it. Suddenly you could deliver software to anyone on the internet, 24/7, always running the latest version, without them having to think about how to install it. Software became a service. And thus SaaS was born.
Mobile (2008 - Now) - In many ways this was a reprise of the first OS era, this time powered by new kinds of computers and the internet. You still have to build and maintain separate apps targeted at entirely different operating systems, but distribution got better and those apps could be powered by internet services in the background. Good software became about working with the unique constraints and capabilities of mobile devices.
Each of these shifts started with some new enabling technology. Early companies rush in with different approaches, creating a fragmented market. Eventually you get consolidation and standardization. A few platform winners emerge. Those platforms then enable everyone else to build on their unique capabilities to do useful things for a large market of end users.
You can see this happening today in the competition for agent supremacy. LLMs were the big initial shift. Agent “harnesses” came next. Now standard ways of extending agents are starting to emerge. They’re looking increasingly like platforms.
The big thing that sets agents apart from previous platform shifts is that agents are more than just plumbing to execute software on behalf of users—they are users in their own right. That opens up entirely new ideas about what software can be.
A bull case for software
There’s a strong chance agents follow the common historical arc of disruption, fragmentation, consolidation and standardization we’ve seen from new software platforms over the last 75 years.
If that happens, BYOA becomes a reality and staking your whole strategy on embedded agents will seem as foolish as building your own phone just to ship a few apps.
BYOA does, however, represent an opportunity for a new wave of companies to build software that maximizes what agents can do. It won’t be an easy transition. We’ll see plenty of old guard fade away. UX, GTM and pricing will have to evolve.
I wouldn’t be surprised to see some successful B2B software companies launching with just an MCP, a set of skills and some usage-based pricing. That may seem ludicrous, but it seemed crazy back in 2010 when Instagram launched with a mobile app and no website. They simply went all in on the new platform.
I’m long on agents and software. Bring your own agent and let’s find out if I’m right.
Yes, agents are software—software that can write other software—but the stock market doesn’t care about that fine distinction and so neither will we.
If you’re of a certain age, you heard this in Morpheus’ voice.
I do not believe Salesforce will win this one.
It’s an open question whether you can own the agent platform but not the LLM. Apple could pull it off by just letting everyone build AI infrastructure while they buy capabilities for some change they found in Tim Cook’s office couch cushions.
Meaning software people actually use regularly at scale to do something valuable. You know, the kind of software people pay for.
It won’t just cost tokens, of course. There will be fixed and variable infrastructure costs. Don’t forget opportunity cost. There might even be a few humans still in the mix. How much are you willing to spend to forgo that $25k/year SaaS subscription with 5 9s of uptime, SOC2 compliance and regular feature updates?
Yes, Linux arrived during this time too. That’s a slightly more complicated story.