AI tokenomics needs span-level telemetry, not spreadsheet forecasts

At a glance

What this is: This article argues that AI tokenomics for agentic systems must be measured from production telemetry because single-call spreadsheets miss the multi-step work that drives real token spend.

Why it matters: For IAM and NHI practitioners, the governance lesson is that observable runtime activity matters more than forecast assumptions when cost, attribution, and accountability depend on per-span execution data.

Context

AI tokenomics is the discipline of measuring how AI systems consume and convert tokens into value. In agentic systems, the core problem is that cost no longer maps cleanly to one prompt and one completion, so spreadsheet forecasts become structurally incomplete.

The governance gap is attribution. When retrievals, retries, tool calls, and sub-agent runs all contribute to cost, teams need operational telemetry that ties spend to a specific agent, step, tenant, and outcome. That is a measurement problem, not a finance spreadsheet problem.

This matters to identity and access programmes because agentic systems behave like non-human actors with runtime behaviour that must be observed and attributed, even when the immediate issue is cost rather than access control.

Key questions

Q: What breaks when AI tokenomics is modeled with spreadsheets instead of production telemetry?

A: Spreadsheets break when they assume one request equals one model call. Agentic systems fan out into retrievals, retries, tool calls, and sub-agent steps, so the real cost lives in the trace. Without production telemetry, teams can see the invoice total but cannot explain which agent, step, or tenant created the spend.

Q: Why do agentic systems make token cost harder to predict in production?

A: Because the work is no longer linear. A single user request can trigger a decision tree of model calls, fallback paths, and internal reasoning that changes total token use from one run to the next. Predictability improves only when teams measure the actual execution path, not the simplified design assumption.

Q: How do teams know whether token spend is actually producing value?

A: They need both cost and outcome in the same model. Cost per run is only half the picture. Pairing that number with a result signal such as a resolved ticket or merged pull request shows whether a more expensive run produced more useful work, which is the real management question.

Q: How should organisations attribute AI spend when usage is spread across tools and agents?

A: Start by tagging AI activity at the interaction level, not just the infrastructure level. Track team, environment, workload, and model path so finance can separate training, inference, and embedded usage. If one request can trigger many model calls, attribution has to follow the workflow, otherwise showback and chargeback will both misstate who used what.

Technical breakdown

Why single-call token forecasts fail for agentic systems

A single-call forecast assumes one request becomes one model invocation and one response. Agentic systems break that assumption because a single user request can trigger retrieval, retries, model fallback, tool execution, and sub-agent work before the final answer appears. Each of those steps consumes tokens, so the correct cost unit is the run, not the prompt. If the model only prices visible input and output, it misses hidden reasoning tokens and fan-out effects that are billed but not obvious in the response.

Practical implication: Model token cost at the run level, not the request level, so multi-step agent behaviour is not flattened into a false single-call estimate.

Why span-level telemetry is the right accounting unit

A span is one discrete unit of work inside a trace, such as an LLM completion, retrieval, or tool call. Span-level telemetry lets teams assign token counts, model choice, price, and outcome to each step as it happens. That matters because cost drift, cache effects, and routing changes alter the true price of the same workflow over time. Without span capture, teams can total invoices but cannot explain which step produced the spend or whether a change improved efficiency.

Practical implication: Instrument each span with token counts, model identity, resolved price, and outcome so cost can be reconstructed after execution.

How agent observability closes the cost attribution gap

Agent observability has to join gateway-side and agent-side records because gateways only see calls that pass through them, while agents see sub-agent calls and internal loops that bypass central metering. That joined view is what exposes the full hierarchy of agent behaviour. Once the telemetry is stitched together, cost can be rolled up from span to trace to agent and then linked to the business result, such as a resolved ticket or completed pull request.

Practical implication: Correlate gateway logs with agent traces so the full execution path is visible before you use the data for budgeting or chargeback.

NHI Mgmt Group analysis

