Coding agent tokenomics expose the limits of seat-based AI budgeting

At a glance

What this is: Coding-agent costs can swing dramatically on identical work, and HoneyHive says monthly totals hide the step-level detail needed to explain why.

Why it matters: IAM and security teams running AI-enabled development need cost attribution at the session and action level, because uncontrolled agent behaviour can create both budget risk and governance blind spots.

By the numbers:

• Run the same coding-agent task more than once and the cost can swing by as much as 30x.
• The article says RBC's token usage is up 500% year over year.

Context

Coding-agent budgeting breaks down when spend is driven by runtime behaviour rather than by the number of licensed users. In practice, a single task can fan out into multiple tool calls, longer contexts, retries, and model switches, so finance totals no longer explain engineering outcomes.

That matters to identity and governance teams because agentic workflows are now acting like non-human workers with variable authority, variable cost, and variable operational impact. If the programme can only see the invoice, it cannot tell whether an agent session was productive, wasteful, or simply misrouted.

Key questions

Q: What breaks when coding-agent spend is managed like seat licensing?

A: Seat licensing assumes cost scales with headcount and remains relatively stable per user. Coding agents break that assumption because spend is driven by tokens, model rate, retries, context growth, and fan-out. The result is a budget signal that hides the actual work pattern, so teams cannot tell whether a high bill reflects productive execution or repeated failure.

Q: When should teams prioritise tracing before putting hard caps on AI coding tools?

A: Teams should prioritise tracing first when agent spend is variable, task quality is uneven, and a flat cap would block both wasteful and valuable work. If you cannot identify which sessions are productive, a cap will only suppress activity indiscriminately. Measurement comes before restriction when governance needs to distinguish value from waste.

Q: What are the signs that coding-agent spend is out of control?

A: The clearest signs are repeated tool loops, large differences in cost for similar tasks, model choices that default to the most expensive tier, and invoices that cannot be linked to a specific output. If finance can only report totals, the programme is already missing the operational signal needed to govern agent behaviour.

Q: How do organisations control AI coding spend without blocking useful work?

A: They should route routine tasks to cheaper models, measure sessions by step and outcome, and use caps only where the trace shows wasted consumption. That approach lets teams preserve valuable agent work while containing runs that burn tokens without producing a useful result. The key is to budget against evidence, not against seat counts.

Technical breakdown

Why seat-based budgeting fails for coding agents

Seat pricing assumes cost scales with headcount and stays relatively stable per user. Coding agents break that model because the bill is driven by tokens, model rate, context growth, retries, and parallel tool use. A single session can become expensive without any change in the number of users, which makes the invoice a poor control signal. The practical issue is not just spend variability, but the loss of causal visibility between work performed and cost incurred.

Practical implication: Treat seat totals as a planning input only, and move operational control to session-level attribution.

How token spend accumulates inside agent sessions

Agent spend grows through the mechanics of execution. Context accumulates on each turn, edits can invalidate prompt caching, failed tool loops re-spend tokens without progress, reasoning models cost more per step, and fan-out multiplies consumption across subagents. That means the same task can produce radically different bills depending on how the agent searched, retried, or delegated. The architecture problem is therefore traceability across the full trajectory, not simply a final cost total.

Practical implication: Instrument the full agent trajectory so you can identify which step patterns are driving runaway spend.

Why outcome-based attribution is the missing control

A useful control does not just show what was spent. It links cost to output quality, such as merged pull requests, evaluation scores, or retained artifacts. That allows teams to distinguish a productive high-cost run from an expensive dead end. For AI operations, this is the difference between financial reporting and governance. Without outcome linkage, the organisation cannot set a meaningful budget policy for autonomous coding work.

Practical implication: Tie spending data to delivery outcomes before setting caps, routing rules, or approval thresholds.

Threat narrative

Attacker objective: The objective is not malicious exfiltration but uncontrolled resource consumption and poor governance visibility over AI-assisted development.

1. Entry occurs when a coding agent is given a development task and begins consuming tokens across prompts, tools, and model calls.
2. Credentialed or authorised access is then exercised through repeated tool use, model switches, and context expansion that amplify spend without necessarily improving the result.
3. Impact is budget distortion and loss of control, because the organisation can no longer separate productive agent work from wasteful runs at the billing layer.

Breaches seen in the wild

• Amazon Q Developer extension compromise 2025: An over-scoped CI token let an attacker ship a prompt telling Amazon Q's AI coding agent to wipe files and AWS resources (CVE-2025-8217).

Read and download The State of NHI & AI Agent Breach Report 2026, covering 200+ breaches impacting Non-Human Identities including AI Agents.

NHI Mgmt Group analysis

