TOON: Token Oriented Object Notation - La nueva forma de estructurar datos en sistemas basados en tokens
En los últimos años hemos visto cómo JSON, YAML y Protobuf dominan el intercambio de datos entre servicios. Sin embargo, la llegada de arquitecturas impulsadas por modelos generativos, agentes autónomos y sistemas basados en tokens ha dejado en evidencia una limitación clave: las representaciones clásicas no entienden el concepto de “token” como unidad fundamental de procesamiento.
Aquí es donde entra TOON — Token Oriented Object Notation. Un formato pensado para representar información optimizada para modelos que operan por tokens, evitando ambigüedades semánticas y reduciendo el coste de tokenización.
Este post te explica qué es, por qué existe, cómo se usa y cómo integrarlo en aplicaciones modernas.
1. ¿Qué es TOON?
TOON es un formato de serialización diseñado para expresar datos usando estructuras que priorizan:
- Baja complejidad léxica (menos coste de tokenización).
- Estructuras estrictas (evitar interpretaciones ambiguas en LLMs).
- Representaciones compactas (ideal para contextos de IA y modelos embebidos).
- Contextualización explícita (los tokens representan intención, no solo cadenas).
A diferencia de JSON:
1
2
3
4
5
6
7
{
"user": {
"name": "Carlos",
"age": 32,
"active": true
}
}
En TOON se busca reducir ruido y agrupar significado por tokens:
1
2
3
4
:user
:name "Carlos"
:age 32
:active +
Menos símbolos, semántica directa, estructura clara para modelos.
2. ¿Para qué sirve TOON?
2.1. Optimización para modelos generativos y agentes
Cuando un LLM lee JSON, internamente debe tokenizar cada símbolo, llave, comilla, coma y palabra. Esto incrementa costes, aumenta latencia y puede generar interpretaciones diferentes según el modelo.
TOON elimina mucho del “ruido sintáctico”.
2.2. Evitar ambigüedades
Los modelos generativos suelen confundir:
- null vs “” vs “ “
- booleanos escritos como “true” en vez de true
- campos opcionales
TOON utiliza un conjunto reducido de símbolos sin ambigüedad.
2.3. Ideal para prompts estructurados
Muchos sistemas de IA ya están migrando a formatos como:
- ReAct JSON-like structures
- MiniLang
- DSLs personalizados
TOON es un estandar no oficial pero emergente, pensado para el futuro de la IA.
3. Sintaxis básica de TOON
TOON es minimalista. Usa reglas simples:
3.1. Claves
Siempre comienzan con : Ejemplo:
1
:user
3.2. Asignación
Se usa simplemente un espacio:
1
:name "Ana"
3.3. Tipos de datos
- String → “texto”
- Numero → 123
- Booleano → + (true), - (false)
- Nulo → 0
- Lista:
1 2 3 4 5
:items [ "a" "b" "c" ]
- Objeto:
1 2 3
:address :city "Madrid" :zip 28010
La indentación define jerarquía, igual que en YAML pero con un objetivo: la IA no confunde bloques ni niveles.
4. Ejemplo completo
JSON convencional
1
2
3
4
5
6
7
8
9
10
11
12
13
{
"product": {
"id": 401,
"title": "Cámara 4K",
"price": 249.99,
"available": true,
"tags": ["video", "cámara", "4k"],
"meta": {
"rating": 4.7,
"reviews": 128
}
}
}
TOON equivalente
1
2
3
4
5
6
7
8
9
10
11
12
13
:product
:id 401
:title "Cámara 4K"
:price 249.99
:available +
:tags [
"video"
"cámara"
"4k"
]
:meta
:rating 4.7
:reviews 128
Resultado:
- Menos símbolos → menos tokens.
- Semántica más clara para LLMs.
- Representación más limpia para prompts técnicos.
5. Cómo parsear TOON en aplicaciones reales
Aunque TOON no es un estándar oficial, su sintaxis es lo bastante simple como para implementar un parser seguro en cualquier lenguaje.
5.1. Ejemplo de parser básico en Java (Spring)
Enfocado en evitar errores comunes:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
public class ToonParser {
public ToonNode parse(List<String> lines) {
ToonNode root = new ToonNode();
Deque<ToonNode> stack = new ArrayDeque<>();
stack.push(root);
int previousIndent = 0;
for (String line : lines) {
if (line.trim().isEmpty()) continue;
int indent = countIndent(line);
String trimmed = line.trim();
if (!trimmed.startsWith(":")) {
throw new IllegalArgumentException("Clave inválida: " + trimmed);
}
while (indent < previousIndent) {
stack.pop();
previousIndent--;
}
String[] parts = trimmed.split(" ", 2);
String key = parts[0].substring(1);
ToonNode node = new ToonNode(key);
if (parts.length > 1) {
node.setValue(parseValue(parts[1]));
}
stack.peek().addChild(node);
stack.push(node);
previousIndent = indent;
}
return root;
}
private int countIndent(String line) {
return (int) line.chars().takeWhile(c -> c == ' ').count() / 4;
}
private Object parseValue(String raw) {
if (raw.equals("+")) return true;
if (raw.equals("-")) return false;
if (raw.equals("0")) return null;
if (raw.startsWith("\"") && raw.endsWith("\"")) {
return raw.substring(1, raw.length() - 1);
}
try {
return Double.parseDouble(raw);
} catch (NumberFormatException e) {
throw new IllegalArgumentException("Valor inválido: " + raw);
}
}
}
Este parser:
- Valida indentación.
- Controla errores de sintaxis.
- Evita interpretaciones ambiguas.
- No intenta adivinar tipos (evita bugs silenciosos).
6. ¿Por qué TOON es importante ahora?
✔ LLMs consumen tokens, no bytes Reducir símbolos = reducir coste = aumentar rendimiento.
✔ Evitar malinterpretaciones Los modelos procesan mejor claves directas y símbolos simples.
✔ Formato ideal para prompts estructurados Muchos agentes funcionan mejor con DSLs semánticamente claros.
✔ Fácil de serializar, fácil de leer Tanto por humanos como por máquinas.
7. ¿Deberías adoptar TOON en tus proyectos?
Sí, si trabajas con:
- agentes inteligentes,
- modelos generativos,
- pipelines de IA,
- prompts estructurados,
- automatización basada en IA.
No es necesario si solo intercambias datos entre microservicios tradicionales donde JSON o Protobuf siguen siendo óptimos.
8. Conclusión
TOON es una propuesta simple pero poderosa: un formato de datos optimizado para IA, para sistemas basados en tokens y para la nueva generación de aplicaciones inteligentes.
Al reducir ruido sintáctico y aumentar claridad semántica, TOON se adapta mejor a cómo los modelos trabajan internamente.
Si trabajas con IA, agentes o prompts complejos, conocer TOON no es opcional: es el siguiente paso lógico en la evolución de la representación de datos.