The pincer
Can we still run the software we choose on hardware we own? That's no longer just an architecture question; it's a political one. Frontier labs now compete with their own users, because user autonomy threatens the moat.
Collusion or not, the playbook is a pincer: lock the strongest models in datacenters behind metered APIs, and lobby that open-weight models are dangerous, even a national-security problem.
The double standard is almost funny. Microsoft's Mustafa Suleyman says it's unacceptable for Microsoft to depend on someone else's models forever; they must own the full stack. That's called “sovereignty.” When you depend on them, it's packaged as “convenience.” Anthropic's framing is subtler, but they've lobbied to restrict certain weight releases too; Amodei has been at this since his OpenAI days.
No conspiracy required; incentives suffice. And if they harden into law, nobody has to ban local AI outright. Just make distribution, insurance, financing, and operations miserable. A right that's too expensive to exercise isn't a right.
The legal collision course
This isn't hypothetical. The legal mechanism the AI lobby is going to reach for already has a name and decades of case law behind it: the distinction the courts draw under the Free Exercise Clause between an absolute right to belief and a regulatable right to action. The precedents map almost exactly onto the playbook Anthropic and Microsoft are already running.
The “neutral law” trap
In Employment Division v. Smith, the Supreme Court ruled that the government can restrict a fundamental First Amendment right as long as it does so through a “neutral law of general applicability.”
When Amodei lobbies Congress for AI safety regulations, demanding compute thresholds, mandatory red-teaming, and licenses for “frontier models,” he is designing the ultimate “neutral law.” The legislation won't explicitly say open source is illegal, or that you cannot run local models. It will say: for public safety, any computational system exceeding some threshold of operations per second must possess a federal safety certification.
Because that law applies to everyone equally, a neutral law of general applicability, the courts, following the Smith precedent, will likely uphold it. The fact that a massive corporation can afford a $50 million certification process while a local developer running a decentralized mesh network cannot is entirely legally permissible under this framework.
Code as thought vs. code as action
The Free Exercise Clause grants an absolute, untouchable right to hold a belief or opinion, but your practices and actions can be regulated, the same logic that upheld the polygamy ruling in Reynolds.
That is the exact battleground for sovereign compute. Is running a local open-weight model on your own hardware an extension of human cognition and thought, which is absolutely protected? Or is executing a script an action the government can regulate in the name of public safety?
The AI megacorps are lobbying aggressively to define model execution as a dangerous action: analogous to refining uranium or manufacturing a drug, rather than an extension of speech, thought, or mathematics. If they succeed in defining computation as an action subject to neutral safety laws, the First Amendment will not protect your local rig.
We already ran this experiment in 1761
The neutral-law trap has a founding-era case study: the writs of assistance.
Writs of assistance were general search warrants. Statutorily authorized, facially neutral, applied to every subject equally. Customs officers could enter any house, shop, or warehouse on bare suspicion, without oath, and conscript bystanders to help. In February 1761, James Otis argued against their renewal before the Massachusetts Superior Court for five hours while a young John Adams took notes (the scene at the top of this post).
Otis didn't argue against search power. He conceded that special warrants were lawful: a named officer, a specific place, sworn suspicion before a magistrate, returnable when the job was done. His attack was purely structural. The general writ was universal (anyone holding one became “a tyrant in a legal manner”), perpetual (no return, no expiry, no accountability), discretionary (entry on bare suspicion, no oath required), and transferable (one customs officer endorsed his writ over to his successor, so the court never even judged who wielded the power).
Run the mapping. Universal: blanket authority over all compute above a threshold. Perpetual: standing compliance obligations with no sunset. Discretionary: mandated telemetry instead of warranted inspection. Transferable: enforcement delegated to intermediaries like insurers, hosts, and payment processors. And the writ's power to “command all to assist” is the deputization of every platform in the stack.
Otis closed with the higher-law argument: “an act against the constitution is void.” He lost. The chief justice checked with London and issued the writs anyway. The court deferred to the statute, exactly the way Smith tells courts to defer to neutral laws today.
What actually killed the writs came in sequence. First they became practically unenforceable against a community structured to resist them. Then, two decades later, Adams hard-coded Otis's special-warrant checklist into the Massachusetts Declaration of Rights, the direct template for the Fourth Amendment. Structure bought the time; codification locked in the win. Adams's verdict on the courtroom loss: “then and there the child Independence was born.”
One honest caveat. The Fourth Amendment restrains searches, not licensing; a compute certification statute isn't a search. Where the Otis lineage bites is the enforcement layer: telemetry mandates, remote inspection, audit access. The loophole to watch is the “closely regulated industry” doctrine, which lets regulators inspect without warrants. That's the writ pattern reborn. The counter-lineage is Riley v. California, where a unanimous Supreme Court invoked the writs while putting your phone behind a warrant. Your local rig is a lot closer to Riley's phone than to a liquor warehouse, and the labs know it. That's why they'd rather win in Congress than in court.
Quotes are from John Adams's reconstruction of Otis's argument: teachingamericanhistory.org.
Why we have to harden the gates structurally
This constitutional ambiguity is exactly why we cannot rely on the legal system, open-source licenses, or First Amendment defenses to protect our hardware rights.
If we end up in front of the Supreme Court arguing that running a local Rust orchestration environment is protected speech or thought, we have already lost the war of attrition. Otis had the better argument in 1761 and lost anyway; the durable fix took a revolution and two decades of constitution-writing. The legal fight will take a decade, and in the meantime the hub-and-spoke API moats will become deeply entrenched.
Which is why the immune response has to be architectural. We have to build sovereign state management, decoupled edge agents, and decentralized mesh networks that operate outside the purview of these easily captured regulatory frameworks. If the system executes entirely locally and peer to peer, it becomes nearly impossible to enforce those neutral laws in the first place. That was step one in 1761 too. The writs didn't die in a courtroom; they died against a population that made them unenforceable. The constitutional fix came after, and only ratified what the resistance had already proven.
The defense has to be architectural
Licenses won't stop regulatory capture; the defense has to be architectural:
- Decouple orchestration from the cloud. Baseline: local CLI plus containers; commercial APIs strictly optional. I've been building Nemesis8 this way: a local control plane for containerized coding agents, with models (Ollama or frontier APIs) swappable like parts. An agent whose memory, tools, and compute a vendor can cut off isn't autonomous; it's an API customer with a business license.
- Own the state. Weights get the attention; state is the real lock-in. Memory, logs, prompts, permissions, credentials, generated files: all in formats you can inspect, encrypt, back up, migrate, and replay. The model is a replaceable engine, never the archivist.
- Make inference swappable. The next token can come from the GPU under your desk, a laptop NPU, a LAN box, rented bare metal, or a cloud API. Route by privacy, latency, and cost. An outage, policy change, or deprecation should degrade your system, never kill it.
- Harden distribution. Reproducible builds, signed manifests, pinned model hashes, mirrored repos, offline installs. If GitHub deleting your repo ends your project, it was too fragile.
- Local safety must beat cloud gatekeeping. Network-off by default, tight tool permissions, scoped file access, tamper-evident logs, hard sandboxes, a human kill switch. Safety as a property of the system, not a permission rented from a vendor.
- Build an ecosystem, not just a repo. Known-good hardware recipes, tested model bundles, paid support, shared benchmarks, business models that don't touch user data. Sovereignty only wizards can operate is a hobby.
The goal isn't to kill cloud AI. It's to guarantee that anyone who wants to create, remember, reason, or run a small business never has to do it permanently at one vendor's pleasure.
So the question isn't “is centralized AI useful?” It's “will running AI locally still be a viable right ten years from now?” What runtimes, protocols, data formats, distribution systems, and business models do we need to build today?
Built and shipped by Deep Blue Dynamics. Reach Kord at kord@deepbluedynamics.com.
// transmission ends