A cold-start fallback wrote 17,000 rows while the real handler never ran | Silent Wiring

Kimi K3's weights went up on Hugging Face on 26 July. The model itself had launched ten days earlier, hosted only. The weights are the part that changes things.

The benchmark arguments have already started, and I'm going to skip them. They'll be settled by people with more GPUs than me, and in six weeks something else will have shipped anyway.

The part that seems least in dispute is the part that changes things: the weights are on your disk, and they run on your hardware.

Think about what that removes. Not capability: friction , and a particular kind of it. Until now, putting an autonomous agent into production usually meant your data left the building. That tends to summon people. A security review. A data-processing agreement. Someone in procurement. An API key that somebody had to provision and could take away again.

None of that was fast, and none of it was fun. But notice what it quietly did. To get through it, you had to describe the system out loud. What it reads. What it writes. What it touches when it fails. You had to put that in a document and hand it to someone who was going to read it.

That gate was never checking whether your agent worked. It was asking whether the data was allowed to leave, which is a different question. But it forced a description, and a description is most of what makes a system legible to the people responsible for it.

Weights on your own hardware remove the boundary. Which is good; it's the reason a lot of us wanted this. It also removes the description, and I don't think anything has replaced it yet.

So here's roughly what the next few months look like. Agents get stood up by people who no longer need to ask anyone. The backend engineer who wires one into the deploy pipeline over a weekend. The data team that leaves one watching a queue. The platform group that quietly replaces three cron jobs with something that reasons about them. Not reckless people: ordinary people doing the ordinary thing, which is shipping.

And nearly all of that is new integration code. Handlers. Subscriptions. Producers and their consumers. Fallback paths for when the main path doesn't run. Most of it written by the model itself, reviewed by a person who reads the diff but not the seam, merged on a Tuesday afternoon.

Multiply that out. That's the wave.

Now: when that goes wrong, what does it look like?

You already have an answer ready, and I think it could be the wrong one.

Ask most engineers and you get the loud failures. The model hallucinates. The agent deletes something it shouldn't. The endpoint times out at 3 a.m. and the pager goes off. These are real, they're bad, they're well covered, and they share one enormous mercy that few of us ever think to be grateful for.

You find out.

There's a second category, and I'd argue it's the one more likely to cost you. It doesn't crash. It doesn't throw. It never pages anyone at 3 a.m., in either direction, and that is precisely the problem. It tends to pass your test suite. Not by luck. By construction.

I know that category is real because I shipped one. It ran in production for two months while I looked at the evidence of it most weeks and concluded, every time, that everything was fine.

Two months of a number I was proud of

Since 2023 I've been building the plumbing between AI models and the things that use them: 1.1 million lines of production code across two complete builds. The kind of system where the real question isn't does the code compile. It's does the data actually flow.

We ran a calibration engine. Its job was to measure whether our AI's confidence scores meant anything: when the model says it's 80% sure, is it right 80% of the time? Boring, important, the kind of internal instrument you build once and then trust.

It had been writing records for two months. Right table. Right format. Right timestamps. One row roughly every five minutes, right on schedule. Over seventeen thousand of them.

The handler that was supposed to write those rows never fired. Not once. In two months.

A cold-start fallback (a safety net, built for first boot when there's no history to average yet) had quietly become the only thing writing to that table. It had nothing real to compute, so it did what a moving average does when the input stops: it decayed. Smoothly. Plausibly. It drifted downward for about a month, much the way a real instrument settles as it finds its level, and then it died in place and stayed there for thirty-three more days.

Here's the part that should bother you more than the two months.

Every value in that table was different from every other value. Ten thousand distinct numbers. Nothing wrote a constant. Nothing wrote a default. If you'd gone hunting for the obvious tell (a column full of the same figure, a flatline, a suspicious round number), you'd have found variety, nodded, and closed the tab. Every freshness check we had...