Langfuse had ingested 31,321 observations across 1,315 traces on the main video-generation service. Every model name, every token count, every prompt label, every parent span — all correct. Every cost field: null. The dashboard that was supposed to answer "where does the money go" had never once answered it, for the entire time it had been running, and nobody had noticed because a dashboard reading $0 doesn't look broken. It looks like a quiet day.
A cost instrument that silently reads zero is not a quiet day. It's an outage in the one system whose entire job is to make outages like this visible.
The tracker that never worked
PR #1177 found two defects, and they had to land together because each one hid the other. Langfuse reserves the key total inside its costDetails object as the aggregate it actually sums and displays — any other key name gets stored as a separate custom bucket that the dashboard never reads. The pipeline's cost-reporting code had been writing to a differently-named key the entire time. Separately, the cost was being attached to the wrong span in the trace tree, so even a correctly-keyed value wouldn't have rolled up to the totals the dashboard shows. Two independent bugs, same symptom, and fixing only one would still have shown $0.
The scale of what that blindness cost is the real headline. Two separate runs made 1,555 and 844 high-resolution vision calls each, against a per-run median of seven. Nothing alerted, because the one system built to notice spend anomalies had never been capable of noticing anything. Meanwhile a separate, simpler cost-notes mechanism had quietly recorded the true number for the same 22-day window: $1,191.85. The money was never actually untracked — it just wasn't visible anywhere a human would look.
36% of the bill, reporting $0 on every call
PR #1177 fixed the bug class for Anthropic and ElevenLabs calls. PR #1185 found the same bug class had never been checked at all on fal — the single transport behind every Kling clip, lipsync pass, multi-shot bundle, split, b-roll animation, preview, and voice-create call in the product. A grep for the string "usd" anywhere in the fal integration code returned nothing. Measured against the honest cost-notes ledger for a single day — 15,170 notes, 181 runs, $1,227.51 total — fal clips alone were $443.58, or 36.1% of everything spent that day. Reported in Langfuse: zero, on every single observation, since the day #1177 shipped and the team believed the dashboard had been fixed.
That's the sharpest lesson in the whole cluster. Fixing a bug class in two of three places and believing it's fixed everywhere is itself a kind of bug — the fix needs to be verified against every vendor integration independently, not assumed to generalize just because the root cause was the same shape.
A retry that was already right, and a ladder that billed for one
PR #1179 found a vision call that retries three times whenever it comes back with an empty result — reasonable, except that on a scene whose plan never placed a product in frame, an empty box set is the correct answer, not a failure. Two of the three retries were buying the same correct nothing again, at roughly 2,981 high-resolution input tokens each, across 2,796 calls measured over 26 runs. The retry logic had no way to distinguish "the call failed" from "the call succeeded and the honest answer is nothing."
PR #1180 found the inverse failure shape on a different feature: a provider fallback ladder designed to represent multiple distinct paid attempts, where the billing call sat below every quality check on the result. A generation that failed its checks after being purchased fell back to per-scene generation — paid for once, billed for zero, then billed again as new per-scene clips. Measured impact today: $0, because the feature defaults off and the failure path hadn't fired yet in production. The PR ships the fix anyway, on the reasoning that an unmeasured bug costing nothing today is exactly the cheapest moment to close it — before the feature is on and the bug has a real dollar figure attached.
A name that meant something different from what it said
PR #1181 is a small bug with an expensive incident attached. A setting called CLIP_REDOS_PER_RUN reads as a once-per-run budget. The function that resets it actually ran at the end of every stitch pass — and re-stitching is a normal, frequent operation, triggered by a lip-sync pass, an editor's scene redo, or an editor's clip redo. Every one of those re-armed the budget from scratch. On one measured incident, a 21st clip finished rendering at $32.20; the run was cancelled 70 minutes later at $42.97, having silently re-run its entire stitch sequence a second time — three clips the budget existed specifically to refuse, purchased anyway because its name promised a guarantee its implementation didn't keep.
The $290 line item hiding inside a label nobody read
PR #1186 is the best example in this cluster of a cost leak that was visible the whole time, in a number nobody had looked at closely. anthropic:ugc-continuity was the second-largest Anthropic cost line in the product at $290.87 across 49 runs — and it should, by design, cost roughly one call per scene. The call's own label happened to carry an exchange number, which meant the ledger had been recording exactly how many times each run re-authored its continuity context, in plain sight, the entire time. Of 49 runs, 25 reached exchange 25 or higher on plans with only 10 to 17 scenes — and those 25 runs accounted for 81% of the entire line item. Worse, every single one of 27 measured runs showed calls getting about 1.85x more expensive as the exchange count climbed, because the context being resent grows with every exchange. The fix wasn't exotic — it was reading a number the system had already been recording and asking why it kept climbing instead of resetting.
That finding fed directly into one of the more interesting reversals in the cluster. An earlier decision had marked an append-only version of the same continuity mechanism DO-NOT-RETRY, on the belief that resending the full growing context at a 1.25x premium was obviously worse than periodically trimming it — a roughly 40% win, on paper. PR #1184 measured it for real on a specific fork and found the opposite: $2.54 for five calls under the trimmed approach against $0.36 under append-only, because the trim sends roughly 14,375 tokens per call against append-only's ~100,000, but the frames being authored five to eleven minutes apart meant the expensive long-context prefix was being paid for and then expiring, unread, before it could be reused. A follow-up measurement a week later (PR #1208) made it official: append-only continuity is 27.5% cheaper overall, and the prior DO-NOT-RETRY was overturned by the same kind of direct measurement that had originally justified it.
One timestamp was fine; the call next to it was not
PR #1188 started from a one-line operator question — "I turned off bbox stamping completely, why is it still here?" — and the honest answer was that the feature the operator turned off was in fact off, correctly, and contributing zero calls. The spend was coming from a different, default-on feature that happened to share a code path: a product-consistency check that locates the product in every identity panel to compare color across scenes, changing no pixels but running the same expensive vision call. Two separate features, one expensive call between them, and only one had ever been switched off. PR #1187, investigated in parallel, found a related coordinate bug: a Claude vision tier enforces two separate limits — a long-edge cap and a total visual-token cap — and the bounding-box math had only ever respected the one the team happened to have coded for, silently downscaling images wrong whenever the untested limit bound first.
Finishing the instrument, and correcting your own last round
PR #1189 closed three smaller holes specifically so the dashboard could be trusted, not just read: speech-to-text calls reporting $0 on every span despite having carried a real charge since #1177 (fixed carefully, as a cost-only note rather than a normal charge, since double-billing the ledger would have been a worse failure than the original gap); two routes that had never been traced at all; and a usage counter that structurally could never fire. PR #1190 found the single largest uncached Anthropic line in the product — a clip critic re-sending the same two product reference photographs, unchanged for the whole run, on every one of 4,724 calls, at roughly 2,350 of each call's 5,264 input tokens.
And PR #1191 is the honesty check the whole cluster runs on itself: a documentation pass that had to correct four claims, three of which the same author had written the round before — including a six-row vendor pricing table where the last three rows turned out to just be the first three doubled, cited as its own evidence for being credible. Measuring your own prior claims against reality, on a fixed cadence, catches the kind of error that confidence alone never will.
A sibling tool, the same discipline
The measurement habits built here traveled. On a sibling AI-presenter tool, a later audit (presenter-generation PR #29) found that every default clip was being priced 2.33x too high — a Kling v3 voice bind riding on an "element" was being charged the element-rate multiplier on top of the voice rate, based on a constant explicitly commented "NOT YET CONFIRMED AGAINST AN INVOICE." The correction came directly from this cluster's work: PR #1194 on the main service had already found that fal returns an x-fal-billable-units header on every response, and that fal's own documentation says that header is authoritative. Once one tool in the family learned to read the vendor's own receipt instead of a hand-transcribed rate table, the fix for a sibling tool's pricing bug was a lookup, not a new investigation.
The pattern: the instrument can fail exactly like the thing it measures
Every bug in this cluster is a variant of the same failure: a cost signal that was computed, or should have been computed, and didn't reach the place a human would look at it — a wrong key name, a call site that forgot to pass a charge, a label nobody read closely, a feature flag that looked like it governed the spend it didn't. None of these are exotic bugs. They're the same class of wiring failure that shows up anywhere a value is produced in one place and consumed in another, except here the value is money and the consequence of it silently vanishing is that the team spends weeks believing a system has been priced and verified when it's never once actually been checked. The fix isn't a smarter dashboard. It's treating the dashboard itself as a thing that can be wrong, and auditing it against the vendor's own invoice on a schedule — not once, and not assuming a fix for one vendor integration generalizes to the next one before you've actually measured it.