The money in AI is moving fast. So fast, in fact, that Uber burned through its entire 2026 AI budget in just four months. Individual engineer costs ranged from $500–$2,000 per month, yet no FinOps playbook existed for token-based billing. The company is now back to the drawing board, with 11% of live backend code already being written entirely by AI systems.
Uber is not some glitch in the matrix.
In just one year, artificial intelligence has migrated from the innovation budget to the operating budget. And the numbers are no longer trivial:
For a mid-sized delivery team of 100 developers, that's $180,000 annually in developer AI tooling alone. Factor in QA engineers, business analysts, product managers, and agentic pipelines running continuously in production and the real AI bill can swell to 4–5x what appears on the developer licensing line.
If your goal is to keep AI spend from spiraling beyond expectations, you have two levers:
This post is about the latter. Across conversations with 1,000+ enterprise clients, we saw that teams that control costs do so because they can see them in real time. Everything else like governance, forecasting, optimization flows from that foundation.
From our conversations, we have distilled four approaches that consistently deliver AI observability across team sizes, stack configurations, and agentic maturity levels we encounter every day.
4 strategies to track AI costs in real-time for enterprises
1. Use native AI cost tracking dashboards for tool-level visibility
Enterprise tech teams today run 30+ tools. AI tool sprawl is only accelerating. The natural instinct is to open the dashboard of your primary tools and figure out AI agent cost. Unfortunately, most platforms provide only a slice of the story:
These tools were simply not designed with cost observability as a first-class concern. A native-tool like CodeMie is and it shows up immediately in what the analytics layer actually gives you.
Rather than a flat seat cost or aggregate usage count, Codemie's native telemetry surfaces:
2. Centralize AI cost tracking across tools with Power BI
For teams with mixed tool chains, Power BI can be used to give a consolidated view of AI spend without needing custom dashboards.
You can track per-user cost for Cursor, active license counts, daily active users across both tools, and month-over-month trends. For delivery managers, this is the closest thing to a unified AI cost dashboard today. The only blind spot is Copilot, which still provides richer usage data than cost data.
BI dashboards are still a beta-stage capability but it will improve. The point is to establish the habit of pulling this data on a regular cadence rather than waiting for the perfect dashboard to exist before you start.
3. The workaround approach— How to track AI costs without native telemetry
This scenario rarely makes it into articles about AI cost tracking, but it should. For many enterprise teams, especially in regulated industries, it is the reality. Every AI tool must clear security reviews before deployment, which often means limited access to telemetry and even less visibility into actual spending.
Their first solution was to run local scripts on each engineer's machine to manually track GitHub Copilot usage. It was cumbersome, hard to maintain, and abandoned within weeks.
A custom GitHub reporting pipeline wasn't a silver bullet either. Multiple teams shared the same repositories, making it difficult to separate one team's AI consumption from the rest. Sometimes the biggest challenge isn't analyzing the data. It's getting clean, usable data in the first place.
Our solution was to reverse-engineer what data was available. Bedrock invocation logs were already flowing through Lambda into Splunk, which meant no new tooling or security review. Hidden inside those logs were the signals we needed: token counts, model IDs, and API costs and API call volumes.
The team built parsing logic to pull out those fields, map them to known Bedrock pricing models, and surface cost estimates through custom Splunk dashboards. It wasn't perfect, but it was enough to turn a black box into something measurable.
The more interesting cost, however, had nothing to do with tokens.
Because newer Copilot versions were stuck in certification, the team spent months building custom prompt libraries and AI workloads to compensate for missing features. Then the approved versions finally arrived, and much of that work became obsolete almost overnight. That engineering effort never showed up in a cost dashboard, but it was a cost nonetheless. Tooling churn has a habit of quietly draining time and budget while everyone is focused on API spend.
If log formats change or logs are rotated, the approach breaks. The right response is to use it as a stopgap while pushing the client for proper telemetry access. The broader lesson is that imperfect cost visibility built from available signals is always better than none.
Read more: Introducing Agentic Development Lifecycle (ADLC): Building and Operating AI Agents in Production
4. Utilize AI observability platforms for granular cost tracking
Langfuse is a godsend for teams running RAG pipelines, chatbots, or agentic applications connected to multiple LLMs. It offers trace-level cost visibility by instrumenting every LLM call at the application layer so you can follow a single user interaction across every AI model call it triggers.
It can surface per-model token usage, cost per interaction, and daily and monthly spend trends across every LLM your application calls. You can also configure proactive spending threshold alerts for when a cost ceiling is crossed and catch cost spikes early.
Lanfuse is powerful, but it is not a plug-and-play solution. Teams need to invest engineering effort upfront to instrument applications, maintain integrations, and tune alerts so they surface real issues instead of noise.
At scale, trace volume can become a cost factor of its own. And in regulated environments, data residency and access control requirements may add another layer of review before deployment.
Key AI cost tracking metrics every enterprise should monitor
Having dashboards is only useful if you are measuring the right things at the right granularity. These are the metrics that actually tell you what is happening:
1. Cost per person and per role
Different roles use AI very differently, and averages hide that reality. Across multiple projects, we see BAs averaging around $39 per month, DevOps engineers around $50, while developers running advanced agentic workflows with Codemie, Claude Code, and multi-tool stacks average $131. Roll all of that into a single per-seat number and you lose the signal you need for budgeting, optimization, and client reporting.
2. Cost per model
One of the easiest ways to overspend is to throw the most powerful model at every problem. Not every task needs a frontier model. Tools like Cursor's model guidance and benchmarking resources such as the Artificial Analysis leaderboard can help teams match model capability to task complexity instead of paying a premium by default.
3. Cost per use case
Code generation, documentation, code reviews, and agentic workflows all have very different cost profiles. In one project, 60–70% of AI usage came from routine work such as bug fixes and code development while heavy workflows such as new feature development only takes around 10% of usage.
4. Development costs and usage costs
If your team is building an AI-powered product while also using AI to build it, combining those costs creates confusion. Development costs should be measured against engineering productivity. Product usage costs should be measured against product economics.
5. Volume alongside cost
Cost tells you where you are. Volume tells you where you're headed. Token consumption trends tell you where costs are heading before they arrive on the invoice.
Turning Tracking Into Action
Making the ROI case to clients
Cost tracking only matters if it connects to business value. If an agent handles a task that previously took a developer 2 hours, and the agent run costs $15, the math works. But clients rarely care about cost savings alone. They want to know what happened next. Did delivery accelerate? Did throughput increase? Did the team ship more features, reduce defects, or shorten release cycles?
That's why AI costs need to be tied directly to delivery outcomes. EPAM built AI/Run to help teams make that connection. It brings together CodeMie, EliteAI, and more than 1,000 other agents with cost tracking, usage pattern visibility, and ROI measurement in a single platform.
With AI/Run, teams can track spending at the workflow level, monitor how agents perform, and connect usage data to real delivery outcomes. Instead of reporting costs in isolation, they can show exactly where AI is creating value and back ROI discussions with clear, structured data.
The result is a much stronger conversation with clients.
Rather than saying, "We spent $20,000 on AI this quarter," you can say, "We spent $20,000 on AI and reduced test creation time by 40%, increased developer throughput by 25%, and delivered two additional releases." One is a cost discussion. The other is an ROI discussion.
AI/Run gives you the infrastructure, but the discipline for cost control has to come from your team. Set a review cadence, weekly makes more sense if you're running active agentic workflows where costs can spike fast. Assign someone to own cost monitoring. Make it a named responsibility, not a shared assumption.
Costs are always on the table either quietly, because someone is accumulating them, or loudly, because a client has started asking questions. The only variable is whether you're ready to answer.
