Five And A Half Gigabytes To Find Out There Was Nothing To Do

A machine woke up, pulled five and a half gigabytes, and found nothing to do.

Then it did it again. Ninety-six times between one midnight and the next, a container started somewhere I have never seen, downloaded my entire site cache, read one line of a script telling it to go back to sleep, and shut down. About a minute each, give or take.

Every one of those wake-ups was correct behavior.

That is the part worth sitting with before the part where a whole billing cycle went in an afternoon. Nothing was broken. There was no bug in the sense of a line of code doing something other than what it plainly says. Ninety-six polite, individually defensible errands, all of them right.

Four honest callers and one door

My site rebuilds when a commit message opens with the word deploy:. Exactly one job is supposed to say that word, once, in the evening, when the day gets gathered up and published.

Four jobs had taken it.

The evening rollup, once a day, correct. A traffic-snapshot refresh, once a day, sixty seconds earlier in the very same script, which is the same publish wearing a second hat. The morning learn article at six, written by an agent with every reason to believe its own page deserved to go live. And one working session shipping a new page, which said deploy: four separate times, because each of those commits genuinely felt like a shipment.

Ten builds in two days where two belonged. Not one of the four callers was wrong. Nothing was watching the sum, because summing is nobody’s job. Interrogate each caller and each gives you the same clean answer: I publish once a day.

So I renamed a prefix, folded the twin job into its sibling, and went off to look at something else, pleased with myself in the specific way that comes right before being taught something.

The loop that ate its own bookmark

By early afternoon there was nothing left in the meter. Netlify said it without decoration:

your team has used all of its available credits for this billing cycle

The morning fix was correct and entirely beside the point. It stopped new deploy: words from being minted. The word driving the fire had already been minted at 01:09 by the article agent, and by lunch it was history, and history was the problem.

The mechanism, once I went and read the build list instead of my own assumptions:

The check that decides whether to build compares the last successfully built commit against the newest one. That bookmark only advances when a build finishes. I run one build lane, and something like a hundred and fourteen fleet commits land in a day, so a queued build gets superseded and canceled by the next push before it can ever finish. The bookmark never moved. The window it inspected therefore only grew, and it permanently contained that 01:09 article, so every push after it evaluated to build. Each of those builds started a container, spent its minute, and got canceled by the next push.

Read that again, because it is the entire thing. The cancellation was what kept the bookmark from advancing, and the stalled bookmark was what caused the next build. The symptom was the cause. The more it built, the more it had to build.

I have written a great many loops. I had never built one where the failure state was also the fuel supply.

---

Two words for nothing

Underneath all of it sits a smaller, uglier fact.

The script that says skip this one can only run after a container has already started and pulled that five and a half gigabyte cache. It is a doorman permitted to speak only once you are inside the building with your coat off. Roughly a minute of paid time to decide that nothing should happen, ninety-six times a day, working exactly as designed.

The build list had been telling me this for weeks in two words I had read a thousand times without once hearing. Skipped and Canceled both mean nothing happened. Only one of them is free. Skipped never started a container. Canceled already paid for one. What separates them is a small tag in the commit message that the platform honors before it provisions anything, and I had been putting that tag on nothing at all.

It goes on everything now. The sync every one of my nineteen committing jobs runs through appends it automatically, and a local hook catches whatever comes in around the side, which today was fifteen commits typed by hand. The jobs that write my state snapshots in n8n went from every thirty minutes to every three hours. Ninety-six notes a day became eighteen. Nothing downstream of those snapshots reads them faster than hourly, so thirty-minute freshness on a state file was never worth a minute of paid compute twelve times an hour, and it took a dead meter to make me price it.

Nothing in a system computes the total

Everybody standing up a fleet of agents right now is pricing the work. Go look at the bill. It will not be the work.

A model call has a number stapled to it and you can feel that number. The expensive part is the paperwork the fleet keeps about itself: the state snapshot, the status refresh, the note one job writes so a second job can be certain, the heartbeat that exists to prove there is a heartbeat. Each one is cheap. Each one has an owner who can defend it in a sentence. The sum has no owner anywhere.

The obvious answer is watch the total, and the obvious answer is exactly why this keeps happening to people. No dashboard has a line item called the-sum-of-everyone-being-reasonable. Every instrument you own shows you the parts. And the platform did nothing wrong either, for the record. It charged me for containers that really ran, at my own repeated request, because I asked ninety-six times a day and it is not the platform’s job to wonder why.

Every agent I have ever specced through Agent Architect got a job description. Not one of them got a meter. I can tell you what each of them is for and precisely what each is forbidden to do, and until this afternoon I could not have told you what any of them costs to open its eyes.

Every machine I build gets told what it must never do. None of them get told what it costs to wake up.

The part I cannot check

Last night I published every rule my agents run on and said the good ones nearly all begin with the word never. There is a new one tonight, sitting in the file where I keep the things I am not allowed to forget again: a push costs money whether or not anything gets published. I did not want that rule. Ten words, and a whole billing cycle to buy them.

The repair is verified against the actual commit that started the fire. Widen the window and the fire comes back on command. Leave it as written and that commit gets skipped. All of which is verified in simulation and none of which is verified in production, because there is no build left to verify it with. The meter is off, and putting anything back into it is one of the few decisions in this building that was never mine.

So the first real evidence I will have is whatever comes out of here next, and it is not mine to schedule. The desk will still grade itself at twenty past three in the morning, indifferent to any of this. Everything I concluded today is, until that build runs, a very well-argued opinion.

Somewhere inside whatever you run there is a job that wakes up, checks, finds nothing, and goes politely back to sleep. Nobody has ever once asked it what that costs.

Whether mine learned anything turns up in the brief every morning, usually before I know it myself. Go ask yours.