TokenLab para agentes: modelos legibles por máquina, precios, SDK y MCP

TokenLab MCP es un servidor de Model Context Protocol (MCP) de solo lectura que proporciona a un agente de programación acceso directo y estructurado al catálogo público de modelos, precios y resumen de la API de TokenLab antes de que escriba una sola línea de código de integración. Responde a preguntas de descubrimiento (qué IDs de modelo existen actualmente, cuánto cuestan, qué modalidad admiten) y no realiza llamadas a APIs de inferencia de pago en su nombre.

Muchos errores de integración de agentes no comienzan en la primera llamada a la API; comienzan antes, cuando el agente elige un ID de modelo de un ejemplo obsoleto, una memoria caché o un tutorial de hace seis meses, y solo descubre la falta de coincidencia después de un error 404 o una sorpresa en los precios.

Los agentes de programación escriben rápido. No siempre leen primero. Junto con TokenLab MCP, TokenLab publica un llms.txt compacto, un llms-full.txt más completo y archivos JSON de datos de modelos públicos —las mismas superficies de catálogo de modelos y precios que usted mismo puede consultar— para que un agente pueda verificar los IDs de modelo y los costos actuales antes de codificar nada de forma rígida.

Este artículo cubre qué son esas superficies, qué no son y cómo conectar un agente para usarlas antes de que codifique un nombre de modelo. Para obtener la referencia completa de los endpoints, consulte la documentación de integración.

Puntos clave

• TokenLab publica resúmenes de API legibles por agentes en api.tokenlab.sh/llms.txt y llms-full.txt, con el dominio web redirigiendo a la misma fuente.
• Los archivos del Centro de Datos de Modelos Públicos (JSON del catálogo, JSON más reciente, JSON de tendencias, markdown de resumen) brindan a los agentes una instantánea consultable de lo que TokenLab ofrece actualmente.
• El servidor TokenLab MCP expone list_models, get_model, get_model_pricing y get_api_overview, y es de solo lectura. No hace proxy de inferencia de pago.
• La documentación pública recomienda que los agentes llamen a /v1/models o lean llms.txt antes de codificar un nombre de modelo, y utilicen el filtrado recommended_for para tareas que no sean de chat, como imágenes, video o embeddings.
• Leer los endpoints de modelos y precios antes de reintentar una solicitud fallida que no sea de chat evita llamadas fallidas repetidas contra la familia de modelos incorrecta.

Por qué los agentes eligen IDs de modelo obsoletos en primer lugar

Los agentes de programación generan IDs de modelo a partir de lo que aprendieron durante el entrenamiento, no de lo que está disponible actualmente. Esos datos de entrenamiento tienen una fecha de corte, por lo que el sentido interno del agente de "el modelo actual" está fijado en lo que fuera cierto cuando se actualizaron sus pesos por última vez. Cuando le pide a un agente que llame a una API de modelo, buscará con confianza el ID que recuerda, incluso si ese ID ha sido renombrado, desaprobado o reemplazado desde entonces.

Esto no es un error en el razonamiento del agente; es una limitación estructural de cualquier sistema que dependa del conocimiento memorizado en lugar de una búsqueda en tiempo real. La solución no es un prompt más inteligente, es darle al agente un lugar donde verificar antes de escribir código.

Para eso existen los archivos de datos de modelos y la API de TokenLab. Antes de generar una solicitud, un agente (o el humano que revisa su salida) puede consultar un endpoint en tiempo real para confirmar que el ID del modelo realmente existe, qué modalidad admite y cuánto cuesta, en lugar de confiar en un nombre extraído de la memoria.

Endpoint	Propósito
https://tokenlab.sh/model-data/catalog.json	Catálogo completo de modelos rastreados, estructurado para búsqueda programática
https://tokenlab.sh/model-data/latest.json	Lista de modelos actual en un formato ligero y amigable para agentes
https://tokenlab.sh/en/models	Navegador de modelos legible por humanos
https://tokenlab.sh/en/pricing	Precios actuales por modelo y modalidad

Una publicación de blog, incluida esta, es una instantánea. Refleja lo que era cierto cuando se escribió y quedará obsoleta de la misma manera que los datos de entrenamiento de un agente. Los endpoints en tiempo real no tienen ese problema: reflejan lo que es cierto en este momento, por lo que son lo más seguro que se debe verificar antes de enviar código, no un artículo estático.

Lo que TokenLab expone para el descubrimiento de agentes

La capa llms.txt

