The model does not edit the letters. It turns the prompt into tokens, then matrices, then FLOPs. Providers usually meter that work in tokens, not FLOPs. Tokenomics (not crypto) is how energy and capital become those tokens, how teams consume them, and whether the output is worth the usage. Arena's agent-cost talk shows why a naive per-token estimator understates long sessions.
- Typing Agentivo Capital Labs does not send letters into the model. It sends a short list of token IDs.
- Those IDs become vectors, then a matrix, then FLOPs. Model providers usually meter that compute per token, not per FLOP.
- Tokenomics Foundation (Linux Foundation, draft v0.2, August 2026) treats this as energy to intelligence to value. It is not the crypto meaning of the word.
- A spend estimator that is only users × requests × tokens will miss hidden model calls, agent depth, reasoning tokens, and cache misses. Arena's heuristic is cost per task, not cost per turn.
- Token numbers in this article (152, 847, 3921) are invented for the walkthrough. A real tokenizer may split the same phrase differently.
Think of the process as a loop, not a black box:
- You send text
- AI breaks it into tokens
- Tokens become numbers
- Numbers become vectors and matrices
- Huge matrix calculations happen
- AI predicts the next token
- Repeat
Text becomes tokens
Suppose you send:
Agentivo Capital Labs
The model first breaks that string into tokens. For this walkthrough, treat it as three pieces:
Agentivoas token 1Capitalas token 2Labsas token 3
A real tokenizer might cut those words differently, including sub-word pieces. The simplified split is only there so the rest of the math is easy to follow.
Tokens become numbers
Each token has an ID in the model's vocabulary. Imagine, only for this article:
| Token | ID |
|---|---|
| Agentivo | 152 |
| Capital | 847 |
| Labs | 3921 |
So the phrase becomes a short list of IDs:
[152, 847, 3921]These numbers are mainly labels. 152 does not mathematically mean "Agentivo." It tells the model which row of its vocabulary table to look up.
IDs become vectors
The model looks up each ID in its embedding matrix. In a tiny cartoon, token 152 might map to a long list of numbers:
152 → [0.21, 0.73, -0.15, 0.42, .]Token 847 might map to:
847 → [0.18, -0.32, 0.91, 0.27, .]Token 3921 might map to:
3921 → [-0.41, 0.62, 0.15, 0.88, .]Each of those lists is a vector. In one line:
- Agentivo → 152 → [0.21, 0.73, -0.15, 0.42, .]
- Capital → 847 → [0.18, -0.32, 0.91, 0.27, .]
- Labs → 3921 → [-0.41, 0.62, 0.15, 0.88, .]
Vectors become a matrix
Stack the vectors and you have a matrix. Using a four-number cartoon:
| Token | Number 1 | Number 2 | Number 3 | Number 4 |
|---|---|---|---|---|
| Agentivo | a | b | c | d |
| Capital | e | f | g | h |
| Labs | i | j | k | l |
X = [
[a, b, c, d],
[e, f, g, h],
[i, j, k, l]
]That matrix is the three-token prompt in a form the rest of the network can multiply. Production models use much longer vectors and many more rows.
Huge matrix calculations
The model then combines that matrix with other matrices of learned weights:
X W = YThose operations run again and again across layers. Attention, feed-forward blocks, and residual paths are still matrix work under the names. This is where FLOPs show up. Every multiply and add is a floating-point operation. A long prompt, a large model, and more layers all raise that count. That is why the same short phrase is cheap compared with a long report, and why a larger model costs more to run even when the English looks the same.
Hardware still pays in FLOPs. Model providers usually meter that work in tokens. Those are not the same unit. Transformers are also stateless in the naive sense: without a cache, growing context means you re-run more arithmetic on prior tokens. Prefix or KV cache is how providers avoid recomputing activations they already have. That gap, FLOPs on the chip versus tokens the provider counts, is the rest of this article.
The model predicts the next token
After those calculations, the model produces probabilities for what should come next. After Agentivo Capital Labs, a cartoon distribution might look like this:
| Possible next token | Probability |
|---|---|
| is | 40% |
| develops | 25% |
| builds | 15% |
| focuses | 10% |
| . | . |
Suppose it chooses is. The text is now:
Agentivo Capital Labs is
Nothing in that step "understood" the firm as a legal entity. It scored tokens that often follow similar sequences in training, then sampled or picked the top one, depending on settings such as temperature.
Then it does it again
The new string goes back through the same loop. More matrix calculations. Another token, for example building. Then another. The run continues until the model emits a stop token or hits a length limit.
The big picture, in one line:
Agentivo Capital Labs → tokens → numbers → vectors → matrices → matrix calculations → next token → repeat.
When you type the name, the system does not rearrange the letters on the page. It turns them into numbers, organizes those numbers into vectors and matrices, runs a large amount of arithmetic, and uses the result to predict what should come next.
Tokenomics is not crypto tokenomics
Tokenomics Foundation is a Linux Foundation project. Draft definition v0.2 (August 2026) is about converting energy and capital into AI, then consuming that AI to drive business value. Their line is energy to intelligence to value. It sits next to the FinOps Foundation. FOCUS 1.5, with AI and token cost fields, is slated for December 2026. It is not Web3 "tokenomics."
They split the work into three domains:
- Production. Token factories. The preferred metric is cost per token: hardware cost divided by tokens produced. FLOPs per dollar and FLOPs per GPU-hour are inputs, not the scoreboard.
- Consumption. Allocation, forecasting, and FinOps for AI. Cost per call, not only cost per token, because one user action can hide many model calls.
- Value. The CFO question: did the tokens buy an outcome worth more than they cost.
Their five-layer stack (4 August 2026) is a way to stop optimizing the wrong layer:
| Layer | What it is | Why it matters |
|---|---|---|
| L1 silicon | GPUs, power, the chip | Sets the cost floor |
| L2 capacity | How much of that silicon you actually have | Queueing and utilization |
| L3 inference stack | Cache, batching, serving | Often the first large optimization |
| L4 model | Size, quantization, distillation | Quality versus tokens burned |
| L5 routing / governance | Which model, or none | Can decide not to call a model at all |
First wins, they argue, are often L3 and L5: cache and batching, then routing so a cheap path or no path handles work that does not need the frontier model.
Big-T: why the naive estimator is too small
Dan Neff (Adobe) writes Big-T notation on the same site. Demand is not just tokens. It is:
T(n · k · a)- n = requests and input size
- k = hidden model calls inside one request
- a = agent depth (tools, retries, loops)
| Form | What it describes |
|---|---|
| T(1) | One shot, bounded |
| T(log n) | Work that gets cheaper per unit as you scale |
| T(n) | Linear with input or users |
| T(n · k) | Each request fans out to hidden calls |
| T(n · k · a) | Agents add depth on top of hidden calls |
| T(∞) | Unbounded loops. Usage has no lid. |
Their worked example, not ours: summarizing ten white papers drops from about $3.04 to $0.09 (about 34×) by killing context replay, right-sizing the model, and bounding output. The pricing calculator on that page is still listed as coming soon. Do not treat a screenshot of list prices as a live estimator.
A naive spend line is:
users × requests × tokens × priceA less naive line adds the missing multipliers:
users × requests × tokens × k × a × price
+ reasoning / thinking tokens
+ cache misses
− cache hits
− compactionTokenomics' point is that a simple base understates demand. Arena's point, next, is that even a better per-token line still misses turn efficiency.
The real cost of agentic AI
Arena AI's talk The Real Cost of Agentic AI: Tokens, Caching & Context Costs Explained is the other half of that usage cost. Watch it on YouTube, or here:
The speaker's relative cartoon, not a live price sheet, is on the order of $1 input / $10 output / $0.01 cache per million tokens. Input is cheaper than output. Cache is cheapest of the three. The first turn of a chat can look like cents. Then a growing triangle appears, because each new turn replays prior turns unless the prefix is cached. Agentic tool loops multiply that back-and-forth. A cache miss after a long session (even a short "hi" after a million tokens of context) can cost a full re-prefill.
Compaction is the other hidden valve. Coding harnesses often compact around 200–300k tokens, not the advertised million-token window. After compact, you pay less per turn, but you also dropped state. Stronger models can look expensive because people stay in-session and carry context forward, not only because the per-token list price is higher. A cheap model that needs many turns can still beat a pricey model that finishes in two. Long agent sessions, in their observation, can reach hundreds of dollars and in some cases around $1,000. That is their field note, not an Agentivo Capital Labs forecast.
Arena's spend heuristic matches the Tokenomics consumption domain: estimate cost per task, use the first two or three real tasks as the sample, and refresh on a roughly seven-day window because harness and compaction changes go stale. Per-turn and per-token dashboards miss that.
Sources
- Tokenomics Foundation (definition draft v0.2, August 2026)
- The five-layer Tokenomics stack
- Big-T notation (Dan Neff)
- The Real Cost of Agentic AI: Tokens, Caching & Context Costs Explained (Arena AI)