TOON: La Notación que Reduce tus Tokens hasta un 60% en Prompts de LLM

Hace algunos días, en una conversación con colegas entusiastas del vibe-coding y del desarrollo asistido por IA, surgió un tema recurrente: lo complicado que es manejar el contexto para optimizar costos. ¿Cómo mantener en un solo chat todo lo necesario para trabajar sin que el modelo pierda el hilo o sin que la factura se dispare? Entonces, uno de ellos mencionó TOON. Investigué, y lo que encontré podría cambiar cómo estructuramos datos para LLMs.

El Problema: JSON es Verboso y los Tokens Cuestan

Si trabajas con LLMs de forma intensiva, conoces esta realidad: los tokens cuestan dinero. Cada prompt que envías, cada respuesta que recibes, todo se traduce en tokens. Y el formato que usamos para estructurar datos tiene un impacto directo en ese consumo.

JSON es el estándar de facto para intercambio de datos, pero es extremadamente verboso. Las llaves, corchetes, comillas y la repetición constante de claves en arrays de objetos consumen tokens innecesariamente. Cuando trabajas con datasets grandes o necesitas incluir mucho contexto en tus prompts, esta verbosidad se convierte en un problema real de costos y límites de contexto.

¿Qué es TOON?

TOON (Token-Oriented Object Notation) es un formato de serialización diseñado específicamente para minimizar el consumo de tokens en prompts de LLM, manteniendo la legibilidad humana y la compatibilidad con el modelo de datos de JSON. Piensa en él como una capa de traducción: usas JSON programáticamente y lo codificas como TOON para la entrada del LLM.

La Filosofía detrás de TOON

TOON combina dos enfoques probados: la estructura basada en indentación de YAML para objetos anidados, y un layout tabular estilo CSV para arrays uniformes. El resultado es un formato que puede lograr reducciones del 30-60% en tokens comparado con JSON formateado, especialmente en arrays de objetos con la misma estructura.

Características Principales

• Eficiencia en Tokens: Típicamente 30-60% menos tokens en arrays uniformes grandes comparado con JSON formateado.
• Guardrails para LLMs: Longitudes explícitas y campos declarados permiten validación estructural.
• Sintaxis Mínima: Elimina puntuación redundante (llaves, corchetes, la mayoría de las comillas).
• Estructura por Indentación: Como YAML, usa espacios en blanco en lugar de llaves.
• Arrays Tabulares: Declara las claves una vez y transmite los datos como filas.

Ejemplo Práctico: De JSON a TOON

Veamos la transformación con un ejemplo real. Supongamos que tienes datos de métricas de analytics:

// JSON Original (22,250 tokens)
{
  "metrics": [
    {
      "date": "2025-01-01",
      "views": 5715,
      "clicks": 211,
      "conversions": 28,
      "revenue": 7976.46,
      "bounceRate": 0.47
    },
    {
      "date": "2025-01-02",
      "views": 7103,
      "clicks": 393,
      "conversions": 28,
      "revenue": 8360.53,
      "bounceRate": 0.32
    }
    // ... más filas
  ]
}

El mismo dataset en formato TOON:

// TOON (9,120 tokens - 59% de reducción)
metrics[5]{date,views,clicks,conversions,revenue,bounceRate}:
  2025-01-01,5715,211,28,7976.46,0.47
  2025-01-02,7103,393,28,8360.53,0.32
  2025-01-03,7248,378,24,3212.57,0.5
  2025-01-04,2927,77,11,1211.69,0.62
  2025-01-05,3530,82,8,462.77,0.56

Observa cómo TOON declara la estructura una sola vez: metrics[5]{date,views,clicks,conversions,revenue,bounceRate}: indica que hay 5 elementos con esos 6 campos. Luego, cada fila contiene solo los valores separados por comas. No hay repetición de claves, no hay llaves, no hay corchetes por cada objeto.

Benchmarks: Los Números Hablan

Los benchmarks de TOON son impresionantes y están respaldados por pruebas con múltiples modelos (Claude Haiku, Gemini Flash, GPT-5 Nano, Grok 4). Aquí está el resumen de rendimiento general:

TOON ████████████████████ 26.9 │ 73.9% acc │ 2,744 tokens
JSON compact █████████████████░░░ 22.9 │ 70.7% acc │ 3,081 tokens
YAML ██████████████░░░░░░ 18.6 │ 69.0% acc │ 3,719 tokens
JSON ███████████░░░░░░░░░ 15.3 │ 69.7% acc │ 4,545 tokens
XML ██████████░░░░░░░░░░ 13.0 │ 67.1% acc │ 5,167 tokens

TOON logra 73.9% de precisión (vs 69.7% de JSON) mientras usa 39.6% menos tokens. No solo es más eficiente en costo, sino que los LLMs lo comprenden mejor.

Ahorros por Tipo de Estructura

Para datos tabulares uniformes (registros de empleados, métricas de tiempo, repositorios), TOON logra reducciones del 42-60% comparado con JSON. Incluso para estructuras anidadas o semi-uniformes, los ahorros rondan el 15-33%.

Cómo Funciona la Sintaxis

Objetos Simples

Los objetos con valores primitivos se representan con indentación, similar a YAML:

