The Model Was Never the Moat

2026-09-01

A frontier API charges you for three things: a model at the edge of what is currently possible, the infrastructure to serve it reliably, and the convenience of not having to run anything yourself. Only the first of those was ever going to get cheap fast, and it has. The other two are real costs that are not going away. This piece is about what changes once you separate those three things instead of treating “the model” as one indivisible, permanently scarce thing.

Intelligence is not the scarce input anymore

Two numbers, from two independent sources, say the same thing from different directions.

Neither number says frontier models stopped mattering. Being four months behind the frontier is a real, measurable gap, and for some work it is decisive. What both numbers say together is that the gap between “the best available” and “freely available” has compressed from something like a permanent structural advantage into something closer to a release cycle. A model you can download and run yourself is not a downgrade from the frontier anymore. It is a few months behind it, and the frontier itself is what is expensive to stay at, not the ability to get close to it.

What you are actually paying an API for

Once capability is not the scarce part, it is worth being precise about what a frontier API bill actually buys, because it is not “access to intelligence” anymore:

• Being at the edge, right now. Four months of lead time is a real product for some use cases, and someone has to pay to stay there.
• Uptime, rate limits, and infrastructure someone else operates. Running a model yourself means you now own that.
• Not having to choose, configure, or run anything. A real cost, just not an intelligence cost.

None of those are nothing. But none of them are the thing “AI is expensive” usually gets blamed on, which is the model itself. That part is the part that got 280 times cheaper.

The Zero-Dollar AI Stack went through what this looks like concretely in Zorp: the same binary, the same evidence record, against a frontier API or a model running on your own GPU, with the same ZORP_BASE_URL swap either way. This post is about why that design choice was the right bet, not just a nice option: it was betting that the model would stop being the part worth gatekeeping, and the two numbers above are the receipts for that bet having already paid off.

So what is Zorp actually building, if not a model

This is worth being exact about, because the honest answer is not “a proprietary layer on top.” Zorp is MIT licensed, all of it, including the evidence store. The memory layer, open-context, is a separate MIT-licensed project connected over MCP, not a component kept closed to create a moat. If commoditized intelligence is the premise, building a walled garden around a thin wrapper would be a strange way to respond to it, and also not what the code in the repository actually does.

What is not commoditized, and is not really a licensing question at all, is the specific shape of the loop: four capabilities, a human checkpoint before each one, a hypothesis and a kill threshold committed before evidence is gathered, and an evidence record that every claim in the final answer has to resolve back to.

Anyone can read this code and build their own version of it. That is the point, not a gap to be closed later. The hard part was never hiding the mechanism. It was designing a mechanism where a human commits to what would prove the investigation wrong before a model generates a single token, so that a fluent answer and a defensible one are not the same thing by default:

hypothesis = "Replacing Kafka with NATS cuts p99 publish latency"
metric      = "p99_publish_latency_ms"
threshold   = { direction = "decrease", min_delta_pct = 20 }
registered  = "2026-08-11T09:14:22Z"
sha256      = "e3b0c44298fc1c149afbf4c8996fb924..."

Commoditized intelligence makes this more valuable, not less. A model that generates a fluent, confident-sounding answer in two seconds instead of twenty does not make that answer more trustworthy. It makes it cheaper to produce an untrustworthy one at scale. The Investigation Tax laid out six independently sourced numbers on what that costs organizations already, before generation got any cheaper: research productivity falling even as research effort rises, most researchers unable to reproduce even their own earlier work, decision quality and decision speed not actually trading off the way people assume. None of that gets fixed by a faster or cheaper model. It gets fixed, if it gets fixed, by a structure that makes verification cheaper too, which is a design problem, not a scaling problem.

The actual claim, stated plainly

Intelligence got commoditized. That is a real, measured, two-source- verified fact, not a slogan, and it changes what is worth building. It does not mean the underlying technology was “free” all along, and it does not mean a memory layer or an evidence store is worth more by being locked away. It means the four-month gap and the 280x price drop already did the work of making raw generation cheap. What is left to build, and what actually determines whether an answer is worth trusting, is the part that was never about the model in the first place: whether the claim can be traced back to evidence a human can check.

That is what Zorp is building. Not faster answers. A shorter distance between an answer and the record that has to back it up.

Where this actually is

Zorp is pre-alpha, the same honest status every piece on this site has led with. The four-capability loop above is built and tested; the evaluation that would let anyone compare a Zorp-produced answer against a plain model’s, on accuracy or groundedness rather than architecture, is not built yet. The code is public and MIT licensed, so the loop above, the kill threshold sample, and everything this post claims about how the pieces fit together can be checked against the repository directly.