Sci-Fi Labs · Essay

You Bought the Hardware. You Never Owned It.

You paid for the silicon. The software, the data, and the intelligence belong to someone else. We've entered a new era of computing — one where you can own the full stack. The OS, the AI, the apps, the data. Here's why, and how.

You bought the phone. You think you own it. You don't.

Every picture you take gets sent to the cloud. Your location is tracked. Every message you send, every call you make, every search — reported, monetized, used to train someone else's model. You rely on the brand to push out updates, and the brand decides what those updates do. You paid for the silicon. The software, the data, and the intelligence belong to the vendor, not you.

That's the deal we've all been living with. It just ended. The pieces have finally converged: an OS that ships with AI baked in, local models good enough to run as a personal assistant on a 16 GB laptop, where your sensitive data stays, and frontier models a prompt away for the heavy lifting. You can take control of the whole stack — the OS, the AI, the apps, the data — on a machine that answers to you.

The precedent

In August 2007, a seventeen-year-old named George Hotz — geohot — spent about five hundred hours soldering and coding until he unlocked the original iPhone. He stood in his parents' kitchen, hit record, and said: "This is the world's first unlocked iPhone." The New York Times covered it. CBS, CNBC, Wired. He traded the phone for a Nissan 350Z.

He wasn't trying to be rich. He wanted to use his iPhone on T-Mobile instead of AT&T. The lock was physical — a carrier-locked baseband chip, firmware signed by the manufacturer, a bootloader that decided what was allowed to run. He cracked it with a Phillips screwdriver, a guitar pick, and a soldering iron, then posted the instructions so anyone could do it.

That was the first crack. Then he did it again, and again, for nearly two decades. The PS3's hypervisor in 2010 — Sony sued him under the DMCA the next year. Towelroot in 2014, a one-tap Android root for devices with an eighteen-thousand-dollar bounty on them. comma.ai and openpilot — open-source self-driving, MIT-licensed, now on over three hundred car models and over three hundred million miles. tiny corp and tinygrad — a from-scratch deep learning framework to commoditize the petaflop and keep compute decentralized.

Same move, every time. Phone. Console. Car. Android. AI compute. Take something that isn't yours. Make it yours. Hand the key to everyone.

His own words nail the philosophy. From his blog: "I don't mean 'owns' from a legalist perspective, I mean 'owns' as in the hacker meaning, like 'owning' the box. Who has root?"

He's the precedent. Same move, every time — and it applies just as much to the machine you're reading this on.

The machine was always locked

The lock on the laptop isn't new. Windows and macOS have been locked down for years — SIP, the sealed system volume, notarization, telemetry you can't refuse, a vendor deciding what gets to run before you do. You open Activity Monitor and see the list. You just can't do anything about most of it.

What changed isn't the OS. What changed is that the vendor's reach now extends to the AI that writes your code, the data that trains it, and the intelligence that organizes your life — all of it behind the same gate. And for the first time, the tools exist to take all of it back.

Linux has been the escape hatch for decades. You could always replace the vendor's OS with one you controlled. That part isn't new. What's new is that the pieces finally fit together. Omarchy ships with AI natively integrated — you can tweak anything about it by talking to a local model. A driver misbehaves, a game won't launch, you hate the theme — describe the problem, the model writes the fix, you approve it, every change visible and reversible.

That's not customization. Customization is picking from a menu. This is describing the machine you actually want and having it built. And it only gets better from here — the models get smarter, the tools get easier, the gap between what you imagine and what you can build keeps closing.

The AI belongs to you too

Following the same logic, you should own the AI.

The model that writes your code, answers your questions, organizes your life — that shouldn't live on someone else's server, under someone else's terms, with someone else's off-switch. Hotz put it bluntly: "The fundamental limitation of cloud is who owns the off-switch."

Running AI locally used to be hard. On 16 GB of RAM — what most people actually have on their laptop — frontier models don't fit. But the landscape shifted. Small, efficient models like Bonsai run on a machine like that through llama.cpp, and you get a personal assistant that lives on your hardware, not a server farm in Virginia. Your sensitive data stays there. For the moments you need more — building an app, a multi-step install, a real refactor — you bring in frontier models through OpenCode. That conversation goes through the cloud, and you should treat it that way. The frontier model gets the code, not your life. When the heavy lifting is done, you hand daily use back to the local model.

Your data is more valuable than ever — and they're taking it

Here's the part that makes this urgent now, not just philosophically interesting.

In the old world, your data was harvested and sold for ads. Now your data is more valuable than ever — because it gets used by AI to teach it and make it better. Every photo, every message, every document, every search, every financial record you hand to a cloud service becomes training material for someone else's model. They're basically stealing your intellectual property and your private data, turning it into capability, and selling that capability back to you.

The hardware was always yours. The software was someone else's. The data was extracted. The AI was someone else's. The whole stack belonged to the vendor.

Until the pieces stopped needing the vendor to talk to each other.

The culmination

Any one of these pieces on its own isn't enough. Linux without AI is just a distro you maintain yourself. AI without Linux is a chat window in someone else's cloud. The era begins when they converge.

The OS ships with the model. The model is good enough to run on the machine you have. Frontier models are a prompt away for the hard parts. And the whole thing gets easier every month.

You can talk to your computer now. The model writes the code — whether that's a UI tweak, which is most of the cases, or wiring in something that doesn't work quite right for your setup. You don't need to be a developer. You need to be able to describe what you want.

Pull your bank statements and have your AI build a mobile app and a desktop app for your financials. Download your medical records — the data you're most locked out of, the one place the cloud's convenience argument is weakest — and feed it to a local model. You get a health dashboard that works the way you think, not the way a vendor's product manager decided. Same move for taxes, credit card statements, everything. The archive was always yours. It just had nowhere to go.

Flash a custom ROM on your phone. Build custom apps. Take control of your desktop. Run AI locally. Publish only what you choose. The rest stays on the machine. Private. Secure. Sovereign.

And this is the early days. The models will get more intelligent. The tools will get easier. What you can do today by talking to a model is the floor, not the ceiling.

The pattern, applied

geohot spent nearly two decades proving the thesis: take something that isn't yours, make it yours, hand the key to everyone. This is the same thesis applied to the machine you use every day — the laptop, the AI, the apps, the data. Not one device. The whole stack.

The recipe

This is the why. The how is a five-part series that takes you from a stock laptop to a machine you own end to end — the OS, the local AI, the apps, the public site, and the archive of your data. It runs on 16 GB — the laptop you already have.

1. Take Over the Machine — install Omarchy, strip the vendor's defaults, list every process and know why it's there.
2. Fork, Customize, or Build — llama.cpp + Bonsai on localhost, Open WebUI on top, the Knowledge Graph fork for memory.
3. Claim the Domain — claim a domain, push to GitHub, let Vercel deploy. The public arm of the stack.
4. The Local AI Layer — fork or scaffold apps, point them at your local model, run them on the machine you jailbroke.
5. Graduate to Creator — export from the platforms, import onto the machine, drop it into the graph. The archive comes home.

It works on the laptop you already have. The full walkthrough — prompts, commands, the exact order — is in the series. If you've been renting your machine, this is how you stop. Start with part one and take the keys back.

Paul Visciano · Sci-Fi Labs · paulvisciano.com