AI tokenomics becomes a governance problem once agentic systems move into production. The article shows that cost cannot be managed from static forecasts when one request expands into a chain of model calls, retries, and tools. The broader lesson is that runtime behaviour must be measured where it happens, because that is where attribution and accountability begin. Practitioners should treat token telemetry as an operating control, not a finance afterthought.

Span-level telemetry is the named concept that matters here. It is the only measurement unit that preserves the relationship between a request, the work performed, and the outcome produced. That creates a more defensible basis for cost governance than invoice totals or spreadsheet assumptions. In identity and agent governance terms, the same logic applies to any non-human runtime actor whose behaviour is only understandable at execution time. Practitioners should design for traceability, not estimate for convenience.

Token spend and token value are different management variables. The article is right to separate what a provider bills from what a workflow returns. A cost-only model can show overruns without showing whether the spend was justified by the result, which leaves optimisation decisions incomplete. That distinction matters for AI governance because the programme needs both expenditure control and outcome measurement. Practitioners should pair telemetry-based cost attribution with outcome signals before making scaling decisions.

Agentic systems expose the limits of spreadsheet-era control thinking. Static models assume the work is predictable, but agent behaviour changes with routing, retries, cache hits, and model selection. That makes the control boundary the live trace, not the planning sheet. For NHIMG, the strategic takeaway is simple: where runtime systems are dynamic, governance has to move closer to execution. Practitioners should build controls around observed traces and spans, not around intended design alone.

What this signals

Span-level telemetry is the control boundary for agentic cost governance. Once agent behaviour fans out across retrieval, reasoning, and tool use, a forecast can only guess at spend. A trace can show where the cost actually accumulated, which is why the measurement layer has to move closer to execution.

AI governance now has a finance dimension that cannot be separated from runtime observability. Teams that cannot attribute spend by agent, step, and outcome will struggle to explain whether a workflow is efficient or merely expensive. The practical implication is that cost governance and agent observability need to be designed together, not treated as separate programmes.

For practitioners

• Instrument token spans at runtime Capture input, output, and reasoning tokens for every span as the run executes, along with the agent, tenant, model, and outcome.
• Resolve pricing at request time Store the unit price used for each span when the request is processed so later provider pricing changes do not rewrite historical cost.
• Join gateway and agent telemetry Correlate gateway logs with agent-side traces so sub-agent calls and internal tool loops are included in the cost model.
• Attribute cost to the business outcome Roll up span costs to the trace, then tie each run to a concrete outcome such as a resolved ticket, merged pull request, or completed workflow.
• Compare spend against value per token Recalculate value per token after any change to caching, model routing, or prompt structure so optimisation is judged by outcome, not cost alone.

Key takeaways

• Agentic systems break single-call cost models because one user request can expand into multiple paid steps before any answer is returned.
• Production telemetry is the only reliable way to attribute token spend to the agent, step, tenant, and outcome that created it.
• Teams should pair cost attribution with outcome measurement so token optimisation is judged by value, not just by a lower invoice.

Key terms

• AI Tokenomics: AI tokenomics is the study of how tokens are generated, consumed, priced, allocated, and converted into value across AI systems. In practice it is a measurement discipline that links model usage to both economic cost and workflow outcome, especially when agentic systems create multi-step consumption patterns.
• Span-Level Telemetry: Span-level telemetry records the smallest meaningful unit of work inside an AI run, such as one model call or tool invocation. It lets teams trace cost, retries, and behaviour back to the exact step that created them instead of relying on aggregate totals.
• Agentic Hierarchy: An agentic hierarchy is the layered structure of AI execution, from individual spans to traces, sessions, and application views. It matters because cost, risk, and policy decisions often happen at the span level, while governance decisions are made higher up the stack.
• Token Spend: Token spend is the amount of model output and input consumed by an AI workload, usually translated into cost. It is useful for budgeting and monitoring, but it does not prove usefulness. Mature teams pair token spend with delivery, quality, and workflow metrics to understand real return on investment.

Deepen your knowledge

NHI Foundation Level course, the industry's only accredited NHI security programme, covers NHI governance, agentic AI identity, and workload identity. It helps practitioners connect runtime visibility and identity control across the systems their programmes now have to govern.