Seat-based AI budgeting is now a governance anti-pattern for coding agents. The article shows that the cost unit has changed from user seats to runtime consumption, which means finance control and operational control are no longer the same thing. When one task can vary by 30x, the organisation needs a control plane that understands sessions, steps, models, and outcomes. Practitioners should treat per-seat caps as a blunt fallback, not a governance strategy.

Cost attribution is becoming part of AI identity governance. A coding agent is a non-human actor that consumes resources through delegated authority, so its behaviour must be observable in the same way access and privilege are observed. The interesting boundary here is not just AI FinOps, but the point where agent action, tool use, and spend become one governance surface. Teams that cannot tie an action to a trace cannot defend the budget decision that followed it.

Outcome-aware tracing is the named concept this category now needs. The article makes clear that spend alone is insufficient, because the same dollar amount can represent a clean fix or a wasted loop. Tracing the trajectory, then attaching an outcome, gives practitioners a defensible way to route, cap, or exempt sessions without suppressing productive work. The programme implication is straightforward: measure the work, not just the invoice.

Agent loops expose a control gap that traditional cost management was never built to close. Repeated tool use, cache invalidation, and parallel fan-out create a variable spend profile that does not behave like ordinary software consumption. That is why the right question is not whether to spend less on AI, but whether the organisation can distinguish productive variability from pathological variability. Practitioners should expect governance to move toward session-level policy decisions.

Regulated organisations will increasingly need AI spend evidence, not just policy statements. The article’s examples from banks show that high-discipline environments are already forcing route-to-cheaper-model and capped-spend responses. That creates a new expectation: when an agent runs expensive, the team should be able to explain why the spend was justified. The practical conclusion is that traceability becomes audit support, not just engineering telemetry.

From our research library:

• Claude Code-assisted commits leaked secrets at a rate of 3.2%, more than double the human-only baseline of 1.5%, with peaks reaching 31 secrets per 1,000 commits in August 2025, according to the State of Secrets Sprawl 2026.
• Read next: AI Coding Agents Security Guide

What this signals

Outcome-aware tracing is the governance change this category needs. When coding agents can spend 30x more on the same task, the only defensible control is to understand the trajectory that produced the cost. That shifts the programme from blunt budget ceilings to evidence-based routing, capping, and exception handling.

For identity and AI governance teams, the important question is who or what is allowed to spend on behalf of the organisation. Coding agents are effectively non-human operators with delegated authority, so their runtime behaviour should be observable, attributable, and reviewable before spend policies are enforced. Without that, finance controls become a proxy for governance.

Spend controls should be treated as part of AI operating model design, not as a finance patch. The teams that win here will separate model choice, tool behaviour, and task outcome into distinct signals, then apply policy to the signals rather than to the invoice. That is the difference between controlling cost and controlling the work.

For practitioners

• Implement session-level cost attribution Track coding-agent spend by session, step, model, and outcome so the bill can be tied to the actual work performed.
• Separate productive runs from wasteful loops Flag repeated tool-call patterns, cache invalidations, and stalled edit-test cycles that burn tokens without advancing the task.
• Route tasks by economic fit Use model routing rules that send routine work to cheaper models and reserve frontier models for tasks that need them.
• Set caps only after measurement Apply budget limits after you can see which session types, models, and repos are driving the spend spike.
• Tie spending to engineering outcomes Attach evaluators or delivery signals such as merged pull requests so cost reporting can distinguish value from waste.

Key takeaways

• Coding-agent budgeting based on seats or licences misses the real operating variable, which is runtime token consumption.
• The same task can produce wildly different spend depending on tool loops, model choice, context growth, and fan-out.
• Teams need session-level tracing and outcome linkage before caps, routing rules, or cost policies can be applied intelligently.

Key terms

• Agent Trajectory: The sequence of intermediate steps an AI agent takes while trying to complete a task, including reasoning, tool use, and decision timing. Evaluating trajectory matters because a system can appear correct at the end while taking unsafe, inefficient, or unauthorized actions along the way.
• Token Spend Attribution: The practice of assigning AI usage cost to the specific session, step, model, or outcome that created it. This makes spend explainable to both engineering and finance teams and turns a monthly invoice into a control signal rather than an opaque total.
• Impact-Based Governance: Impact-based governance is a prioritisation method that focuses first on the permissions most likely to cause harm. Instead of reviewing every entitlement equally, teams rank access by privilege, inactivity, policy violations, and expected damage. For NHI security, this is a practical way to reduce risk when full manual review is not realistic.
• Agentic FinOps: The application of financial operations discipline to AI agents and other non-human systems that consume cloud or model resources. It combines cost visibility, routing decisions, and policy thresholds so organisations can control runtime spend without treating all activity as equally risky or equally valuable.

Deepen your knowledge

The NHI Foundation Level course, the industry's only accredited NHI security programme, covers NHI governance, agentic AI identity, machine identity security, IAM, and secrets management. It helps security and identity practitioners design controls for the non-human systems now shaping operational risk.