Borrowed AI disappears overnight

A model I had picked, measured, and optimized around was retired by a notice one morning. And it wasn’t just one. The whole cheap tier disappeared, and the only survivor was the most expensive one — priced at 5x its predecessor on output.

I could control latency, I could control cost — but the base model itself was the one thing I never had a grip on. This is where supply sovereignty stands up as a third axis of judgment, alongside speed and cost.

Self-hosting isn’t just about getting it running, though. Off-the-shelf small models lost on quality (42–69% vs 94%). And the reason I could react to a six-days-left crisis at all was that I had measurement infrastructure — a way to check whether a replacement would hold up, with no human in the loop.

The first three parts were all about making performance better with my own hands. Measure, break it down, pull the lever. But no matter how much optimization I stacked up, there was one layer left that I could do nothing about: the base model itself.

What drove that home was a retirement notice, one morning.

It didn’t stop at one retirement

With a third-party AI API, models get retired (end of service). One day the model you’re using picks up an end date.

In my case, it chained. First I noticed that both the model behind the free allowance and the model behind the paid tier had end dates — next month and the month after. I scrambled to move everything onto a different model. Two weeks later, the model I had moved to turned out to have an end date too. Looking around, the whole family of models was moving toward retirement together. The situation was: pick a replacement, six days left.

Not one line of my code was broken. The problem was underneath it — the model I was borrowing as my foundation was being repossessed at the lender’s convenience. This isn’t a bug. It’s supply disappearing.

I sorted them cheapest-first, and got a chill

I lined up the models being retired in order of cost, cheapest first.

What was being retired was the cheap tier, all of it. The only survivor was the single most expensive one. And that model had been repriced to 5x what its predecessor cost.

So what I lost wasn’t quality. Quality actually goes up with the expensive survivor. What I lost was the one thing that was cheap. Every cheap option was pulled out by the roots, and what remained was a one-way ticket to the most expensive plan.

I ran a cost simulation to see what the economics look like if I served that surviving expensive model to every user. The result was unambiguous — at any realistic paid conversion rate, it’s clearly in the red. The conversion rate needed to break even jumps to several times reality (a few percent), a level where the model just breaks. Quality goes up, but at that unit price the business doesn’t work. That’s what it means for cheap to disappear.

Latency I can control. The foundation, I couldn’t.

Slowly, the real shape of it came into focus.

• Latency I can break down myself, and shrink myself.
• Cost too — trim the output, cut the waste, bring it down myself.
• But — the base model itself is something the supply side retires and reprices. There is nothing I can do.

However cleverly you stack optimizations on top of a borrowed CPU, the day the CPU itself gets repossessed, it’s over. That was the hard-to-see risk of depending entirely on a third-party API.

So I own it myself — not for speed or cost, but for “sovereignty”

In Part 2 I wrote that I wanted somewhere near and fast. But what I actually wanted was one step past that: somewhere that doesn’t disappear and doesn’t get repriced without my say.

The real motive for owning inference (self-hosting) wasn’t speed and it wasn’t cost — it was supply sovereignty: having a grip on my own foundation.

There’s a pitfall here, though. Just standing an off-the-shelf small model up yourself loses on quality. When I measured it, every off-the-shelf small model came in far below the surviving production model — especially on how natural the translation sounds as spoken language.

Why such a gap? Here’s what sits behind it. The surviving production model (served by the third-party API) is in fact a high-performance large model. The third-party inference provider puts that large model on its own high-speed inference stack (a purpose-built chip), and that’s how it delivers “large yet low-latency” — smart and fast at the same time. So for as long as I was on the third-party API, I was getting the best of both: big and fast. Move it onto a cheap GPU of your own, though, and the only way to run it fast and cheap is to make the model smaller. The moment you do, what gets sacrificed is quality — the naturalness of spoken language above all.

So “just run it yourself” isn’t enough. Fine-tune the model on your own data and turn it into a purpose-built machine — only then do sovereignty and quality coexist. The actual recipe that took that 42% to 84%, and on some tasks drew level with a giant model, is in the model-specialization series. This isn’t something you do on the side; it’s a deliberate investment (a moat).

And the economics flip, too. From usage-based billing where you pay more the more you use, to holding a GPU as a fixed cost. Past a certain scale, self-hosting is cheaper — and free of retirements and price increases (that projection, and the measured latency, are in Part 5).

Lessons

1. On top of a third-party API, the one with a grip on the foundation is the supplier. Retirements and price increases are supply-chain risks outside your control, and the cheaper the option, the sooner it disappears. Build a business on the premise that “it’s cheap right now” and the ground goes out from under you.
2. Supply sovereignty is a third axis of judgment, alongside speed and cost. But self-hosting isn’t just about getting it running — off-the-shelf small models lose on quality. Don’t buy sovereignty at the price of quality.
3. When the foundation wobbles, what pays off is measurement infrastructure. I could settle on a replacement in six days because I could confirm, with no human in the loop, that swapping it in wouldn’t drop quality.

---

Appendix: raw data