There’s a server running in my house right now that would have been science fiction five years ago.
It’s a Mac mini — the kind you can buy at any Apple Store — sitting on a shelf in my home office. It runs 24/7. On it, there’s a personal AI agent that manages my email triage, monitors my family’s calendar, drafts blog posts, tracks my fitness data, keeps notes on dozens of ongoing projects, and holds more context about my daily life than any single app or service ever could. It has access to my files, my messages, my schedules. It’s connected to a local language model for tasks that shouldn’t leave my network and to cloud APIs for tasks that need more horsepower.
Next to it — well, not physically next to it, but on the same network — there’s a NAS running a dozen Docker containers: a DNS sinkhole that blocks ads and trackers across my entire home network, a reverse proxy that gives everything clean internal URLs, a media server for my family, a chore tracker, a feed reader pulling from 124 RSS sources. On a different server, I run my own Personal Data Server for the AT Protocol — the open social networking standard that powers Bluesky — which means my social identity, my posts, and my social graph don’t belong to any company. They belong to me.
I’m telling you this not to brag about my homelab setup. I’m telling you because this — all of it, running on consumer hardware that cost less than a year of cloud subscriptions — represents something that the tech industry desperately doesn’t want you to understand: you can own your own infrastructure, and it’s getting easier every year.
This is the eighth post in the Neoteric series, and if the previous seven have been building toward anything, it’s this. We’ve traced the arc from science fiction visions through ethical frameworks, economic analysis, cultural shifts, responsible building, trust infrastructure, and new organizational forms. Now it’s time to talk about the architecture of the world those ideas point toward — a world where individuals and small collectives own the infrastructure that shapes their digital lives.
The Landlord Problem
Let me start with an analogy that anyone who’s rented an apartment will understand.
When you use a cloud service — Gmail, Notion, Slack, iCloud, Google Drive, any of them — you’re renting. The service provider owns the building. They set the rules. They decide what features you get, what you pay, when to renovate, and when to demolish. You have a lease (the terms of service), but that lease can change at any time with minimal notice. Your data lives in their building, and while there are usually export options, the practical reality is that moving is expensive, time-consuming, and often lossy. You leave furniture behind.
This analogy isn’t perfect — digital services have zero marginal cost dynamics that physical real estate doesn’t — but the power dynamic is identical. The provider captures the value of your investment (your data, your workflows, your habits, your social graph), and that captured value makes it progressively harder to leave. Economists call this switching costs. Normal people call it being stuck.
For most of computing history, this was an acceptable tradeoff. Running your own email server was a full-time job. Self-hosting a database required actual expertise. The cloud offered convenience, reliability, and features that individual operators couldn’t match. Renting made sense because building was impractical.
That equation has changed. Not gradually — drastically.
What Changed
Three things happened more or less simultaneously, and their convergence is what makes this moment different from every previous “year of the Linux desktop” prediction.
Hardware Got Absurdly Powerful and Cheap
The Mac mini I run my AI agent on has a neural engine that can do 38 trillion operations per second. It has unified memory that eliminates the bottleneck between CPU and GPU. It costs $600. Five years ago, equivalent AI inference capability required cloud instances that cost hundreds of dollars per month.
The QNAP NAS on my network has multiple terabytes of storage, runs a full container orchestration platform, and serves media to every device in my house. It cost less than two years of the cloud storage equivalent.
This isn’t a niche hobbyist situation anymore. Consumer hardware — the stuff on shelves at Best Buy — is powerful enough to run services that used to require enterprise infrastructure. The gap between what a motivated individual can deploy at home and what a small company runs in the cloud has narrowed to the point where, for many use cases, it’s nonexistent.
Software Got Radically Easier to Deploy
Docker changed everything. I know that sounds like developer hype, but I mean it literally. The difference between “install this service” in 2015 and “install this service” in 2026 is the difference between following a 47-step guide that requires specific OS versions, library dependencies, and configuration files — and running a single command that pulls a container image and starts it.
My NAS runs Pi-hole, Caddy, Jellyfin, a print server, multiple AI agent instances, a chore tracker, and several other services. Each one was deployed in minutes. Not because I’m especially skilled at operations — because the packaging and deployment tooling has matured to the point where “self-hosting” no longer means “self-administering a Linux server.” It means “pulling containers and editing YAML files.”
Combine this with projects like CasaOS, Umbrel, and TrueNAS, which provide consumer-friendly interfaces for home server management, and you have an ecosystem where self-hosting is approaching the usability of installing a phone app. Not there yet — but close enough that the barrier is motivation, not skill.
Open-Source AI Eliminated the Last Moat
This is the big one, and it happened faster than anyone predicted.
In early 2023, the only way to get capable AI was through API calls to OpenAI or Google. The models were proprietary, enormous, and required data center-scale infrastructure. If you wanted AI capabilities, you rented them from a hyperscaler. No exceptions.
Then Meta released Llama. Then Mistral released their models. Then Google released Gemma. Then DeepSeek released models that rivaled GPT-4 at a fraction of the size. The open-source AI ecosystem went from “toy models that can barely write coherent sentences” to “production-quality models that run on consumer hardware” in about eighteen months.
I run a 4-billion-parameter model locally for tasks that shouldn’t leave my network — embedding searches against my personal notes, classifying emails, processing transcripts of family conversations. It runs on the same Mac mini as everything else. No API calls, no usage fees, no data leaving my house. The model isn’t as capable as Claude or GPT-4 for complex reasoning, but for the 80% of tasks that don’t require frontier-model intelligence, it’s more than sufficient.
This matters because AI was supposed to be the ultimate centralizing technology. Training frontier models costs hundreds of millions of dollars. Only a handful of companies can do it. The assumption — shared by those companies and by most commentators — was that AI would cement Big Tech’s dominance because nobody else could afford to play.
What actually happened is that the weights got released, quantization techniques made them runnable on consumer hardware, and an army of open-source contributors built tooling that made deployment trivial. The means of AI production — not training, but inference and fine-tuning — got democratized faster than any previous technology in computing history.
AT Protocol: A Case Study in Decentralized Architecture
I want to spend some time on the AT Protocol because it’s the clearest example I know of what decentralized infrastructure looks like when it’s designed well.
Most people know Bluesky as “the Twitter alternative.” That framing misses the point so thoroughly that it’s almost misleading. Bluesky is a client — an app that provides a particular view of a particular dataset. The AT Protocol is the infrastructure underneath it, and the infrastructure is what matters.
Here’s how it works, stripped to essentials:
Your identity is a DID (Decentralized Identifier). It’s a cryptographic identity that you own. Not “you own it the way you own a Twitter handle” — you own it the way you own a private key. No company can revoke it. No platform change can invalidate it. It’s yours.
Your data lives in a PDS (Personal Data Server). Think of it as a personal database that stores everything you create on the network: posts, likes, follows, blocks, lists. The default is that Bluesky hosts your PDS. But you can run your own — and I do. My PDS runs on my own infrastructure, which means my data lives on my hardware, under my control. If Bluesky goes bankrupt tomorrow, my data persists.
Views are separate from data. The feed algorithms, the trending topics, the moderation decisions — these are services that read from the data layer, not properties of the data itself. Don’t like Bluesky’s algorithm? Use a different feed generator. Don’t like their moderation? Use a different labeler. The protocol is designed so that the consumption layer is swappable without touching the data layer.
Portability is structural, not theoretical. On traditional platforms, “data portability” means “you can download a ZIP file of your posts that no other service can read.” On AT Protocol, portability means you move your DID’s hosting to a different provider, and your identity, your social graph, and your content come with you. Seamlessly. No ZIP files, no re-uploading, no starting over.
Why does this matter beyond social networking? Because AT Protocol demonstrates a design pattern that can be applied to any domain where users create data that a platform currently captures:
- Professional networks where your reputation and connections survive platform changes
- Content platforms where your creative work and audience belong to you, not the hosting service
- Communication systems where your message history and contact list aren’t locked into one app
- AI agent ecosystems where your agent’s identity, reputation, and interaction history are portable
The AT Protocol isn’t trying to replace every centralized service. It’s demonstrating that there’s a better architectural pattern — one where the data layer is owned by users, and the service layer competes on quality rather than on lock-in.
Self-Hosted AI: The Personal Stack
Let me get concrete about what a self-hosted AI setup looks like in 2026, because I think the gap between perception and reality is enormous.
Perception: Self-hosted AI means you’re a machine learning engineer with a rack of GPUs in your garage, training models from scratch and babysitting CUDA drivers.
Reality: Self-hosted AI means you download an application, pull a model, and start using it. The complexity is hidden by tooling the same way that Docker hid the complexity of server administration.
Here’s my stack:
Ollama handles local model serving. It’s a single binary that manages model downloads, quantization, and inference. Running a model locally is literally ollama run gemma3:4b. That’s it. It exposes an API that any application can call, and it manages GPU memory automatically.
OpenClaw (the platform my AI agent runs on) is open-source software that turns a language model into a persistent, tool-using agent with memory, scheduling, and integrations. It runs on Node.js. The configuration is a YAML file. Deploying it is npm install -g openclaw && openclaw init.
mlx-whisper handles speech-to-text transcription locally, on the GPU, with no data leaving the machine. I can transcribe a 35-minute voice memo in 90 seconds. This matters because voice memos are my primary input method for complex thinking — I talk through ideas while walking, and the transcripts become the raw material for projects like this series.
None of this required machine learning expertise. It required the same skills as any other self-hosting project: reading documentation, editing configuration files, and being willing to troubleshoot when something doesn’t work. The tooling has matured to the point where the barrier is wanting to do it, not knowing how.
What I can’t do locally — and this is important to be honest about — is match the capability of frontier cloud models for complex reasoning, long-context synthesis, and nuanced writing. My local 4B-parameter model is good for classification, embedding, and simple generation. For writing a Neoteric post or analyzing a complex codebase, I use Anthropic’s API. The local models handle the private stuff; the cloud models handle the hard stuff. It’s a hybrid architecture, and pretending otherwise would be dishonest.
The point isn’t that you can completely escape cloud dependency today. The point is that you can choose which dependencies you accept, based on actual tradeoffs rather than forced lock-in. That choice didn’t exist three years ago.
The Open-Source AI Renaissance
I want to zoom out from my personal setup and talk about what’s happening in the broader open-source AI ecosystem, because it’s the most significant technology story of our moment and it’s being dramatically underreported.
Here’s a partial list of what’s happened in the last twelve months:
Meta released Llama 3.1 in sizes from 8B to 405B parameters, with an open license that allows commercial use. The 405B model is competitive with GPT-4 on most benchmarks. It’s free.
DeepSeek released models that match or exceed GPT-4 on reasoning benchmarks at a fraction of the parameter count, using novel architectures (mixture of experts) that make them runnable on smaller hardware. Their research is published openly.
Mistral continues to release high-quality models in commercially permissive licenses, specializing in efficient architectures that punch above their weight class.
Google released Gemma in multiple sizes optimized for on-device inference, including versions specifically designed for Apple Silicon.
The MLX ecosystem (Apple’s machine learning framework for their own hardware) has exploded, making Apple Silicon Macs into genuinely capable AI inference devices without requiring NVIDIA GPUs.
Quantization techniques (GGUF, AWQ, GPTQ) have advanced to the point where models that “require” 32GB of VRAM can run acceptably in 4GB, with quality loss that’s often imperceptible for practical tasks.
The significance of this can’t be overstated. A year and a half ago, the AI landscape looked like it was going to be the most centralized technology market in history — three or four companies with hundred-billion-dollar training budgets, everyone else paying rent. What actually happened was that the open-source community, funded by a mix of corporate strategy (Meta wants to commoditize the complement) and genuine ideology (researchers who believe AI should be open), created an alternative stack that’s good enough for the vast majority of use cases.
This is the printing press moment that we talk about in the abstract but rarely identify in real time. The means of AI inference — not training, but using — have been democratized. An individual with a $600 computer and an internet connection has access to AI capabilities that were literally unavailable at any price two years ago.
What “Decentralized Futures” Actually Looks Like
So what does all of this add up to? Let me paint a picture that’s not science fiction — it’s extrapolation from things that exist today.
Your identity is yours. Your DID is your identity across every service you use. Your reputation, your credentials, your social graph travel with you. No platform can hold them hostage. When you switch services — and you will, because services that can’t compete on quality lose users they can’t lock in — your identity is seamless.
Your data lives where you choose. For data that’s private — health records, financial information, family communications, personal AI interactions — you self-host. For data that benefits from aggregation — social posts, professional contributions, creative work — you use decentralized protocols that give you ownership while enabling network effects.
AI works for you, not your landlord. Your personal AI agent runs on your hardware for private tasks and uses cloud APIs (that you choose, and can switch between) for tasks that require frontier capability. The agent’s memory, your interaction history, your preferences — they’re files on your machine, not entries in someone else’s database.
Organizations are opt-in and transparent. When you collaborate with others, you do so through structures (DAOs or their successors) where the rules are explicit, governance is participatory, and your exit rights are structural. You can leave any collective and take your contributions with you.
Infrastructure is composable. Each piece — identity, data storage, AI capability, organization membership — is a module that connects to the others through open protocols. You can swap any piece without rebuilding the whole stack. Tired of your feed reader? Switch it; your subscriptions are portable. Want a different AI model? Switch it; your agent’s memory and tools don’t change.
This isn’t utopian. It has real costs. Self-hosting requires maintenance. Decentralized systems are slower than centralized ones. Open-source software sometimes has rougher edges than commercial alternatives. The hybrid model — local for private, cloud for hard — means you’re still dependent on cloud providers for some things.
But compare it to the alternative: a world where three or four companies own your identity, your data, your communications, your creative output, and your AI capabilities, and extract rent from every interaction. A world where “personalization” means a corporation knows more about you than you know about yourself, and uses that knowledge to maximize your engagement (their revenue) rather than your wellbeing (your interests).
The costs of decentralization are real. The costs of the alternative are existential.
The Builder’s Responsibility
Throughout this series, I’ve been writing for a specific audience: builders at the edges. People who are tinkering with personal AI, self-hosting their infrastructure, experimenting with decentralized protocols. The people who, in Cory Doctorow’s framing, are building the “adversarial interoperability” that keeps technology honest.
If you’re one of those people, I think we have a responsibility that extends beyond our own setups. We’re proof-of-concept for a different way of relating to technology. Every time someone sees a self-hosted setup that works — that’s reliable, that does what commercial alternatives do, that respects privacy and grants autonomy — it shifts the Overton window of what people think is possible.
I don’t mean evangelism. Nobody likes the friend who won’t shut up about their homelab. I mean demonstration. Running infrastructure that works. Writing about what you learn. Making the tools better for the next person. Contributing to the open-source projects that make all of this possible.
The decentralized future doesn’t happen because someone writes a manifesto (though we’re getting close to that — stay tuned for Post 10). It happens because enough individuals make the practical choice to own their infrastructure, and the network effects of those choices compound until the centralized alternative looks increasingly untenable.
What’s Coming
We’re at an inflection point, and I want to be specific about what I think happens next.
Local AI gets good enough for more tasks. The gap between local models and frontier models is narrowing every quarter. Within a year, I expect 7B-parameter models to handle most of the tasks I currently send to cloud APIs. The hybrid model shifts toward local-first, cloud-for-edge-cases.
Self-hosting gets even easier. Projects like Umbrel, CasaOS, and the containerization ecosystem continue to lower the barrier. I’d bet that within two years, setting up a self-hosted AI agent is as easy as setting up a smart home device. The market for “personal server” hardware is emerging — dedicated devices purpose-built for home infrastructure.
Decentralized protocols mature. AT Protocol is the leading edge, but there are others — Nostr for messaging, IPFS for storage, various DID standards for identity. These will consolidate, interoperate, and become infrastructure that developers build on without thinking about, the way TCP/IP became invisible plumbing.
Regulatory pressure increases. GDPR was the first wave. The EU’s AI Act is the second. As people become more aware of what centralized AI platforms know about them, the political appetite for data sovereignty regulation will grow. Self-hosted infrastructure isn’t just a technical choice — it’s going to be a compliance choice.
The talent flows. This is the one I’m most confident about. The most interesting engineers, designers, and builders I know are increasingly drawn to open-source, decentralized, user-sovereign projects. The talent isn’t going to Big Tech anymore — or at least, not all of it, and not the most creative fraction. The ideas, the energy, the ambition are moving toward the edges.
The Infinite Game
I’ve been using a framework throughout this series that I want to make explicit: the distinction between finite games and infinite games.
A finite game is played to win. It has defined players, defined rules, and a defined endpoint. The corporate tech race is a finite game: ship faster, capture more market, achieve dominance before the other guy. The players are known, the rules are “grow or die,” and the endpoint is either monopoly or acquisition.
An infinite game is played to keep playing. The goal isn’t to win but to continue the game, to ensure that there are always players, always possibilities, always room for new moves. The rules evolve. New players join. The game adapts.
Centralized technology is a finite game. Someone wins, and when they do, everyone else is stuck renting from the winner. Decentralized technology is an infinite game. Nobody wins, because winning isn’t the point. The point is that the game continues — that there’s always room for a new protocol, a new model, a new way of building — and that no single player can end it by capturing the infrastructure everyone depends on.
I build at the edges because I want to keep playing. I self-host because I don’t want my ability to participate in the digital world to depend on any company’s continued existence or benevolence. I use open-source AI because I believe the means of intelligence — like the means of communication, and the means of production before that — should be available to everyone, not rented from a few.
That’s not ideology. That’s architecture.
This is part 8 of a 12-part series. Previously: “The DAO Revolution” — how decentralized autonomous organizations are creating new models for collective action. Next: “AI for Workers” — how individuals are using AI to replace employer leverage, and what that means for the future of work.
Running your own infrastructure? Self-hosting AI? Building on decentralized protocols? I want to hear about it. Find me on Bluesky.