What actually gets billed is the retry, and the underlying error never shows up on an invoice. Databricks says a misbehaving tool rarely makes the calling agent fail loudly; the agent retries, guesses and eventually routes around the problem, burning tokens the whole way [3]. From the outside the task still completes, and the cost lands in an aggregate dashboard as a token bump that reads like usage growth [4]. The load-bearing field in the gateway's trace turns out to be the session ID, which ties calls together and sits on the same span as the per-call token count [8], rather than the error string itself. Error logs give you a ranked bug list, but only the session data shows how many model calls one bad `.split()` actually bought.
The headline total is two kinds of money stapled together. Subtract the $499K token estimate from the $1.2M and the 12,000 hours are carrying roughly $701K, which implies a wait-time rate near $58 an hour [2]. Databricks does not publish that rate; it falls out of the two figures it does publish. Only the token half arrives as an invoice. The rest is about 5.8 engineer-years of waiting on a 2,080-hour year [4], and it becomes cash only if the waiting displaced work someone would otherwise have paid for.
Per bug, the average is about $71K a year [1]. The worst one ran 535 failures a day, call it 195,000 a year [3]. The cause: the Jira `issues.search` server expected a comma-separated string like `key,summary,status` for its `fields` parameter, the model sent an array because that is the semantically natural JSON type for a list of fields, and a list has no `.split()` [6][7]. That missing type check ended up costing more than any other line in the fleet.
For the $499K to transfer to your fleet, a few conditions have to hold at once. A tool has to be called hundreds of times a day before a schema mismatch turns into a five-figure item, which is a matter of volume. The wrappers have to be hand-written code sitting over SaaS APIs where a parameter's type is genuinely ambiguous, which is what the sample was, drawn from Jira and Google Drive/Docs servers in one 24-hour window [12]. And, where most shops stop, something has to already sit on the path of every tool call emitting tokens, arguments and session IDs without any per-agent instrumentation [9]. Databricks says it could not manage or even fully understand these costs before that existed [13].
The hour will get quoted [10]. The part worth copying is that the trace existed before anyone had a question, which is why the analysis was reading answers rather than schema spelunking [11]. And the design conclusion is cheap to adopt now: models guess on ambiguous inputs, so accept the variation rather than crash on it [14].