// JavaScript
{ id: 123, name: 'Ada', active: true }

// TOON
id: 123
name: Ada
active: true

Arrays Primitivos

Los arrays de primitivos incluyen la longitud en corchetes:

// JavaScript
{ tags: ['admin', 'ops', 'dev'] }

// TOON
tags[3]: admin,ops,dev

Arrays Tabulares (El Poder Real)

Cuando todos los objetos de un array comparten los mismos campos primitivos, TOON usa formato tabular:

// JavaScript
{
  items: [
    { sku: 'A1', qty: 2, price: 9.99 },
    { sku: 'B2', qty: 1, price: 14.5 }
  ]
}

// TOON
items[2]{sku,qty,price}:
  A1,2,9.99
  B2,1,14.5

El header items[2]{sku,qty,price}: declara: 2 elementos, con campos sku, qty y price. Cada fila son los valores en ese orden. Esta declaración explícita ayuda a los LLMs a validar y parsear la estructura correctamente.

Key Folding para Estructuras Anidadas

TOON v1.5 introdujo key folding para colapsar cadenas de objetos de una sola clave en paths con puntos:

// Sin key folding
data:
  metadata:
    items[2]: a,b

// Con key folding
data.metadata.items[2]: a,b

Instalación y Uso

TOON tiene un SDK oficial en TypeScript y una CLI para conversiones rápidas:

# Convertir JSON a TOON desde CLI
npx @toon-format/cli input.json -o output.toon

# Pipe desde stdin
echo '{"name": "Ada", "role": "dev"}' | npx @toon-format/cli

# Ver estadísticas de tokens
npx @toon-format/cli data.json --stats -o output.toon

Para usar en tu código:

import { encode, decode } from '@toon-format/toon'

const data = {
  users: [
    { id: 1, name: 'Alice', role: 'admin' },
    { id: 2, name: 'Bob', role: 'user' }
  ]
}

// Codificar a TOON
const toon = encode(data)
// users[2]{id,name,role}:
//   1,Alice,admin
//   2,Bob,user

// Decodificar de vuelta a JSON
const restored = decode(toon)

Opciones de Delimitadores

TOON soporta diferentes delimitadores que pueden ofrecer ahorros adicionales:

// Delimitador por tabs (más eficiente en tokens)
encode(data, { delimiter: '\t' })

// Delimitador por pipes
encode(data, { delimiter: '|' })

Cuándo Usar (y Cuándo No Usar) TOON

TOON Excela Con:

• Arrays uniformes de objetos: Datasets con la misma estructura repetida (logs, métricas, registros).
• Contexto de LLM: Cuando necesitas incluir mucho dato estructurado en un prompt.
• Optimización de costos: Proyectos donde el consumo de tokens impacta directamente el presupuesto.

Considera Alternativas Cuando:

• Estructuras profundamente anidadas: Con 0% de elegibilidad tabular, JSON compacto puede ser más eficiente.
• Datos puramente tabulares: CSV es más pequeño para tablas planas sin anidamiento.
• Aplicaciones críticas en latencia: Algunos setups (especialmente modelos locales) pueden procesar JSON más rápido a pesar del mayor conteo de tokens.

Integración con tu Flujo de Trabajo

TOON se integra naturalmente con el stack de vibecoding económico que ya conocemos. Cuando usas Cline con DeepSeek para planificación, puedes codificar el contexto de tu codebase en TOON antes de enviarlo al LLM. Esto significa que puedes incluir más archivos, más estructura, más contexto en cada prompt sin explotar el límite de contexto o el presupuesto.

Para usar TOON efectivamente en prompts de LLM, la documentación recomienda mostrar el formato en lugar de describirlo:

Data is in TOON format (2-space indent, arrays show length and fields).

```toon
users[3]{id,name,role,lastLogin}:
  1,Alice,admin,2025-01-15T10:30:00Z
  2,Bob,user,2025-01-14T15:22:00Z
  3,Charlie,user,2025-01-13T09:45:00Z
```

Task: Return only users with role "user" as TOON.

Implementaciones en Otros Lenguajes

Además del SDK oficial en TypeScript, hay implementaciones comunitarias en desarrollo para Python, Go, Rust, .NET, Swift, Ruby, PHP, y muchos más. Esto significa que puedes integrar TOON en prácticamente cualquier stack de desarrollo.

Conclusión

TOON representa una solución elegante a un problema real del desarrollo asistido por IA: la eficiencia del contexto. Al combinar la familiaridad de YAML y CSV con guardrails estructurales que los LLMs pueden validar, logra reducir tokens significativamente sin sacrificar legibilidad ni precisión.

Para aquellos de nosotros que hacemos vibecoding de forma intensiva, TOON es una herramienta más en el arsenal de optimización. No es magia: requiere que tus datos tengan cierta uniformidad para aprovechar al máximo el formato tabular. Pero cuando tus casos de uso encajan, los ahorros del 30-60% en tokens se traducen directamente en más contexto disponible, menos límites alcanzados, y menores costos de API.

El formato está en producción pero sigue evolucionando. Si trabajas con grandes volúmenes de datos estructurados en tus prompts de LLM, vale la pena experimentar con TOON y ver cómo impacta tu flujo de trabajo específico.