Why Software Economics Haven't Changed (Despite What the AI Hype Tells You)

Introduction: The Panic

If you've been on tech Twitter lately, you've seen the panic. OpenClaw has gone viral, tech stocks are wobbling, and there's a growing chorus claiming that SaaS is dead. The logic goes: if anyone can spin up an AI agent to build custom software, why would you ever pay for a vendor again?

As someone who's spent the last few years building software at startups and watching the AI revolution unfold from the trenches, I'm here to tell you: the unit economics of software haven't fundamentally changed. Not even close.

OpenClaw: A Watershed Moment

Let me be clear: OpenClaw is a big deal. It's amassed over 145,000 GitHub stars since its November 2025 launch, making it one of the fastest-growing AI projects ever. It's genuinely useful. As an engineer who's spent time with it, I can objectively say this feels like a ChatGPT-level moment—the first agent framework that actually delivers on the promise of autonomous task execution.

The magic of OpenClaw is its ability to fix itself. It can literally debug its own errors, iterate on solutions, and execute long-running tasks with minimal supervision. It doesn't matter if your personal assistant has a PhD in physics—you just need basic reasoning skills and the ability to get things done. OpenClaw delivers that.

But here's where the panic comes in. People see this capability and extrapolate: "If I can build custom software with OpenClaw, why would I ever pay for SaaS again?" The answer is more nuanced than the hot takes suggest.

The Unit Economics That Never Changed

Here's the fundamental truth that the AI hype machine keeps missing: it has always been cheaper to buy software than to develop it yourself. This remains true even in a world where AI agents can write code.

Think about it from first principles. Software vendors exist because they can amortize the cost of development across thousands or millions of users. When Zoom builds video conferencing software, they're spreading the cost of building, maintaining, and scaling that system across their entire user base. When you try to build your own Zoom replacement with OpenClaw, you're paying the full cost yourself.

This is where the rubber meets the road. Building software that "more or less works for you" is radically different from building software that works reliably at scale. Software companies invest enormous resources into:

• Infrastructure provisioning and scaling - Load balancers, CDNs, database optimization, caching layers

• Monitoring and observability - Understanding what's broken before your users complain

• Security and compliance - SOC 2, GDPR, penetration testing, vulnerability management

• Reliability engineering - Disaster recovery, backup systems, incident response

• Integration maintenance - Keeping up with API changes from external services

Software vendors will always be better at building software with the help of AI than consumers will be, for the simple reason that they have more expertise, resources, and economies of scale working in their favor.

The "Local-First" Illusion

Now, I can already hear the counterargument: "But with OpenClaw, I can build something that 'more or less works for me' without paying subscription fees! I can run it on my own hardware!"

Sure, you can. And for a technical founder working solo or with a small team, that might actually be a reasonable solution. If you wanted to build your own GTM machine, you can set up prompting, maintain your own instance, tinker with execution, and integrate external infrastructure for email sending, Twitter posting, or website management. If you have the expertise and time, go for it.

But here's what that doesn't give you:

• Multi-tenancy - The moment you need to share this with a team, complexity explodes

• Permissioning - Who can access what? Who can approve changes? How do you prevent disasters?

• Reliability guarantees - Did that email actually send? Did the website update? How do you know?

• Support & maintenance - When something breaks at 2 AM, you're on your own

Local-first projects are "easy" to build in comparison to actual business software. The concerns about something like OpenClaw destroying SaaS are overblown because of the fundamental complexity jump that happens when you transition from "works for me" to "works for my business."

Vertical Agents vs. Horizontal Agents

Here's where the conversation gets interesting. OpenClaw represents a breakthrough in horizontal agents—general-purpose tools that can do a bit of everything. But there's a reason vertical agents will continue to thrive: context, tools, and interface.

Context

It's not that OpenClaw can't have context about your business. It's that building reliable, production-grade agentic systems requires significant forethought into engineering context, state management, execution patterns, and runtime behavior data models. You need these foundations to get consistent, reliable results without unexpected behavior.

Sure, you could spend hours training OpenClaw on your business context. But that's exactly the kind of work that software companies do once and amortize across thousands of customers.

