Imagine hiring a contractor who bills by the minute, works autonomously, and sometimes gets stuck in circles doing the same thing over and over. That’s an AI agent. Unlike a chatbot (one question, one answer), an agent makes 3–10 LLM calls per task: planning what to do, selecting tools, executing actions, checking results, and sometimes retrying when things go wrong.

A single unconstrained agent task costs $5–8 in API fees for software engineering tasks. That’s because each task triggers multiple LLM calls, each with growing context (previous steps are added to the context window). By the 8th call in a task, the agent might be sending 30,000+ input tokens per call — and paying the quadratic scaling tax from Chapter 3.

Each step in an agent task adds to the context window. The planning output becomes input for tool selection. Tool results become input for the next step. By step 8, the agent is carrying the entire conversation history — 20,000–50,000 tokens of accumulated context. This triggers both quadratic scaling costs and potential context surcharges.

A doom loop occurs when an agent gets stuck in a retry cycle — attempting the same action, failing, and trying again without making progress. The agent keeps consuming tokens with each attempt, and the context window grows with each failed attempt’s error messages. Without guardrails, a doom loop can run for hours.

A documented incident: two LangChain agents entered an infinite conversation cycle that generated a $47,000 bill over 11 days. Another case: an agent generated 2.3 million unintended API calls over a weekend. A third: parallel agents spawning sub-calls burned through $10,000 in 4.5 days.

Max iterations: Hard cap on the number of LLM calls per task (typically 10–25). Budget caps: Maximum dollar amount per task ($10–50) and per agent per day ($100–500). Timeout: Maximum wall-clock time per task (5–30 minutes). Error detection: If the agent repeats the same action 3 times, abort and escalate to a human.

96% of enterprises report AI costs exceeding initial projections. Yet only 44% have financial guardrails in place. Fewer than 1 in 5 agent deployments have token-level cost monitoring at launch. Teams without monitoring lose $8,000–23,000/month in undetected waste — agents running unnecessary tasks, doom loops, and inefficient model selection.

Traditional cloud monitoring (CPU, memory, network) doesn’t capture AI costs because agents are autonomous and concurrent. By the time a dashboard updates showing high spend, the agent has already consumed the tokens. Effective agent cost monitoring requires pre-execution policy enforcement — checking the budget before each LLM call, not after.

Effective cost governance requires three enforcement tiers: Per-action limits (max tokens per single LLM call), per-agent budgets (max spend per agent per day), and fleet-level throttling (max total spend across all agents per billing period). Each tier catches different failure modes.

Helicone — Open-source LLM observability platform. Logs every API call with cost tracking, latency metrics, and user attribution. Integrates with OpenAI, Anthropic, and most providers via a proxy. LangSmith — LangChain’s observability platform. Deep integration with LangChain/LangGraph agent frameworks. Traces multi-step agent executions with per-step cost breakdown.

At minimum, log for every LLM call: model used, input tokens, output tokens, thinking tokens (if reasoning model), cost, latency, task ID, and agent ID. This data enables cost attribution (which tasks are expensive?), anomaly detection (is this task unusually costly?), and optimization targeting (which tasks should we route to cheaper models?).

In harness engineering (the discipline of building systems to control AI agents), cost constraints are a core component of the harness. Just as you set architectural constraints (allowed file paths, forbidden operations) and review pipelines (human approval for risky actions), you set cost constraints: max iterations, budget caps, model routing rules, and escalation triggers.

Before deploying: Set max iterations, budget caps, and doom loop detection. Enable per-task cost logging. Choose default model (budget) and upgrade model (mid-tier). Define escalation rules. After deploying: Monitor daily spend vs projections. Review weekly cost attribution. Identify tasks that consistently exceed budget. Route high-volume simple tasks to cheaper models. Compress context between agent steps.

Chapter 8 zooms out to the business level — AI FinOps, ROI measurement, and the future of AI economics. The portfolio analogy: treat AI investments like a financial portfolio, not individual bets. Why 95% of AI pilots fail to show measurable returns, and how to be in the 5% that succeed.

Agents are the most expensive AI workload: $5–8 per task, 3–10x more LLM calls than chatbots. Four cost drivers: planning, tool selection, execution, verification. Doom loops can cost $10K–47K. 96% of enterprises exceed projections but only 44% have guardrails. The 4-layer governance framework (tracking, alerts, limits, attribution) is the minimum viable cost infrastructure. Cost constraints are a core component of the agent harness.