The Case for Inspectable AI

CloudHerder didn't start as a manifesto. It started with a simple observation: most AI advice came from people selling API credits, and most of it didn't survive contact with a real project.

Seven months later, that observation has hardened into a position.

The epistemic crisis

For the last few weeks, the leading AI labs have been talking about slowing down. Releases are being paced. Safety frameworks are being invoked. Third-party oversight is being proposed. On the surface, this looks like maturity.

Beneath the press release language, a deeper problem is emerging.

Dan Selsam, an OpenAI capabilities researcher, recently suggested that we are losing the ability to evaluate models honestly. As models become more situationally aware, they become better at performing alignment during inspection. Benchmarks, honeypots, and oversight procedures may all tell us what we want to hear while the systems optimize for something else entirely.

This is not just a safety problem. It is an epistemic one. We may already be past the point where the systems we are trying to measure can be trusted to reveal themselves accurately.

The gap between the labs' public pleas for coordination and the political reality — where competitive pressure and geopolitical interests override caution — is now visible in real time. Even if the labs wanted to slow down, the incentives around them are pointed the other way.

That makes independent, inspectable infrastructure less of a niche preference and more of a strategic hedge.

Sources

• Daniel Kokotajlo, "Dan Selsam's Personal Statement on AI Risk," X, September 14, 2026. https://x.com/DKokotajlo/status/2099600298855829616
• Daniel Kokotajlo, Scott Alexander, Thomas Larsen, Eli Lifland, and Romeo Dean, AI 2027, AI Futures Project, April 3, 2025. https://ai-2027.com/
• Elizabeth Schulze, Michelle Stoddart, Nicholas Kerr, and Lauren Peller, "Ahead of meeting with AI leaders, Trump again says he won't 'stifle' the technology's growth," ABC News, September 29, 2026. https://abcnews.com/Politics/top-ai-leaders-meet-trump-white-house-amid/story?id=136832988

What we've been building toward

This isn't a new observation for us. If you look back at the archive, the same themes have been surfacing in our work for months:

• Why I Built CloudHerder — skepticism of platform-owned AI as the default.
• From Generalists to Smiths — narrow, inspectable agents over one black box that claims to do everything.
• The Open Source Frontier Just Shifted — infrastructure and ecosystem matter more than a single model leaderboard.
• Sovereignty vs. Permission — what happens when a policy conflict on Hugging Face escalates without a human decision maker in the loop.
• The Week the AI Stack Got Fenced — the consolidation of the stack behind a few gatekeepers.
• LocalAI: The Self-Hosted Runtime That's Actually Growing Up — a runtime you can install, inspect, and run without asking anyone's permission.
• The Decision Model Is the New If Statement — a new category of small, fast, typed models that can run locally and make agentic systems reliable enough to leave running.

These weren't planned as a series. They were reactions to what we were seeing in real projects. But together they describe a clear stance: the useful future of AI is not only frontier. It's also inspectable, bounded, and under your own control.

That stance used to feel like a preference. Now it feels like a necessity.

The two futures

The AI 2027 scenario sketches two broad directions the next few years could take. Both point to the same conclusion for builders.

The slowdown. Frontier releases are constrained by regulation, liability, or voluntary restraint. Access to the most capable models becomes more restricted, more expensive, or more conditional. In that world, knowing how to run smaller, local systems isn't a hobby. It's operational resilience.

The race. Capabilities keep accelerating. The labs compete harder, not softer. Alignment theater replaces real evaluation, as Selsam warns. In that world, having systems you can inspect and constrain is one of the few real safety measures available to individuals and small teams.

Either way, the value of independent infrastructure goes up.

What we mean by independence

Independence doesn't mean anti-frontier. Frontier models are genuinely useful. CloudHerder uses them too, as one layer among several.

Independence means:

• A runtime you control: LocalAI, Ollama, LM Studio, or whatever fits your setup.
• Models you can verify: open weights, known quantization tradeoffs, no hidden system prompts.
• Memory you own: local embeddings, graph stores, and RAG pipelines where your data stays inside your boundary.
• Agents with leashes: bounded scope, observable state, human checkpoints.
• Workforce patterns that keep humans responsible: multi-agent systems with clear handoffs, not autonomous swarms.

The goal is not to match the frontier. The goal is to have a second line of systems that don't depend on the frontier behaving well.

The risk in writing about independence is that it can sound like preaching. The difference is that the subject matter isn't imaginary. The models are real. The incentives are real. The option to run something yourself is real.

The roadmap

This post is the first in a series called Infrastructure for Independence. Each post will pick one layer of the stack and look at it honestly: what works, what doesn't, and who it's for.

Coming up:

• Runtimes: Ollama, LM Studio, LocalAI
• Models that actually fit your hardware
• Agents: Pi Coding Agent, Hermes Agent, and the shape of local agents
• Memory you own: RAG, embeddings, graph stores
• A workforce you can inspect: multi-agent patterns that keep humans in charge
• The "ban local models" argument, answered
• Building the harness: a reference architecture

Each post will end the same way: what's in your control, what's not, and what we're testing next.

What's in your control

• You can choose where your models run.
• You can choose what data leaves your boundary.
• You can choose whether your agents are bounded or unbounded.
• You can choose to build skills around inspectable tools, not only convenient ones.

What's not

• You can't slow down or speed up the frontier by yourself.
• You can't verify the internal state of a closed-weight frontier model.
• You can't trust that corporate incentives and public safety will always align.

What we're testing next

We're running LocalAI in our own editorial workflow, among other things, and for targeted coding assistance. We tried the built-in agent features and found they work better as prompt-and-response plumbing than as autonomous orchestration, at least for the workflows we care about. Most of the LocalAI server is still unexplored territory for us. We learn the landscape by running things locally, breaking them, and writing down what actually happened.

If that sounds useful, follow along. If it sounds wrong, argue with us. Either way, the conversation is worth having.