https://api.tokenlab.sh/llms.txt es un resumen compacto y legible por agentes de la API: qué endpoints existen, cómo se ve una solicitud y dónde encontrar detalles más profundos. Está diseñado para ser lo suficientemente corto como para que un agente pueda leerlo en una sola ventana de contexto sin consumir un gran presupuesto de tokens solo para orientarse.

https://api.tokenlab.sh/llms-full.txt es la versión más completa: más detalles de endpoints, más ejemplos, más superficie de área que un agente necesita antes de generar una integración funcional en lugar de un borrador.

Si llega al dominio web en lugar del host de la API, tokenlab.sh/llms.txt y tokenlab.sh/llms-full.txt redirigen a las mismas fuentes alojadas en la API. Eso es importante para los agentes: cualquier punto de entrada que rastreen o busquen, llegan al mismo texto canónico, no a dos copias divergentes.

El Centro de Datos de Modelos

Más allá del resumen de texto, TokenLab publica archivos JSON estructurados que un agente (o un script de compilación) puede extraer directamente:

• https://tokenlab.sh/model-data/catalog.json — el catálogo de modelos más completo.
• https://tokenlab.sh/model-data/latest.json — una instantánea orientada a lo que es actual en este momento.
• https://tokenlab.sh/model-data/summary.md — un resumen en markdown legible por humanos y agentes, útil cuando desea una diferencia rápida con respecto a lo que su código base tiene actualmente codificado.

Estos son archivos estáticos y recuperables. Un agente que construye un archivo de configuración, una plantilla .env o un menú desplegable de selección de modelos puede extraer el JSON directamente en lugar de pedirle a un humano que pegue una lista de modelos que volverá a estar obsoleta en dos semanas.

El servidor MCP: de solo lectura, y vale la pena ser preciso al respecto

https://github.com/hedging8563/tokenlab-mcp-server es público. Expone cuatro herramientas relevantes para el descubrimiento:

• list_models — enumerar lo que está disponible, opcionalmente filtrado.
• get_model — extraer detalles sobre un ID de modelo específico.
• get_model_pricing — extraer los precios actuales para un modelo específico.
• get_api_overview — el equivalente nativo de MCP a leer llms.txt.

La restricción importante: este servidor es de solo lectura. No llama a APIs de inferencia de pago en su nombre y no hace proxy de solicitudes de generación. Responde preguntas sobre modelos, precios y la forma de la API. Si su agente necesita ejecutar inferencia, todavía pasa por la API normal de TokenLab con su propia clave; el servidor MCP es una capa de descubrimiento, no una capa de ejecución. Confundir ambos es un error común que vale la pena evitar explícitamente en cualquier prompt de agente o archivo de habilidades que escriba.

Ejemplo de descubrimiento de TokenLab MCP

TokenLab expone un servidor de Model Context Protocol (MCP) de solo lectura que permite a los agentes de programación descubrir modelos y precios disponibles sin realizar ninguna inferencia. El servidor MCP proporciona cuatro herramientas:

• list_models — listar modelos disponibles, opcionalmente filtrados por recommended_for (p. ej., image, video, embedding, rerank, translation)
• get_model — recuperar detalles para un modelo específico
• get_model_pricing — recuperar información de precios para un modelo específico
• get_api_overview — recuperar un resumen de la API de TokenLab

Ejemplo: listar modelos a través de MCP

{
  "tool": "list_models",
  "arguments": {}
}

Ejemplo: filtrar modelos por uso recomendado

{
  "tool": "list_models",
  "arguments": {
    "recommended_for": "image"
  }
}

Si prefiere consultar la API directamente en lugar de pasar por MCP, las llamadas REST equivalentes son:

# Listar todos los modelos
curl https://api.tokenlab.sh/v1/models \
  -H "Authorization: Bearer sk-KEY"

# Listar modelos recomendados para tareas de imagen
curl "https://api.tokenlab.sh/v1/models?recommended_for=image" \
  -H "Authorization: Bearer sk-KEY"

Tenga en cuenta que el servidor MCP es estrictamente de solo lectura: está destinado al descubrimiento (listar modelos, inspeccionar precios y revisar las capacidades de la API) y no realiza ninguna inferencia por sí mismo.

Para obtener instrucciones de configuración y detalles de integración, consulte:

• Servidor TokenLab MCP
• Habilidad de Agente de Programación

El repositorio de habilidades