Tools

OpenClaw's tools are incredibly powerful but also incredibly generic. It has primitives like exec, fetch, and write. To use OpenClaw for marketing, you'd need to craft raw API calls to LinkedIn, write markdown files to the file system, and set up an SMTP server for email. Maybe it could do it, but it would be clunky as hell.

Vertical agents have specialized tools designed for their domain. A marketing agent has tools for "create email campaign," "schedule social post," and "analyze conversion funnel." These higher-level abstractions make the agent more effective and the user experience dramatically better.

And here's the kicker: even if you use OpenClaw to orchestrate your marketing workflow, you're best bet is still buying SaaS. You'd use Mailchimp's API for email delivery, LinkedIn's paid API access, Stripe for payments, Twilio for SMS. OpenClaw doesn't eliminate the need for external vendors—it just adds an orchestration layer on top of them. The unit economics haven't changed; you've just added complexity.

Interface

OpenClaw's interface is a chat window in your messaging app. That's great for many tasks, but imagine trying to design a marketing campaign entirely through text messages. You'd want: - A visual calendar view to see your campaign timeline - A collaborative editor for writing blog posts - A preview of how your email will look across devices - Analytics dashboards showing performance - Shareable links and comment threads for team collaboration

The interface matters. A lot. And building great interfaces is expensive—exactly the kind of work that benefits from economies of scale.

The Model Commoditization Factor

Here's an interesting observation: the models themselves are becoming interchangeable commodities. Migrating from AWS to GCP is painful. Switching from Nvidia chips to Google TPUs is painful because of CUDA lock-in. But migrating from OpenAI to Anthropic? Actually pretty easy.

This is fantastic news for software companies. It means competition on model price and quality will be fierce, and the benefits will flow to the application layer. The models getting smarter doesn't really move the needle anymore—I don't care if my assistant has a PhD in physics when I just need basic reasoning skills and reliable execution.

This means that much of the value will accrue to the next layer up the stack: the applications. And what differentiates the applications? Again, it's the context, tools, and interface.

What This Means for the Future

So what does a post-OpenClaw world actually look like? It's not a world where everyone builds their own software from scratch. Instead, I see three distinct outcomes:

1. Technical Individuals Get More Self-Sufficient

Solo founders, technical CMOs, and individual power users will absolutely use tools like OpenClaw to build custom solutions that work for them personally. This is great! It lowers the barrier to entry for technical experimentation and automation.

2. Vertical Software Thrives

Companies will continue to buy software for the same reason they always have: it's more cost-effective than building and maintaining it themselves. The difference is that software vendors will use AI to build better products faster, passing those efficiency gains to customers through better features and competitive pricing.

Vertical agents will differentiate through deep domain knowledge, specialized tooling, and interfaces designed for specific workflows. A marketing platform understands campaign management, content calendars, and conversion funnels in ways that a general-purpose agent simply cannot.

3. Software Becomes the Execution Layer

The most interesting development is software products becoming better execution layers for agentic workflows. Rather than replacing software entirely, agents will increasingly use software as the interface for getting work done. This is already happening—look at how AI agents interact with GitHub, Notion, and other platforms through their APIs.

The companies that win will be those that build robust execution layers with great UX, comprehensive integrations, and reliability guarantees. They'll make it "just work" so users don't have to double-check whether their email sent or their website updated.

The key differentiator will be building software with both humans and agents in mind. Great execution layers will have intuitive UIs for human collaboration alongside robust APIs for agent orchestration. This dual-interface approach—making it easy for humans to review and approve while letting agents handle the execution—is what will separate winning platforms from the rest.

A Note on AI-Assisted Content

Transparency matters to me, so I want to share how this blog post came together. The first draft was AI-generated based on my thoughts and conversations from a Slack thread about OpenClaw at work, before I went through and edited it. Here was my initial prompt:

heres a bug bunch of text which is from a slack thread at work due to all the raving about open claw recently

I dont think the unit econ of software has changed, if anything the flavor of how to write software that is still useful in a world where agents exist

also this snippet from another conversation i was having

smush this into a new blog post for me