Why workflow SaaS loses to local assistants

I am doing most of my work through a local coding agent. I add skills, prompts and MCP servers, and Claude Code does the rest. When I need a new capability, I work through the problem, use evals, run experiments and once I am satisfied with the results, I create a new skill using Claude. I am able to do all this as a developer, but that gap is closing fast, because the agent can build its own tooling from a plain description.

Now let’s compare that with building the same capability as a SaaS product. I have done both, and the SaaS version is easily 10x harder. You need multitenancy, session storage, compaction, forking, sandboxes and billing. Most of that comes free on a laptop, where separate folders already keep the work isolated.

The squeeze

If I compare it to the pre-cloud era, everyone ran servers locally, and ownership and ops were your problem. Cloud won because providers absorbed those burdens, and made money doing it. If agents follow the same path, hosted agents win in the end. Anthropic and Google are already building the hosting.

So the interesting question is probably not local versus hosted. The question is what happens to the companies in the middle, the SaaS products that sit on top of a platform and sell judgment about it, for example ad optimization on top of Meta, analytics on top of your warehouse, reporting on top of someone else’s API.

That middle is getting affected from two layers. From below by local assistants, because a skill plus an MCP server and CLIs now replaces the product for anyone willing to operate an agent. From above by the model platforms, because they are absorbing the hard parts of hosting agents the way AWS absorbed the hard parts of hosting servers. The cloud path may get repeated for hosting agents in the future, but right now this is happening on a laptop or a VPS. The middle loses either way.

This doesn’t cover fundamental SaaS. Payments still need rails. Ads still need an auction to run on. This applies to the layer that interprets, not the layer that executes.

Why the middle cannot defend itself

It sells ownership it cannot honor. The classic case for SaaS is liability transfer, that if it breaks, it is the vendor’s problem. That worked when the promise was uptime, because uptime is measurable and an SLA can cover it. An agent’s output is not measurable that way, so the ownership promise breaks in two ways: the cost of honoring it, and who takes the blame.

First, the cost. To keep “it’s our problem” true, the vendor has to do extra work: multi-tenant isolation, audit trails, safety checks etc. All of that gets priced into the product. On my laptop those problems disappear automatically, because there is only one tenant and one user. So the customer is paying for extra complexity. The multi-tenant cost was always there and was always priced in pre-AI, and it was worth paying, because there was no other way to get the capability. The local agent is the new part with the same capability, one tenant, one user.

Second, the blame. People judge their own mistakes less harshly. If I approve a bad command locally, the responsibility is clearly mine, and that clarity is oddly comfortable. I accept the mistake and move on. When a paid SaaS spends the budget on the wrong audience, there is no such forgiveness, and the terms of service will disclaim the loss anyway. After that failure, the customer still needs a domain expert to catch and fix what went wrong. That expert now holds a local assistant and has little reason to keep the product.

Agents still need a human within arm’s reach. Agents fail mid-session in quiet ways. Memory gets skipped, context drifts, an injected instruction slips in. Locally this is an inconvenience: I see it and correct it in the next message. On hosted agents, the human is outside the loop, so the same failure becomes a support ticket or silent wrong output. The failure is the same in both cases, but the human is too far away to catch it early.

Its competitor sets its input price. A workflow SaaS buys tokens wholesale and resells them with a margin, from the same vendor that competes with it from above. My local assistant runs on a first-party subscription at near cost. That one subscription also powers every workflow the agent runs, so the same price replaces many products at once, and each of those products carries its own margin and overhead. Token prices will fall for everyone, but the middle also carries the overhead of sandboxes, session storage, identity, compute, resources etc. On a laptop those are free.

The productivity gains started off with developers, where Claude Code, Cursor, Codex etc. gained traction, followed by releases like CoWork, ChatGPT Work etc. More and more work is getting done from the local assistants as more powerful models get released and as they cover more and more use cases.

This is my current read, formed while building my own agent platform, and it may change as I build.