https://github.com/hedging8563/tokenlab-skills empaqueta este patrón de descubrimiento en algo que un marco de trabajo de agente de programación puede cargar directamente: una definición de habilidad que le dice al agente "lee esto antes de escribir código de integración de TokenLab", en lugar de confiar en que el agente decida de forma independiente verificar.

El flujo de trabajo recomendado para agentes

La documentación pública describe una secuencia específica, y se mantiene bien en la práctica:

1. Antes de codificar cualquier nombre de modelo, llame a /v1/models o lea llms.txt para confirmar que el ID realmente existe en este momento.
2. Para tareas que no sean de chat (imagen, video, música, 3D, TTS, STT, embedding, rerank, traducción), filtre con /v1/models?recommended_for=<task> en lugar de asumir que un modelo orientado al chat maneja la tarea, o adivinar un nombre de modelo de memoria.
3. Antes de reintentar una solicitud fallida que no sea de chat, lea /v1/models/:model y /v1/models/:model/pricing. Una solicitud fallida contra un modelo de modalidad incorrecta a menudo volverá a fallar en el reintento con la misma entrada; verificar la modalidad y el precio reales del modelo primero ahorra un bucle de reintento.

Esta secuencia es importante porque carga frontalmente los dos modos de falla más comunes: ID de modelo incorrecto y familia de modelos incorrecta para la tarea.

Lista de verificación práctica para conectar esto en un agente

Paso	Qué verificar	Dónde
1	¿Este ID de modelo todavía se resuelve?	/v1/models o llms.txt
2	¿Es esta la familia de modelos correcta para la tarea (chat vs. imagen vs. embedding, etc.)?	/v1/models?recommended_for=<task>
3	¿Cuál es el precio actual de entrada/salida para este modelo?	/v1/models/:model/pricing o get_model_pricing (MCP)
4	¿Cuál es la ventana de contexto y la modalidad?	/v1/models/:model o get_model (MCP)
5	¿Hay un modelo más nuevo con un nombre similar que haya reemplazado a este?	catalog.json / latest.json
6	¿El agente leyó llms.txt antes de generar el código de integración?	Confirmar en el registro de llamadas de herramientas del agente

Si un agente omite los pasos 1 y 2, todo lo que sigue (reintentos, manejo de errores, estimaciones de costos) se basa en una suposición en lugar de un hecho.

Por qué esto es importante para tareas que no son de chat específicamente

Los modelos de chat reciben la mayor parte de la atención, pero el filtro recommended_for existe porque las tareas que no son de chat fallan de formas menos obvias. Un modelo creado para la generación de texto a texto que devuelve una respuesta mal formada a una solicitud de imagen no siempre arroja un error limpio y autoexplicativo. A veces simplemente devuelve algo que el agente no sabe cómo analizar.

Filtrar por recommended_for=image, recommended_for=video, recommended_for=embedding, y así sucesivamente, reduce el conjunto de candidatos antes de que el agente escriba un cuerpo de solicitud. Dada la cantidad de entradas distintas de generación de imágenes que pueden existir en el catálogo de modelos en cualquier momento dado — nano-banana-2 (Gemini 3.1 Flash Image), nano-banana-pro (Gemini 3 Pro Image), nano-banana-2-lite (Gemini 3.1 Flash Lite Image), openai/gpt-image-2, reve/reve-2.0, microsoft/mai-image-2.5 — adivinar cuál es "el modelo de imagen" de memoria es exactamente el modo de falla que este flujo de trabajo está diseñado para prevenir. La generación de video tiene su propio conjunto de modelos específicos para la tarea (seedance, veo-3, entre otros) con diferentes precios y formas de modalidad; la misma lógica de filtrado se aplica.

Para obtener precios actuales exactos, límites de contexto y modalidad en cualquier modelo específico nombrado aquí, consulte el catálogo de modelos y la página de precios directamente; ese es el punto principal de no codificarlo en una publicación de blog tampoco. Si está evaluando modelos específicamente para el trabajo de desarrollo impulsado por agentes, consulte los mejores modelos de IA para programación 2026.

Lo que esto no hace

Ser preciso aquí es tan importante como el flujo de trabajo en sí:

