Theme: The Craft
Length: ~700 words
Hook: Analytical — put real numbers on agent failures
When software fails, the cost is usually measurable: downtime, lost transactions, SLA penalties. We've gotten good at calculating this.
When agents fail, the cost is harder to measure — and often much higher. Let's break down the failure economics.
Direct costs: the money the agent spends being wrong.
Every agent action has a cost. The LLM call to reason about the action. The tool call to execute it. The follow-up call to verify the result. If the agent makes the wrong decision, you pay for all of that — plus the cost of undoing the damage.
Example: An agent that processes refund requests decides to refund $500 to a customer who wasn't eligible. The costs:
- LLM call to reason about the request: $0.02
- Tool call to check eligibility: $0.001
- Tool call to process refund: $0.001
- The refund itself: $500
- Customer service time to reverse it: $15
- Total cost of being wrong: ~$515
- Total cost of being right: ~$0.02
- Agent A finds sources (10 sources, 2 are wrong)
- Agent B extracts claims (20 claims, 4 are based on wrong sources)
- Agent C synthesizes a report (the report has 4 incorrect claims)
- Agent D sends the report to a client (the client acts on incorrect information)
- Cost of failure: What's the worst-case outcome if this agent is wrong? ($10? $10,000? Reputational damage?)
- Probability of failure: How often does this agent produce wrong outputs? (1%? 10%? 30%?)
- Frequency: How often does this agent act? (Once a day? 1,000 times a day?)
- High cost + high probability -> human approval required before every action
- High cost + low probability -> policy gates + audit trail + alerting
- Low cost + high probability -> evaluation framework + improvement cycle
- Low cost + low probability -> monitor and ship
The failure cost is 25,000x the success cost. This ratio doesn't exist in traditional software.
Indirect costs: the trust you lose.
When a microservice returns a 500 error, users retry. They're annoyed but they understand. Software fails. It's expected.
When an agent does something wrong — sends an inappropriate email, makes a poor recommendation, accesses the wrong data — users don't just retry. They lose trust. And trust, once lost, is expensive to rebuild.
A customer who receives a hallucinated refund confirmation that gets reversed doesn't think "the agent had a bug." They think "this company can't handle my money." The trust cost is invisible on the balance sheet but visible in churn.
Compounding costs: the cascade effect.
Agents often work in chains. Agent A produces output that Agent B uses. If Agent A is wrong, Agent B builds on the wrong foundation. The error compounds.
In a multi-agent research pipeline:
The cost of the error at Agent A is small. The cost at Agent D is a damaged client relationship. Each step amplifies the error.
The framework: cost of failure x probability of failure x frequency.
To evaluate whether an agent is safe for production, multiply three numbers:
An agent that costs $100 per failure, fails 5% of the time, and runs 1,000 times a day: $100 x 0.05 x 1,000 = $5,000/day in expected failure costs. That's $1.8M/year.
An agent that costs $10 per failure, fails 1% of the time, and runs 100 times a day: $10 x 0.01 x 100 = $10/day. That's $3,650/year. Probably acceptable.
What this changes about how you build.
If you're not calculating failure economics, you're flying blind. You don't know which agents need human-in-the-loop, which need more evaluation, which need policy gates, and which are safe to let run.
The framework tells you:
Every agent in production should have this calculation documented. Not as a formality — as a decision tool.
What's the most expensive agent failure you've seen — and was anyone calculating the cost beforehand?