Gartner predicts that by 2028, AI coding costs will overtake the average developer's salary. J.P. Morgan Private Bank reports that some heavy users have already run through an entire year's AI coding budget before May 2026. For engineering leaders, the harder problem is not only the size of the bill but how hard it is to predict. A cost that can be forecast is a line in a plan. A cost that cannot becomes friction that quietly shapes how developers work.
Invoices that are larger than anyone anticipated and use restrictions that stop developers midway through a work are two seemingly unconnected ways that this friction manifests. Both result from the same discrepancy between the pricing and rationing of AI agents and their behavior.
Seat-based pricing was simple: seats times price. The open-ended nature of agentic tools' work—one task may touch a few files, while another may touch a significant portion of a codebase—broke that paradigm. According to Gartner, many vendors who switch to consumption-based licensing provide minimal insight into how tokens are counted and billed, making it impossible for businesses to predict spending or link it to results. J.P. Morgan says AI bills now resemble utility bills, with token prices up more than 60% since December 2025 on Bloomberg's LLM Token Expenditure Index.
Tokens are the units of text a model reads and writes, and both are billed. "Read" covers more than the prompt: tool instructions, every opened file, every command output and the agent's own earlier messages. An agent works in a loop, and each pass typically sends the growing history back to the model. One hour-long session can be significantly more expensive than two half-hour ones because early steps are less expensive than late ones. According to Gartner, the main culprits are ungoverned autonomy and inflated context windows. The typical challenges:
Over-reading: entire files pulled in when a small slice would do.
Unbounded retries: a failing step repeated with no stopping rule.
One model for everything: frontier pricing for routine edits.
Few teams are able to estimate the cost of a task before it begins. The context window is not a financial cap, but rather a technical one. Spending caps at the account level are arbitrary and established after the fact. In reality, the most frequent ceiling is someone realizing that a run has gone on for too long. A predetermined ceiling per task is what's lacking.
The same gap appears as usage limits. Developers are disrupted across tools and price levels by rolling caps, weekly allowances, and rate constraints, frequently in units that are difficult to convert into remaining work. The reason is structural: J.P. Morgan observes that while demand continues to rise, computing supply is limited by data center installation timeframes. Long autonomous runs, debugging sessions, and refactors are the areas where interruptions fall most heavily and unevenly. A few heavy users can block everyone else on a shared allowance since the top 1% of users use more than 600 times the tokens of the median user.
A mid-task cutoff teaches rationing and costs individuals built-up context and flow. According to J.P. Morgan, teams can spend up to $730 per engineer per month on an enterprise plan, or more than $3.5 million per month for a hypothetical 5,000-engineer organization. Gartner reports that budgets are frequently exhausted earlier than anticipated. Behavior is also distorted by consumption-focused metrics. For example, one hyperscaler removed an internal usage leaderboard after employees burnt tokens to climb it.
The less visible cost is experimentation. Speculative work, such as trying three refactoring approaches, is exactly what a meter discourages. Predictable pricing changes that, letting finance plan a line item and developers attempt ambitious runs without a personal cost risk.
Much of the cost discipline teams need can be built into the tool rather than left to individual vigilance. A few design choices help close the gap:
Flat monthly pricing with no token meter: so costs stay predictable and work does not stall because credits ran out.
Parallelism as the lever: teams choose how many jobs run at once, so throughput scales rather than spend.
A routing layer: So that matches each step to a suitable model and handles routine upkeep in the background.
Approval before anything changes: the agent shows the exact lines it plans to change, writes nothing to disk without sign-off, and ends each job with a pull request and a plain-language summary.
The trade-off is real: a flat fee works only if the vendor absorbs cost risk through routing and efficiency engineering, the same work metered customers otherwise do themselves.
The useful question is no longer how much AI coding costs, but how predictable it is, and whether a developer can start a task knowing it will finish. Teams evaluating tools should ask how usage is counted, whether it is visible per task, and what the ceiling is before work begins.