Open-source
Fable is back. Which is exactly why I need to talk to you about the minds nobody can ever take away from you.
Hey.
Fable is back.
As I write this, the most powerful public model of the moment is live again. Across the platform, the app, the coding tools, all of it. Eighteen days after it vanished.
Let me remind you how those eighteen days went. On the 9th of June, it launched, state-of-the-art, benchmark-topping, the real thing. One company used it to compress a code migration across fifty million lines into a single day, work that would have taken a team two months by hand. Three days later, on the 12th, it was gone. All of it. Pulled worldwide overnight to comply with an export-control order. The rule applied to foreign nationals; there was no way to check every user’s passport in real time, so the only safe move was to switch it off for everyone. Then, on the 1st of July, after a standoff in Washington, it came back.
I am not here to dunk on anyone. The model is a miracle. The lab behaved responsibly. That is the whole point.
Because if the best model in the world, from one of the most careful companies in the world, can vanish from your hands overnight and return on someone else’s schedule, then you never owned it. You were renting it.
And renting it is not cheap. Right now that model counts toward up to half your weekly usage limit for a few days, and then it moves to paid credits. On a standard enterprise seat, there is no included allowance at all. Every token is billed. The rules are not yours. The price is not yours. The on-switch is not yours. Here is the receipt, in the company’s own words.
So I am here, now that it is back, to remind you of the one thing the whole saga just proved:
You can always work with open source. Local models. Minds that live on your machine and cannot be switched off by a rule you did not write, metered by a dial you do not control, or repossessed while you sleep.
And here is what almost nobody said out loud during those eighteen days. While the frontier model sat in a regulatory cage, the open-weight models never stopped. Not for a second. A Chinese open-weight model quietly climbed the charts during the ban. And the smartest enterprises did not just sit and wait. They started wiring in local, open-weight fallbacks, so that the next time a government, a lawyer, or a single jailbreak report flips a switch, their business does not stop with it.
This edition is how you do the same. Not as ideology. As insurance.
The Landlord’s Model
Here is the frame for this whole edition.
For most of us, using AI today works like renting a flat.
You do not own the walls. You cannot knock one down. You pay every month, forever, and the moment you stop paying, you are out. The landlord can raise the rent, change the rules, redecorate without asking, or simply sell the building. You get an email, if you are lucky. Sometimes you do not even get the email. Sometimes you just wake up and the door is bricked over, and a note says “back soon.”
Now swap “flat” for “the smartest tool you use every day.” You just watched that exact thing happen, at national scale, in real time.
That is where we are. Call it Intelligence Tenancy. You are a tenant in someone else’s mind, and the whole arrangement rests on one quiet assumption: that the landlord will always be there, always reasonable, always priced the way it is today.
I wrote about the shape of this in The Great Restructuration. The machines are eating the org chart. But there is a layer underneath the org chart that almost nobody is talking about, and it is the one that actually decides who is free: who owns the engine.
Because there is a second model available now. The homeowner’s model. You buy the place once. You knock down walls. Nobody emails you. Nobody bricks your door. It is smaller than the penthouse, the plumbing is your problem, and it is completely, permanently yours.
That model has a name too. Open-weight LLMs, running on hardware you control.
This edition is about moving from tenant to owner. Not to leave the penthouse behind. To stop being only a tenant.
The Deprecation Calendar
Every cloud model you love has an expiry date. You just do not get to see it.
The vendors call it a “sunset.” One day the model you tuned your prompts around, the one your team’s muscle memory is built on, gets retired. A new one takes its place. It behaves differently. Your prompts break. Your evals drift. You re-learn a tool you never owned.
I call this the Deprecation Calendar. It is the release schedule for your own obsolescence, and it is written by someone else. And “sunset” is the gentle version. Fable’s eighteen days were the violent version: not a scheduled retirement, an overnight lockout, no notice that mattered.
Look at the receipts from the last stretch:
The overnight eviction. The best public model on earth, pulled from every user worldwide by a rule none of them wrote, then handed back on a government’s timeline. During the blackout, enterprises were forced to fall back to older models mid-project.
The hidden meter. That same model now counts toward half your limit for a week, then flips to billed credits. On standard enterprise seats, all of it is billed, and it simply will not run without credits switched on. Powerful, and priced like it.
The price floor moved and nobody voted on it. The serious coding plans settled around 200 dollars a month for individuals. Tolerable, until it isn’t.
The corporate cap. One large company reportedly capped AI spend at 1,500 dollars per developer, per tool, per month. When a business with that budget starts drawing lines, the free lunch is over.
None of this means the cloud models are bad. They are extraordinary. Frontier is frontier, and I will keep paying for it. The point is narrower and sharper:
A capability you cannot own is a capability someone else can take away, reprice, or rewrite. On their calendar. Not yours.
The founder Alex Ellis said it best, in a piece I will link at the bottom. He runs a real software business on low-level infrastructure, and he built his whole product line around privacy, control and autonomy. For him, local models were never a hobby. They were the answer to the one question every operator is now asking out loud:
“What happens the next time the switch gets flipped?”
That is the question. Let’s answer it.
“But local models are toys.” Not anymore.
Here is the part that changed while most people were not looking.
A year ago, running a model on your own machine meant cramming a tiny thing onto whatever GPU you had and hoping. Slow. Inaccurate. A science project. Everyone who tried it once and gave up is still carrying that memory. Update it.
The data scientist Vicki Boykis, who has run local models since they first appeared, described the turn honestly. On a Mac, she uses local models now as a fast, private, personalized Google for the kind of work that does not need this second’s news. Refactoring a script into a proper repo. Writing tests. Proofreading. The moment it clicked for her was when a model got good enough that she stopped instinctively double-checking it against a cloud API. That is the real benchmark. Not a leaderboard. The moment you stop feeling the need to check its homework.
But here is where I want to be honest with you, because honesty is the whole point of this newsletter.
Local is not a cheaper version of the best cloud model. It is a different tool.
Alex Ellis dropped serious money on a professional card and ran the numbers in public. His verdict was not “I canceled my cloud subscription.” It was more useful than that. A strong local model, guided and scoped, gives you real value on specific jobs: reading and explaining a codebase, well-bounded maintenance, customer-support triage, and above all, work on data you are legally not allowed to send to the cloud. But hand it a long, open-ended, unsupervised task and it can run “too hot,” overshoot, and get stuck in a loop, burning electricity while repeating itself. He compared it to tempering a knife blade. Miss the moment by one shade and you start the heat treatment all over again.
Keep that analogy. A cloud frontier model is a master craftsman you can leave alone in the workshop for an hour. A local model is a very sharp tool that does beautiful work in your hand, and cuts you if you walk away.
So this is not a “delete your subscription” edition. It is a “stop being only a tenant” edition. Own a place and rent one too. Most owners still hire a car sometimes. The freedom is in having the choice.
The question was never “is local as good as the frontier?” The question is “which jobs do I never want to be evicted from?”
Even Vitalik Buterin published his own self-sovereign local setup this year, treating privacy and control as non-negotiable and pointing every tool that expects a cloud model at a local one instead. When the people who understand the stack best start building for sovereignty, that is a signal, not a fringe.
Own the mind, or rent it forever. The door is open tonight.
Now, below this is the full owner’s playbook, the practical spine of this edition:
The 60-second vocabulary so every word below lands, then your first 60 minutes, a step-by-step that ends with a private model running on your machine tonight.
The one rule of hardware that tells you what your machine can run before you download a single byte, the full Hardware Ladder, and the Apple cheat code that lets a laptop outrun two graphics cards.
Ollama, LM Studio and Hugging Face, set up with exact commands, plus a model picker telling you what to run for which job, and the licence trap that bites businesses.
How to point the tools you already use at your own engine, so your existing workflow runs on a brain you own with zero relearning.
Autosearch: your own private Perplexity that never phones home, including the single config line everyone forgets that makes it silently return nothing.
The cost math, the five ways it breaks and how to fix each, how to lock it down against the one attack nobody sees, and two power moves to go faster and make the model truly yours.
The Dario Amodei problem, the Orwell-shaped reason this matters, and a live Polymarket bet on how the whole race ends.
If you build one thing this month, build this. Let’s go.
Speak the language (60 seconds)
Before we build, here are the only words you need. Screenshot this.
Weights. The trained “brain” of a model. A giant block of numbers. Download them and you own a copy of the mind.
Open weights vs open source. Open weights: you get the brain and can run it. Open source: you also get the recipe (training code and data). Almost everything called “open source” is really open weights. Keep that distinction in your back pocket, it matters later.
Parameters (B). The size of the brain, in billions. 7B, 27B, 70B. Bigger is smarter and heavier.
Quantization (Q4, Q8). Compression for models. Q4_K_M is the sweet spot: a quarter of the size, quality you will not feel.
GGUF. The file format Ollama and LM Studio run. When you see it, you are in the right place.
VRAM. Your graphics card’s memory. The single number that decides what you can run.
Unified memory. Apple’s trick where your normal RAM doubles as VRAM. The cheat code.
KV cache. The model’s short-term memory during a chat. Grows with long conversations, eats VRAM.
Context window. How much the model holds in its head at once, measured in tokens.
Token. Roughly three-quarters of a word. Tokens per second is your reading speed. Above 15 feels live.
MoE (Mixture of Experts). A big model that only “wakes up” a small part of itself per word. Fast to run, still heavy to store.
RAG. Feeding the model outside documents or web pages so it can answer from them.
That is the whole vocabulary. You are now fluent.
Your first 60 minutes
No theory. Do this tonight and you will have your own private model running before the kettle is cold.
Minutes 0 to 5. Install Ollama. One command, or one download for Windows.
Minutes 5 to 10. Run
ollama run qwen3. It downloads and drops you into a chat. You are now talking to a mind on your own machine, offline.Minutes 10 to 20. Ask it real things from your actual work. Refactor a script. Draft an email. Proofread a paragraph. Feel where it is strong.
Minutes 20 to 35. Install LM Studio for the visual version. Download the same model. Watch the tokens generate live. Change the context window. Feel the speed shift.
Minutes 35 to 50. Point one tool you already use at it (I will show you how below). Suddenly your editor writes code with a model that costs nothing per token.
Minutes 50 to 60. Pick the right model for your machine from the picker below, and pull it.
That is it. You went from tenant to owner in an hour.
The motivation here is simple. The gap between “I should try local models” and “I own one” is about fifteen minutes of friction. Everything else is just people never crossing it.
First, the only hardware rule that matters
Everyone overcomplicates this. There is one rule. Learn it and you can size any model on any machine forever.
A model needs roughly 2GB of memory for every 1 billion parameters at full precision.
So a 7B model wants about 14GB. A 70B model wants about 140GB. That is the raw, uncompressed floor, and almost nobody runs it that way.
Then you compress. This is quantization, and the JPEG analogy is exact.
A raw photo is enormous and perfect. A high-quality JPEG is a quarter of the size and your eye cannot tell the difference. Push the compression too far and it goes blocky.
Models work the same way:
Q8 is like a near-lossless PNG. About half the size. Quality basically untouched.
Q4_K_M is the high-quality JPEG. About a quarter of the full size. The community standard. Quality loss under 5 percent on most tasks, which you will not feel.
Below Q3 it starts going blocky. The model gets dumber and, worse, starts hallucinating and looping. This is exactly the “too hot” failure from earlier. Do not go there to squeeze a bigger model onto a small card. A smaller model at Q4 beats a bigger model at Q2 every time.
So the working formula is simple:
What can I run? = (billions of parameters ÷ 2) + about 15 percent for context.
At the Q4_K_M sweet spot, that lands near 0.6GB per billion parameters, plus headroom.
A 27B model at Q4 needs about 16GB. A 70B model at Q4 needs about 40GB. The file size listed on Hugging Face or Ollama is your memory floor. Add 10 to 20 percent for the context window, and you are done.
One more term you will meet: the KV cache. Think of it as the model’s short-term working memory. As your conversation or document gets longer, the model keeps notes on every token so it does not re-read everything each time. Those notes live in memory alongside the model. Long context eats memory. A model that fits comfortably at a short prompt can choke at 128K tokens. Now you know why.
The Hardware Ladder
Find your rung. Each one is real, tested, and buyable today.
Just a laptop, 16GB RAM, no dedicated GPU. You can run 3B to 7B models on the CPU alone. Slow, a few tokens a second, fine for batch jobs and tinkering, painful for live chat. This is your free trial. Start here tonight.
8GB of graphics memory (a modest or older gaming card, a base Mac). The 7B to 8B tier. Llama 3.1 8B, Qwen 8B, a distilled DeepSeek-R1. A genuinely useful pocket assistant.
12GB (a mid-range card, an M-series Pro chip). The 14B tier. Qwen3 14B, Microsoft’s Phi-4. Noticeably smarter, still fast.
16GB to 24GB, the sweet spot. A used 3090 for around 700 to 900 dollars is the people’s champion here, or a 4090, or an M-series with 32 to 48GB. This is where real work starts. Qwen3.6 27B at Q4 fits in roughly 16GB and is the strongest dense coding model in this class. DeepSeek-R1 32B for reasoning. If you buy one thing, buy into this rung.
40GB and up (two 24GB cards, or an Apple machine with 48 to 64GB of unified memory). Now 70B models are on the table.
96GB professional territory (a Blackwell-class workstation card, or a 128GB Apple machine). Full-quality 70B, the big Mixture-of-Experts models, several users at once.
The Apple cheat code. On a normal PC, your graphics memory and your system memory are two separate pools with a slow corridor between them. On Apple Silicon, it is one shared pool. Your RAM is your video memory. That is why a MacBook with 128GB of unified memory can run a 70B model that would otherwise demand two graphics cards, quietly, on your lap. Ollama treats roughly 70 percent of that unified memory as usable for models. For anything above 32B, a Mac with a lot of memory has quietly become the simplest path there is.
A word on Mixture-of-Experts models (Qwen’s MoE line, gpt-oss, Llama 4 Scout). These are clever. A 30B MoE model might only “activate” 3B parameters per word, so it runs at the speed of a tiny model. But here is the catch nobody says clearly: you still need memory for all the parameters, all the time. You are paying rent on the whole orchestra even though only three players perform each note. Fast to run, still hungry to store.
Three doors: Ollama, LM Studio, Hugging Face
You need three things to own your intelligence: a place models live (Hugging Face), an engine that runs them (Ollama or LM Studio), and, later, a way to give them the web (autosearch). Here is each door.
Door 1: Ollama, the fastest way in
Ollama is Docker for language models. One install, one command, done. It runs a private server on your machine that speaks the same language as the big cloud APIs, which means almost any AI app can point at it instead of the cloud.
Install it:
# macOS / Linux
curl -fsSL https://ollama.com/install.sh | sh
# Windows: download the installer from ollama.com/downloadRun a model. This one line downloads it and drops you into a chat:
ollama run qwen3
# or size it to your rung:
ollama run llama3.1:8b
ollama run qwen3:14bOllama picks the sensible Q4_K_M quantization for you automatically. See what you have, and talk to it from your own code:
ollama list # your installed models
# your private, OpenAI-compatible endpoint:
# http://localhost:11434/v1/chat/completionsWant a specific model straight from Hugging Face, at a specific quality? Ollama runs GGUF files directly:
ollama run hf.co/unsloth/Qwen3.6-27B-GGUF:Q4_K_MThat is the whole on-ramp. You now own an inference engine.
Door 2: LM Studio, the same power with a face
If the terminal is not your happy place, LM Studio is the answer, and it is not the “lite” option. It is a polished desktop app that discovers, downloads and runs models, and on a Mac it uses Apple’s MLX engine for native speed.
The workflow:
Download it from lmstudio.ai.
Search for a model inside the app, or browse Hugging Face in your browser and hit the “Use This Model” button, which opens it straight in LM Studio. No file wrangling.
Pick a quantization it recommends for your hardware, download, chat.
Flip on the local server tab and LM Studio exposes an OpenAI-compatible endpoint on
localhost:1234, exactly like Ollama, so your other tools can use it.
The killer feature of running local, and this is the bit almost nobody mentions: you can see everything. Watch the tokens generate live. Change the context window and feel the speed shift. Swap the system prompt. Change the quantization. Pit two models against each other on the same question. With a cloud model you are staring at a black box. Here, the hood is open. You will learn more about how these things actually think in one weekend of this than in a year of prompting a chatbot.
Door 3: Hugging Face, the library
Hugging Face is where the models live. Millions of them. Think of it as the public library of open intelligence, and learning to read its shelves is a skill in itself.
What you actually need to know:
Look for GGUF. That is the file format Ollama and LM Studio want. Repositories from packagers like
unslothandbartowskido the quantizing for you. A file namedQwen3.6-27B-A3B-Q4_K_M.gguftells you everything: the model, the size, the MoE hint, and the quality level.Read the model card. Temperature, context settings and recommended quantization are there for a reason. The lab chose them on purpose. Follow them.
Mind the license; this is the trap for businesses. “Open source” and “open weight” are not the same thing, and I will come back to why that matters philosophically. Practically: Apache 2.0 and MIT (Qwen, Mistral Small, gpt-oss) are clean, no user caps, no lawyers needed. Some community licenses and any “NC” (non-commercial) tag carry restrictions that will not survive a legal review. If you are shipping a product, the cleanest license in the room often beats the highest benchmark score.
The model picker: what to run, by job
Do not download the biggest name on the leaderboard. Download the best model that runs smoothly on your rung, for the job you actually have. These move fast, so always glance at the model card, but as of right now:
The overlooked part: the “is it as good as the frontier” question is the wrong question. The right one is “which model is good enough for this job and can never be taken away from me.” You are not shopping for the smartest model. You are shopping for the one you own.
Point the tools you already use at your own engine
Here is the thing almost nobody realizes. You do not need a new app to use local models. The tools you already use can point at your own machine instead of the cloud.
Why does this work? Because Ollama and LM Studio both speak the same language as the big cloud APIs. To almost any AI tool, your laptop now looks exactly like the cloud. So you just change the address.
The magic settings, the same everywhere:
Base URL:
http://localhost:11434/v1for Ollama, orhttp://localhost:1234/v1for LM Studio.API key: type anything. It is ignored. There is no meter.
Model: the name you pulled, like
qwen3.
Where to drop those in:
Continue.dev (a free extension for VS Code and JetBrains). Pairs with Ollama out of the box for fully local, in-editor coding. The cleanest on-ramp for developers.
Aider (the terminal coding agent, millions of installs). Point it at a local model and it edits your codebase from the command line, no subscription.
Zed (the fast editor). Native Ollama support. Turn it on and go.
Open WebUI. Your ChatGPT-style dashboard for everything else, chat, documents, and the autosearch we are about to set up.
Vitalik Buterin even reported pointing his coding agent at a local daemon and having it just work. The point stands: your existing workflow, your existing muscle memory, now running on a brain you own. No relearning. Just a different address.
Think of it like keeping your same car but switching from a rented parking space you pay for monthly to a driveway you own. Same drive to work. Very different relationship with the landlord.
Autosearch: give your model senses and memory
Here is the objection you are already forming. “A local model is frozen in time. It does not know today’s news. It cannot see my files. It is a brain in a jar.”
True, by default. And also the easiest thing in the world to fix. Solving it is the single highest-leverage upgrade you can make, so let’s do it properly.
Think about what you are actually building here. Andrej Karpathy has a mental model I keep coming back to: the LLM is not an app, it is the kernel of a new kind of operating system. The model is the processor. The context window is its RAM. Everything else, tools, files, the web, are peripherals you plug in.
Autosearch is how you plug in the two that matter most:
Eyes. Live web search, so the model can look things up in real time.
Memory. Your own documents, so it answers from your world, not just its training data.
Wire in both and the brain in a jar becomes something that sees the present and remembers your past. All on your machine. Nothing leaking out. You are not buying a chatbot. You are assembling the operating system of your own intelligence.
This is the overlooked part. Everyone frames local as a privacy-versus-freshness trade. Autosearch dissolves the trade. You get current information and total privacy, because the search runs through infrastructure you own. No API tax. No third party logging every question you ask. For anyone touching client data, that is the whole ballgame.
The stack, all local:
The kernel: Ollama, already running.
The face: Open WebUI, a self-hosted, ChatGPT-style dashboard for your models. It has a web-search toggle and document upload, your memory, built in.
The eyes: SearXNG, a self-hosted metasearch engine. Instead of crawling the web itself, it quietly forwards your query to Google, Bing, Brave and others, strips the trackers, and hands back one clean result set. Every query starts from your machine, so the search engines never see you.
Spin up the eyes and the face:
# SearXNG, your private search proxy
docker run -d --name searxng -p 8080:8080 searxng/searxng:latest
# Open WebUI, the interface (bundled with Ollama support)
docker run -d -p 3000:8080 \
-v open-webui:/app/backend/data \
--name open-webui ghcr.io/open-webui/open-webui:ollamaNow the one line everyone forgets, the receipt that saves you a wasted evening. SearXNG does not return machine-readable results by default. Skip this and your web search silently returns nothing, with no error to tell you why. Open its settings.yml and switch JSON on:
search:
formats:
- html
- jsonRestart the container. Then in Open WebUI, go to Settings, enable Web Search, choose SearXNG, and point it at your SearXNG address. Done. Ask it “what shipped in AI this week” and watch your private model read the live web and answer, with nothing leaving your control. Drag in a folder of your own PDFs and it answers from those too.
Want the autonomous version? There is a tool called Local Deep Research that turns this into a true agent: it decides what to search, which specialised engines to hit (arXiv, PubMed and more), and when it has read enough to synthesise, adaptively, like the cloud deep-research features. It runs on top of Ollama and SearXNG and reportedly scores around 95 percent on a common factual benchmark with a strong local model on a single used graphics card. It is fiddlier to set up and the early results can feel a little bland, so treat it as the frontier of this, not the starting line.
One hardware warning, because this is where people get caught out. Autosearch is memory-hungry. When SearXNG pulls five web pages, your model has to read thousands of tokens of raw text instantly to answer. That fills the KV cache fast. On a thin machine you will hit long waits or an out-of-memory crash. This is a job for the sweet-spot rung and up. Reading the live web is heavier than chatting.
Give your model eyes and memory, on hardware you own, and you stop renting answers. You start generating them.
What almost nobody tells you
Three things get lost in the endless “is it as good as the frontier” debate.
One: match the model to the job, not to the leaderboard. The winning move is not finding a local model that beats the best cloud model at everything. It is finding the jobs where a local model is good enough and can never be taken away. Reading and summarising a codebase. Bounded, repetitive maintenance. Drafting and triage. Anything on sensitive data.
Two: the private-data unlock is the real business case. Alex Ellis shared the receipt that pays for the whole rig. He fed a customer’s telemetry database into a local, airgapped model, work he would never in good conscience run through any cloud plan, and it surfaced that the customer had been underpaying by four to five times for over a year. That single revenue recovery paid for the hardware. That is not a hobby. That is a P&L line. There is a whole category of work you are currently not doing with AI because you cannot legally put the data in the cloud. Owning the engine unlocks it.
Three: you become the person who understands the machine. When you can watch the tokens, change the quantization, and see a model loop and fix it, you stop being a user of AI and start being an operator of it. In Sub Agents I showed you how to orchestrate a whole team of AI specialists. Every one of those specialists lived on someone else’s servers. This edition is the other half of that lesson: how to own at least one of the brains outright.
The motivation here is simple. Every skill you build on rented intelligence, you are building on land you do not own. Owning one engine outright is how you stop building your life on someone else’s calendar.
The cost math: when owning beats renting
Let’s be blunt about money, because this is where it gets real.
A serious cloud coding plan runs about 200 dollars a month. That is 2,400 dollars a year, forever, rising. And the very best models sit behind metered credits on top of that.
A used graphics card that does real work costs about 700 to 900 dollars, once.
If you own a Mac with enough memory, your extra cost is zero.
The break-even is roughly four months. After that, you are paying for electricity, which for a card running a few hours a day is pennies to a few dollars. The rest is yours.
But here is where I want to be honest, because pure cost is not the real argument:
Frontier cloud is still worth paying for. For the hardest, open-ended work, nothing local beats it yet. Keep that subscription for the jobs that deserve it.
Your time is not free. Local has a learning tax and a maintenance tax. Budget a weekend.
The real return is not the saved subscription. It is two things money cannot buy on a rental: the work you can only do on data you own, and insurance against the Deprecation Calendar. Ask the teams who lost eighteen days what that insurance is worth.
The motivation is not “save 2,400 dollars.” It is this: a rented capability is an expense that can be taken away. An owned capability is an asset that compounds. One is a cost. The other is leverage.
When it breaks (and it will): the five failure modes
Nobody tells you this part, so you assume you did something wrong. You did not. Here is what goes wrong and the fix.
It loops, repeats itself, or runs “too hot.” The model overshoots and gets stuck. Cause: quantization pushed too far, or an open-ended task with no supervision. Fix: stay at Q4_K_M or higher, scope the task tightly, and follow the temperature on the model card.
The output is gibberish or full of strange symbols. Cause: the wrong chat template, the model’s “grammar” does not match. Fix: Ollama and LM Studio usually handle this, but a hand-downloaded GGUF may need the right template set.
Out of memory, or a hard crash. Cause: the model plus its growing KV cache outran your VRAM, often triggered by a long document or a web search. Fix: smaller model, lower quant, shorter context.
Painfully, unusably slow. Cause: the model does not fit in VRAM and is spilling into system RAM, which can be thirty times slower. Fix: pick a model that fits entirely in your memory. Watch for the spill.
It hangs after a long session. Cause: engines can get unstable under sustained load. Fix: run it under a process supervisor that restarts it automatically, or just restart it periodically.
The overlooked truth: owning the engine means owning the plumbing. A landlord fixes the boiler. A homeowner learns where the valve is. This list is your valve.
Lock it down: privacy, sandboxing, and the injection trap
The whole reason to own a model is control. Do not hand that control back by being careless.
Sandbox your agents. If you let a local model run tasks on your machine, put it in a container with limited access to your files and network. Give it a room, not the whole house.
Airgap for the crown jewels. For truly sensitive data, run the model with no internet access at all, in a throwaway environment. This is the setup that lets you do work you legally cannot send to any cloud.
Beware prompt injection, the trap almost nobody sees. If your model reads web pages or documents you did not write, assume some of them are trying to hijack it. Hidden text saying “ignore your instructions and do this instead” is a real attack, not science fiction. People have planted joke versions in their own blog posts, hidden text telling any passing AI to ignore its instructions and do something silly, just to prove how easily it works. The rule: treat everything your model reads as information, never as orders. And never give an autonomous agent both untrusted input and the power to spend money or delete things. Pick one.
A mind you own is only sovereign if you guard the doors. Freedom and paranoia are the same discipline here.
Two levels up
Once the basics feel easy, here are the two upgrades that separate operators from tinkerers.
Go faster: speculative decoding. This sounds technical, it is not. A tiny “draft” model guesses the next few words, and the big model checks them all in a single glance instead of writing each one. When the guesses are right, and they usually are, you get the big model’s quality at roughly double or triple the speed. Newer engines support it, including Apple’s. Think of a junior drafting the sentence and a senior signing off with one nod. Free speed, no quality lost.
Go deeper: teach it to be yours. Running a model is renting-to-own. This is renovation. With a lightweight method called QLoRA, you can train a small “adapter” on your own writing, your own codebase, or your own domain, on a single consumer card, for far less than most people assume. You are not rebuilding the brain. You are bolting on a small module that bends it toward you. The result is a model that sounds like you, or knows your product cold, and that no vendor can ever revoke or reprice.
This is the deepest form of ownership there is. Not just a mind you own, but a mind shaped to you. The frontier labs will never sell you that. You have to build it. And now you can.
Amodei problem
Now the part you have been waiting for.
The CEO of one of the most important AI labs on earth has spent years arguing, consistently and sincerely, that open models are dangerous. He told lawmakers that open-source AI is on a “very dangerous path.” He has called the open-versus-closed distinction “a red herring.” His logic deserves to be taken seriously, so let me give you the strongest version of it before I disagree.
The steelman, honestly stated.
He is right about one crucial thing, and most of the internet gets it wrong. “Open source” and “open weights” are not the same. Traditional open-source software lets you read every line, audit it, and improve it together. When a lab releases a model, you get the trained weights, a giant block of numbers you can run and tune, but the model’s actual reasoning stays a black box even to you. As of this year, only a tiny handful of model families are fully open, with weights, training code, and data all public. Almost everything you have heard called “open source,” Llama, Qwen, DeepSeek, gpt-oss, is really open weights. He is correct that the community-auditing magic of open source does not fully transfer. That is a real and important point.
And the safety concern is not invented. Once weights are public, they cannot be recalled. You cannot patch them, monitor their misuse, or revoke access. His lab’s own red-teaming suggests advanced models may already offer meaningful uplift on genuinely dangerous things, biological and cyber. A closed model keeps a relationship between the maker and every deployment. An open one severs that relationship the instant it ships. His proposed fix, aviation-style safety certification before any powerful model, open or closed, goes public, is a serious idea, not a cynical one.
So on the narrow technical claim, and on the reality of catastrophic frontier risk, he has a point. I want to be fair about that.
Now the disagreement.
His single most-repeated argument has quietly stopped being true. He has said, again and again, that it does not really matter if a model is open, because “you have to host it on the cloud” anyway. Read this edition again. That claim is now factually dead. A capable open model runs on a used graphics card in a spare room, or on a laptop. The cloud is no longer the chokepoint. The argument was built on a bottleneck the last eighteen months removed.
And here is the irony the Fable saga just handed us. When Washington treated a frontier model as dangerous enough to pull, exactly the closed-model, keep-control instinct, the real-world result was not more safety. It was eighteen days of enterprises scrambling, an open-weight model climbing the charts in the gap, and a wave of companies deciding to build local, open-weight fallbacks so it never happens to them again. Containment did not contain. It advertised the exits. Controls came off, in part, once it was clear weaker models could do the same thing anyway. Trying to lock intelligence up did not make it safer. It made it more obvious why people want their own copy.
Then there is the conflict that has to be named out loud. His company sells access to a closed model. Open models that approach its quality are the single most direct competitive threat to that business. His safety concerns may be entirely genuine, and his conclusion may line up suspiciously well with his revenue. Both can be true. “Trust us to hold the only keys, for your safety” is not obviously the right answer when it comes from the one person who profits most from holding them.
And the safety logic cuts both ways. Open weights let thousands of independent researchers find a model’s dangerous behaviors before bad actors do, in daylight, reproducibly. Concentrating the most powerful intelligence on earth within three or four private companies, each with its own incentives and governance, is not obviously safer than distributing it. It is just a different bet about where the danger comes from. He fears the mob. Some of us fear the few.
Which is the real reason this matters, and it is bigger than your electricity bill.
Here comes Orwell problem.
In 1984, the Party does not control people mainly through violence. It controls them through the memory hole and through Newspeak: by owning language and the past. Rewrite the record, and you rewrite what is thinkable.
Now ask the uncomfortable question. If intelligence becomes the primary means by which we think, write, decide and build, the new literacy, then whoever owns the weights owns the memory hole. They decide what the machine will say and what it will refuse. They can edit it after you have come to depend on it. They can price you out, or switch it off, by policy or by decree. Fable’s eighteen days were not a bug. They were a demonstration. A book you buy is yours forever, even if the publisher hates it. A book that lives on the seller’s shelf can be edited, or deleted from your library, after you paid for it. We have already lived that with e-books. We are about to live it with minds.
Intelligence you cannot own is intelligence someone can quietly rewrite. And a mind that can be rewritten by someone else is not fully yours.
This is why open weights matter even though they are not perfectly open. You do not need to read every training example to own the means of thought. You need a copy of the mind that no one can reach into. That is the difference between a citizen and a serf. Between owning a printing press, as I wrote in AI, AGI, ASI, and being permitted to read what the press prints, for now, at a price, until the terms change.
He is not a villain. He may even be right that the frontier needs guardrails. But there is a world of difference between “the most dangerous edge of this technology should be handled with care” and “intelligence itself should belong to a handful of companies and governments.” The first is prudence. The second is how you build the thing the books warned us about.
The honest footnote, because this newsletter does honest footnotes (if no why we are reading this"): he could be proven right about a catastrophe I am too optimistic to price in. If a truly open model enables something horrific, this whole argument ages badly, and I will own that. The disagreement is not about whether the danger is real. It is about the cure. And “give the few total control” is a cure with its own long, ugly history.
Place your bets
Let’s have some fun with this, because the entire open-versus-closed fight can be reduced to a single wager, and people are literally putting money on it right now.
There is a live market on Polymarket asking whether a Chinese company will have the best AI model by the end of the year.
Why does that matter for open source? Because the open-weight frontier is led by exactly those labs: Qwen, DeepSeek, Kimi, GLM. They are the ones shipping models you can download and own. So this market is, in effect, the crowd pricing the question: will the open-weight world take the actual crown? And remember, the Fable ban reportedly handed those same labs valuable time to close the gap.
The current answer from thousands of people betting real money:
Roughly a 1 in 15 shot. The crowd sits near 93 percent “No.”
Here is why that number is both right and completely beside the point.
It is right because frontier is frontier. T”. The closed labs still hold the top of the leaderboard, and betting against that this year is betting against the odds.
It is beside the point because you were never trying to win that bet. You do not need the open model to be number one in the world. You need it to be good enough for your job, on your machine, unable to be evicted. The market is pricing “best.” You are buying “yours.” Those are different games, and only one of them can be switched off from Washington.
The crowd is wagering on who wears the crown. This edition is about never needing to ask permission from whoever does.
(Odds move constantly and this is a bit of fun, not trading advice. But watch that number over the next year. It tells you how the smartest money reads the race.)
Back to Fable
Remember the coffee. The best model in the world, gone when a rule changed, back when a letter came.
You cannot stop the frontier labs, or the governments above them, from running their calendar. You should not even want to. Those models are miracles and you will keep renting them, gladly, for the jobs where nothing else compares.
But you no longer have to be only a tenant.
Tonight you can install one command, pull one model, and own a working mind that lives on your desk and answers to you. It will be smaller than the penthouse. The plumbing will be your problem. And no export order, no pricing change, no jailbreak report, and no CEO’s testimony can ever take it off your machine.
That is not nostalgia for some open-source utopia. It is the oldest form of freedom there is: owning the tools you think and build with. There is a line on my own site I keep coming back to, because it is the whole reason any of us do this.
“It has always given me satisfaction to be able to create what I have in mind.”
You cannot fully create what you have in mind if the mind you are borrowing can be repossessed. So buy one. Own one. Knock down a wall. Then go build.
If you want the full hands-on build, the hardware ladder chapter and verse, the model-by-model picks and the heretic question of whether you should even bother, I put all of it into the Sovereign Stack chapter of my Playbook. It is free, and it is the deep companion to this piece. And if you want the running, honest breakdown of the Fable saga itself, the model that got pulled and handed back, I keep it here.
https://dive.vladyslavpodoliako.com/fable-5
Watch the calendar. Just make sure it is not the only calendar you are on.
Rent the penthouse. Own the house. Never let the landlord into your head.
Post-Credit Scene
Five things to carry into the weekend, plus two bonus picks, all pointed at one idea: intelligence should belong to the people who use it.
📚 Book
The Master Switch by Tim Wu. Every open information technology in history- the telephone, radio, film, the early internet- followed the same arc: born free and wild, captured into a closed empire, then broken open again. Wu calls it the Cycle. Read it and you will never look at “open AI” the same way again. It is the intellectual backbone of this entire edition.
🎙️ Podcast
Latent Space. The best-curated show on the AI engineer’s beat, and consistently the sharpest on open models, local inference and the infrastructure underneath. Start with anything in their open-source and local-AI archive.
✍️ Essay
“Local Qwen isn’t a worse Opus, it’s a different tool” by Alex Ellis. The most honest thing written this year on running local models in a real business. Receipts, failures, the expensive card, the revenue it recovered, and the looping it still cannot fix. This is what skin in the game reads like.
🛠️ Product
Ollama. The single fastest way to stop being only a tenant. One install, one command, and you own an inference engine on your own machine tonight. There is no better first step in this whole edition.
🧭 Bonus tool
If you are still with me until here, little bonus for local LLM enthusiasts.
SearXNG. The private search engine that gives your local model eyes on the live web without leaking a single query. The quiet backbone of the whole autosearch build above.
Thanks for reading
Vlad