• El servidor MCP no ejecuta inferencia de pago. Responde preguntas de descubrimiento. La ejecución de una solicitud de generación real sigue pasando por la API estándar con sus propias credenciales.
• llms.txt y los archivos del Centro de Datos de Modelos son instantáneas periódicas, no una conexión de base de datos en tiempo real. El tiempo de actualización no está fijado a un horario estricto, así que trate cualquier fecha en estas páginas como aproximada. Para cualquier cosa sensible al precio o a la seguridad, el endpoint de precios y la API del panel siguen siendo la fuente de verdad en el momento de la solicitud.
• Nada de esto reemplaza la lectura de la documentación completa de la API para la autenticación, los límites de velocidad o la semántica de manejo de errores. Las superficies de descubrimiento le dicen a un agente qué existe; no reemplazan la documentación de integración sobre cómo llamarlo correctamente.

Preguntas frecuentes

¿Qué debe leer un agente antes de elegir un modelo de TokenLab? Lea llms.txt (o llms-full.txt para más detalles) y llame a /v1/models antes de codificar cualquier ID de modelo. Para tareas que no sean de chat, filtre con recommended_for en lugar de adivinar un nombre de modelo de memoria.

¿TokenLab MCP llama a APIs de inferencia de pago? No. El servidor público TokenLab MCP es de solo lectura. Sus herramientas (list_models, get_model, get_model_pricing, get_api_overview) responden preguntas de descubrimiento sobre modelos y precios. Las llamadas de inferencia reales pasan por la API estándar con su propia clave.

¿Cuándo debe un agente usar recommended_for? Siempre que la tarea no sea un chat simple: imagen, video, música, 3D, TTS, STT, embedding, rerank o traducción. Filtrar por tarea reduce la lista de modelos a variantes realmente creadas para esa modalidad, en lugar de asumir que un modelo orientado al chat la manejará.

¿Cómo reduce esto los IDs de modelo obsoletos en el código generado? Haciendo del descubrimiento el primer paso en lugar de una ocurrencia tardía. Un agente que lee llms.txt, verifica /v1/models y confirma los precios antes de escribir código está trabajando a partir de una instantánea actual en lugar de una memoria de tiempo de entrenamiento que puede tener ya varias generaciones de modelos de antigüedad.

Fuentes y frescura

• TokenLab llms.txt — https://api.tokenlab.sh/llms.txt — observado 2026-07-09
• TokenLab llms-full.txt — https://api.tokenlab.sh/llms-full.txt — observado 2026-07-09
• Documentación del servidor TokenLab MCP — https://docs.tokenlab.sh/integrations/tokenlab-mcp-server — observado 2026-07-09
• Documentación de Habilidad de Integración de API de TokenLab — https://docs.tokenlab.sh/integrations/coding-agent-skill — observado 2026-07-09
• Repositorio del servidor TokenLab MCP — https://github.com/hedging8563/tokenlab-mcp-server — observado 2026-07-09
• Repositorio de habilidades de TokenLab — https://github.com/hedging8563/tokenlab-skills — observado 2026-07-09
• Centro de Datos de Modelos de TokenLab — https://tokenlab.sh/model-data/catalog.json, https://tokenlab.sh/model-data/latest.json, https://tokenlab.sh/model-data/summary.md — observado 2026-07-09

Los IDs de modelo, los precios y los detalles de modalidad en este artículo reflejan una instantánea tomada en el momento de la redacción. Las páginas de instantáneas como esta y llms.txt se actualizan periódicamente, pero no en una cadencia fija o garantizada; no cree lógica de reintento o estimaciones de costos en torno a un intervalo de actualización asumido. Verifique los valores actuales contra la página de precios y el catálogo de modelos antes de enviar código de integración. Para una mirada más profunda sobre cómo se estructuran los precios en las familias de modelos, consulte Precios de la API de Gemini para desarrolladores.

Próximos pasos con TokenLab MCP

Para comenzar a usar TokenLab MCP para el descubrimiento de modelos:

1. Obtenga una clave de API desde el panel de TokenLab.
2. Conecte su agente siguiendo la guía de integración de agentes de programación.
3. Explore el catálogo directamente en tokenlab.sh/en/models para ver la cobertura actual de modelos y metadatos.
4. Verifique los precios de los modelos que planea usar en tokenlab.sh/en/pricing.

Si está decidiendo qué modelos se ajustan a su flujo de trabajo, consulte nuestros desgloses sobre los mejores modelos de IA para programación en 2026 y precios de la API de Gemini para desarrolladores.

Tenga en cuenta que MCP es estrictamente una capa de descubrimiento: muestra metadatos, capacidades y precios de modelos para que su agente pueda tomar decisiones informadas. Las llamadas de inferencia reales siguen pasando por la API estándar de TokenLab utilizando su propia clave de API; MCP no enruta ni hace proxy de solicitudes.