There is a growing assumption in AI right now that the future of agents is self-hosted. You can feel it everywhere: open-source models, OpenClaw, Hugging Face demos, DIY stacks, rented VPSs, on-prem deployments, and endless screenshots of agents running from laptops, Mac minis, and home servers. The vibe is clear. If agents are becoming real, then surely the endgame is that everyone will run them themselves.
I think that is the wrong conclusion. What we are seeing is real, important, and exciting. But we are confusing a bootstrap phase with a destination architecture. And more importantly, the debate is overfocusing on where inference runs, while the real question is who owns the operational burden of agent systems.
Why self-hosted feels like the future right now
The self-hosted movement is not irrational. It is growing for good reasons. OpenClaw is explicitly positioned as a personal AI assistant you run on your own devices. Open models are getting better. Tooling is improving. Running serious AI systems outside the big labs feels more possible than ever. For builders, researchers, and technical power users, that is genuinely energizing.
There is also a deeper narrative underneath it: control. Control over data, cost, behavior, and where the system runs. That is a completely understandable reaction in a market where agent infrastructure is still immature, trust is still forming, and many hosted AI products feel shallow, constrained, or overpriced.
But none of that proves self-hosting is the long-term default. It only proves that when platforms are immature, builders route around them. That has happened many times before, and the pattern that follows is worth examining.
The pattern is familiar
When the infrastructure layer is young, people over-index on doing everything themselves. They run their own servers, host their own files, self-manage their own pipelines. They assemble their own stack because the managed layer is not good enough yet.
Cloud storage is the closest analogy, though no analogy is perfect. NAS systems, home backups, Synology, on-prem file storage: for some users, those are excellent solutions. But the rise of cloud storage was not reversed by the fact that enthusiasts could store data locally. Cloud won the mainstream because it removed operational burden and packaged reliability, access, syncing, sharing, recovery, and convenience into software. Self-managed storage did not disappear. It found its niche. The pattern is worth taking seriously: when the managed layer is immature, technical users over-index on doing things themselves, and once the platform becomes good enough, the mainstream shifts toward abstraction.
I think AI agents will follow the same trajectory. Self-hosted agents will absolutely exist and matter. But when I say “self-hosted,” I am grouping together very different worlds: hobbyist laptop setups, VPS-hosted agents, serious enterprise on-prem deployments, and local-first device agents. These are different categories with different motivations, but they share one underlying assumption: that the long-term answer is to run the agent stack yourself. That assumption is what I am challenging.
The real bottleneck
One reason people are getting carried away is that agent demos are making the wrong thing feel like the main thing. A self-hosted demo is compelling because it feels magical. You install something, wire up a model, give it a channel, and suddenly your own machine is doing real work. It feels like the future arrived early.
But demos prove that something is possible, not that it is sustainable at scale. The real question is not whether an agent can run locally. It is what it takes to operate an agent reliably over time. Because once agents become useful, people do not just want them to answer prompts. They want them to run continuously, keep context, call tools, survive failures, manage permissions, handle secrets, coordinate with systems, and take action safely. That is no longer just inference. That is software infrastructure.
And infrastructure is where the actual bottleneck lives. The long-term constraint in AI agents is not whether weights are open or whether a model can run on your laptop. The hard part is everything around the model: keeping agents running reliably, managing state and memory, enforcing permissions, recovering from failures, observing what happened and why, controlling cost, and making the whole system auditable and governable in production.
I see this directly in my own work building agent systems for enterprise compliance. An agent that reasons brilliantly is not especially useful in an enterprise setting if it cannot maintain an audit trail, enforce who approved what action, or operate within policy boundaries. The model alone is not the moat. The orchestration layer, the governance layer, the operational backbone: that is where the real engineering advantage accumulates. And once you look at agents through that lens, the self-hosted-by-default thesis starts to look much weaker. Most people do not actually want to operate agent infrastructure. They want the outcome.
SaaS will not outsource its future to customers’ server racks
This is the part that matters most for where the market is going.
If AI agents become a foundational part of software, SaaS companies are not going to tell customers: “Great news. To use our AI agents, please provision the infrastructure, manage the runtime, maintain uptime, wire up orchestration, and keep the whole system alive.” That is not a product strategy. That is a transfer of burden.
The more likely outcome is that SaaS companies will build their own agent layers into their products and deliver them the same way software has been delivered for the last two decades: as managed systems. Not because local or on-prem are invalid. Not because enterprises will never require private deployments. But because the center of gravity of software remains convenience, reliability, and abstraction. And agents dramatically increase the value of those abstractions.
Here is the part that is counterintuitive: the more autonomous the software becomes, the less most customers will want to operate the machinery underneath it. Autonomy increases the surface area of things that can go wrong. That makes operational reliability more important, not less. And operational reliability at scale is exactly what managed platforms are built to deliver.
The hybrid future
To be clear, I am not arguing against self-hosted AI. There are legitimate reasons for local and on-prem deployments: privacy, latency, offline workflows, device-native experiences, regulated environments, data residency, sovereign requirements. The major cloud platforms themselves describe the world this way. AWS’s own guidance presents a tiered execution model where device edge and network edge handle latency-sensitive or local processing, while the cloud core handles heavy inference, orchestration, agent reasoning, and RAG pipelines.
The important distinction is between architectural possibility and market default. These are not the same thing. Local and self-hosted are real architectural options. They are part of a hybrid future whose operational backbone will still, in most cases, live in managed infrastructure. The argument here is not against self-hosting as a mode. It is against self-hosting as the default thesis for where agent software is heading.
Where I see this going
Aravind Srinivas recently argued that the “biggest threat to a data centre” is intelligence being packed locally onto the device, reducing the need for centralized inference. I understand the intuition, and some of that future will absolutely happen. On-device intelligence will improve. Self-hosted agents will get better. Open models will keep changing the economics of access.
But the cloud side is not standing still. Google Cloud is already working on the “efficient frontier” of LLM inference: routing, batching, quantization, speculative decoding, disaggregated prefill/decode paths. That is the kind of systems work that turns expensive, awkward AI infrastructure into something industrial-grade. The platform layer is compounding, and as it does, many of today’s reasons for self-hosting by default will weaken.
The architecture will become more flexible. The operational center of gravity will stay in managed platforms. That is what happened in storage, it is what happened in software delivery, and I suspect it is what will happen in agent infrastructure too.
This is the direction I am building toward in my own work. Not because self-hosting is wrong, but because the real opportunity is in making agentic software dependable, governable, and safe to connect to real systems. The hard problem was never getting an agent to run. It was making it boring enough to trust.
In the end, the market rarely rewards the architecture that is most exciting to assemble. It rewards the one that makes powerful systems feel boringly reliable.
I’m CPTO at Complyance, building AI-first compliance software where agent governance is the product. I also build autonomous agents on the side for personal automation and learning. More on AI agents here. Find me on LinkedIn or X.