TL;DRResumen
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.El modelo no edita las letras. Convierte el prompt en tokens, luego matrices, luego FLOPs. Los proveedores suelen medir ese trabajo en tokens, no en FLOPs. Tokenomics (no cripto) es cómo la energía y el capital se vuelven esos tokens, cómo los equipos los consumen y si el resultado vale el uso. La charla de Arena sobre costo de agentes muestra por qué un estimador ingenuo por token subestima las sesiones largas.
Key Takeaways
- 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:
Agentivo as token 1Capital as token 2Labs as 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 = Y
Those 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 × price
A less naive line adds the missing multipliers:
users × requests × tokens × k × a × price
+ reasoning / thinking tokens
+ cache misses
− cache hits
− compaction
Tokenomics' 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
TL;DRResumen
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.El modelo no edita las letras. Convierte el prompt en tokens, luego matrices, luego FLOPs. Los proveedores suelen medir ese trabajo en tokens, no en FLOPs. Tokenomics (no cripto) es cómo la energía y el capital se vuelven esos tokens, cómo los equipos los consumen y si el resultado vale el uso. La charla de Arena sobre costo de agentes muestra por qué un estimador ingenuo por token subestima las sesiones largas.
Puntos clave
- Escribir Agentivo Capital Labs no manda letras al modelo. Manda una lista corta de IDs de token.
- Esos IDs se vuelven vectores, luego una matriz, luego FLOPs. Los proveedores de modelos suelen medir ese cómputo por token, no por FLOP.
- Tokenomics Foundation (Linux Foundation, borrador v0.2, agosto 2026) trata esto como energía a inteligencia a valor. No es el sentido cripto de la palabra.
- Un estimador de gasto que solo es usuarios × solicitudes × tokens se pierde llamadas ocultas al modelo, profundidad de agente, tokens de razonamiento y fallos de cache. La heurística de Arena es costo por tarea, no costo por turno.
- Los números de token de este artículo (152, 847, 3921) están inventados para el recorrido. Un tokenizer real puede partir la misma frase de otro modo.
Piensa el proceso como un ciclo, no como una caja negra:
- Envías texto
- La IA lo parte en tokens
- Los tokens se vuelven números
- Los números se vuelven vectores y matrices
- Ocurren cálculos enormes de matrices
- La IA predice el siguiente token
- Se repite
El texto se vuelve tokens
Supón que envías:
Agentivo Capital Labs
El modelo primero parte esa cadena en tokens. Para este recorrido, trátalo como tres piezas:
Agentivo como token 1Capital como token 2Labs como token 3
Un tokenizer real puede cortar esas palabras de otra forma, incluso en subpalabras. La división simple solo sirve para que el resto de la matemática se siga fácil.
Los tokens se vuelven números
Cada token tiene un ID en el vocabulario del modelo. Imagina, solo para este artículo:
| Token | ID |
|---|
| Agentivo | 152 |
| Capital | 847 |
| Labs | 3921 |
Así la frase se vuelve una lista corta de IDs:
[152, 847, 3921]
Estos números son sobre todo etiquetas. 152 no significa matemáticamente "Agentivo". Le dice al modelo qué fila de su tabla de vocabulario consultar.
Los IDs se vuelven vectores
El modelo busca cada ID en su matriz de embeddings. En un dibujo chico, el token 152 podría mapear a una lista larga de números:
152 → [0.21, 0.73, -0.15, 0.42, ...]
El token 847 podría mapear a:
847 → [0.18, -0.32, 0.91, 0.27, ...]
El token 3921 podría mapear a:
3921 → [-0.41, 0.62, 0.15, 0.88, ...]
Cada una de esas listas es un vector. En una línea:
- 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, ...]
Los vectores se vuelven una matriz
Apila los vectores y tienes una matriz. Con un dibujo de cuatro números:
| Token | Número 1 | Número 2 | Número 3 | Número 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]
]
Esa matriz es el prompt de tres tokens en una forma que el resto de la red puede multiplicar. Los modelos de producción usan vectores mucho más largos y muchas más filas.
Cálculos enormes de matrices
El modelo combina esa matriz con otras matrices de pesos aprendidos:
X W = Y
Esas operaciones corren una y otra vez a través de capas. Atención, bloques feed-forward y caminos residuales siguen siendo trabajo de matrices con otros nombres. Ahí aparecen los FLOPs. Cada multiplicación y cada suma es una operación de punto flotante. Un prompt largo, un modelo grande y más capas suben esa cuenta. Por eso la misma frase corta es barata frente a un informe largo, y por eso un modelo más grande cuesta más de correr aunque el español se vea igual.
El hardware sigue pagando en FLOPs. Los proveedores de modelos suelen medir ese trabajo en tokens. No son la misma unidad. Los transformers, en el sentido ingenuo, también son sin estado: sin cache, más contexto significa repetir más aritmética sobre tokens previos. El cache de prefijo o KV es cómo los proveedores evitan recomputar activaciones que ya tienen. Esa brecha, FLOPs en el chip frente a tokens que cuenta el proveedor, es el resto de este artículo.
El modelo predice el siguiente token
Después de esos cálculos, el modelo produce probabilidades de lo que debería seguir. Después de Agentivo Capital Labs, una distribución de dibujo podría verse así:
| Posible siguiente token | Probabilidad |
|---|
| is | 40% |
| develops | 25% |
| builds | 15% |
| focuses | 10% |
| ... | ... |
Supón que elige is. El texto ahora es:
Agentivo Capital Labs is
Nada en ese paso "entendió" a la firma como entidad legal. Puntuó tokens que suelen seguir secuencias parecidas en el entrenamiento, y luego muestreó o tomó el de arriba, según ajustes como la temperatura.
Luego lo vuelve a hacer
La cadena nueva entra otra vez al mismo ciclo. Más cálculos de matrices. Otro token, por ejemplo building. Luego otro. La corrida sigue hasta que el modelo emite un token de paro o llega al límite de longitud.
El panorama, en una línea:
Agentivo Capital Labs → tokens → números → vectores → matrices → cálculos de matrices → siguiente token → repetir.
Cuando escribes el nombre, el sistema no reacomoda las letras en la página. Las convierte en números, organiza esos números en vectores y matrices, corre una cantidad enorme de aritmética y usa el resultado para predecir qué debería seguir.
Tokenomics no es tokenomics cripto
Tokenomics Foundation es un proyecto de la Linux Foundation. El borrador de definición v0.2 (agosto 2026) trata de convertir energía y capital en IA, y luego consumir esa IA para generar valor de negocio. Su línea es energía a inteligencia a valor. Trabaja junto a la FinOps Foundation. FOCUS 1.5, con campos de costo de IA y tokens, está previsto para diciembre 2026. No es el "tokenomics" de Web3.
Dividen el trabajo en tres dominios:
- Producción. Fábricas de tokens. La métrica preferida es costo por token: costo de hardware dividido entre tokens producidos. FLOPs por dólar y FLOPs por hora de GPU son insumos, no el marcador.
- Consumo. Asignación, pronóstico y FinOps para IA. Costo por llamada, no solo costo por token, porque una acción del usuario puede esconder muchas llamadas al modelo.
- Valor. La pregunta del CFO: ¿los tokens compraron un resultado que vale más de lo que costaron?
Su pila de cinco capas (4 de agosto de 2026) sirve para no optimizar la capa equivocada:
| Capa | Qué es | Por qué importa |
|---|
| L1 silicio | GPUs, energía, el chip | Fija el piso de costo |
| L2 capacidad | Cuánto de ese silicio tienes de verdad | Colas y utilización |
| L3 stack de inferencia | Cache, batching, serving | Suele ser la primera gran palanca |
| L4 modelo | Tamaño, cuantización, destilación | Calidad frente a tokens quemados |
| L5 ruteo / gobierno | Qué modelo, o ninguno | Puede decidir no llamar a un modelo |
Los primeros aciertos, argumentan, suelen ser L3 y L5: cache y batching, luego ruteo para que un camino barato o ningún camino atienda lo que no necesita el modelo de frontera.
Big-T: por qué el estimador ingenuo se queda corto
Dan Neff (Adobe) escribe la notación Big-T en el mismo sitio. La demanda no son solo tokens. Es:
T(n · k · a)
- n = solicitudes y tamaño de entrada
- k = llamadas ocultas al modelo dentro de una solicitud
- a = profundidad de agente (herramientas, reintentos, ciclos)
| Forma | Qué describe |
|---|
| T(1) | Un disparo, acotado |
| T(log n) | Trabajo que se abarata por unidad al escalar |
| T(n) | Lineal con la entrada o los usuarios |
| T(n · k) | Cada solicitud se abre en llamadas ocultas |
| T(n · k · a) | Los agentes suman profundidad encima de esas llamadas |
| T(∞) | Ciclos sin tope. El uso no tiene tapa. |
Su ejemplo trabajado, no el nuestro: resumir diez white papers baja de unos $3.04 a $0.09 (unas 34×) al cortar la repetición de contexto, ajustar el tamaño del modelo y acotar la salida. El calculador de precios de esa página sigue como "coming soon". No tomes una captura de precios de lista como un estimador en vivo.
Una línea ingenua de gasto es:
usuarios × solicitudes × tokens × precio
Una línea menos ingenua suma los multiplicadores que faltan:
usuarios × solicitudes × tokens × k × a × precio
+ tokens de razonamiento / thinking
+ fallos de cache
− aciertos de cache
− compactación
El punto de Tokenomics es que una base simple subestima la demanda. El de Arena, a continuación, es que incluso una mejor línea por token sigue perdiendo la eficiencia por turno.
El costo real de la IA agente
La charla de Arena AI The Real Cost of Agentic AI: Tokens, Caching & Context Costs Explained es la otra mitad de ese costo de uso. Véala en YouTube, o aquí:
El dibujo relativo del speaker, no una hoja de precios en vivo, es del orden de $1 de entrada / $10 de salida / $0.01 de cache por millón de tokens. La entrada es más barata que la salida. El cache es lo más barato de los tres. El primer turno de un chat puede verse como centavos. Luego aparece un triángulo que crece, porque cada turno nuevo reenvía los anteriores salvo que el prefijo esté en cache. Los ciclos de herramientas de un agente multiplican ese ida y vuelta. Un fallo de cache después de una sesión larga (incluso un "hola" corto después de un millón de tokens de contexto) puede costar un re-prefill completo.
La compactación es la otra válvula oculta. Los harness de código suelen compactar alrededor de 200–300k tokens, no la ventana anunciada de un millón. Después de compactar pagas menos por turno, pero también soltaste estado. Los modelos más fuertes pueden verse caros porque la gente se queda en sesión y arrastra contexto, no solo porque el precio de lista por token sea más alto. Un modelo barato que necesita muchos turnos todavía puede ganar a uno caro que termina en dos. Las sesiones largas de agente, en su observación, pueden llegar a cientos de dólares y en algunos casos cerca de $1,000. Eso es su nota de campo, no un pronóstico de Agentivo Capital Labs.
La heurística de gasto de Arena encaja con el dominio de consumo de Tokenomics: estima el costo por tarea, usa las primeras dos o tres tareas reales como muestra, y refresca en una ventana de unos siete días porque los cambios de harness y compactación se vuelven viejos. Los tableros por turno y por token no ven eso.
Fuentes
