Jev de TypeSafe: un modelo que devuelve decisiones tipadas en lugar de texto

Un nuevo modelo de TypeSafe se salta por completo la generación de texto. Lo que devuelve es una decisión tipada con una probabilidad adjunta, y eso cambia qué partes de tu código puede ocupar un modelo de IA.

El modelo se llama Jev y es el primero de lo que la empresa denomina System One Models. El nombre se inspira en la división de Kahneman entre el pensamiento rápido y automático y el lento y deliberado. Jev se queda con la mitad rápida, y la deliberada sigue en manos de los grandes modelos de lenguaje.

Su anuncio en typesafe.ai subió en Hacker News hasta casi mil puntos, reunió más de 300 comentarios y aproximadamente la mitad discutía sobre el título. Parece otro lanzamiento más de un modelo pequeño, rápido y barato, y no lo es. Jev no escribe nada, porque no tiene salida de texto. Así que en realidad no compite con los modelos de chat que ya usas. Compite con una sentencia if.

La sentencia if por la que todos siguen pidiendo perdón

Casi todo pipeline tiene un punto podrido. En algún lugar del medio hay que tomar una decisión a criterio. ¿Este ticket debería saltarse la cola? ¿Esta respuesta suena grosera? ¿Vale la pena conservar esta fila?

Durante años ese hueco se llenó con reglas: listas de palabras clave, regex, un umbral ajustado algún martes y nunca revisado. Todo eso se rompe la primera vez que un cliente escribe con educación pero furioso.

Así que los equipos pusieron ahí un LLM. Funciona, y también destroza el pipeline. Una sola decisión puede tardar unos ocho segundos, y el parseo del JSON falla en la fila cuatrocientos. No puedes ejecutarlo por elemento sobre un dataset grande ni dentro de un bucle, y desde luego no en algo que un usuario está esperando.

La inteligencia nunca fue el problema

El verdadero dolor está en la ubicación, y tiene poco que ver con que los modelos sean demasiado tontos para el trabajo. Los modelos más inteligentes están en los bordes del software, mientras el bucle interno sigue lleno de regex.

Qué ha lanzado TypeSafe

El fundador lo resume en una frase: una llamada a función con inteligencia de frontera que recibe estado no estructurado y devuelve decisiones tipadas y probabilísticas.

Le pasas un state, que puede ser un ticket de soporte, un documento o un fotograma de un juego serializado como texto, además de un diccionario de preguntas. Te devuelve respuestas tipadas. Solo hay tres tipos de pregunta, y esa es toda la superficie:

• Choice elige una opción de un conjunto. Devuelve la selección, una probabilidad para cada opción y un valor de confianza.
• Score puntúa algo según niveles ordenados y descritos, y devuelve el mismo conjunto de valores.
• Noul es una pregunta de sí o no, respondida como la probabilidad de que la respuesta sea sí.

Todas las preguntas de una llamada se evalúan en paralelo, cada una por separado, contra el mismo estado y en una sola pasada. Por eso TypeSafe dice que añadir preguntas apenas mueve el tiempo de respuesta. El coste es por llamada, no por pregunta.

La latencia anunciada va de 70 ms a 500 ms de extremo a extremo, y el precio es de $42 por cada mil millones de tokens de entrada, con la salida gratis. Si esa cifra significa lo que parece, lo veremos más abajo.

Toda la API

El quickstart empieza con un único import:

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

Después entra un ticket de soporte y salen tres decisiones:

client = TypeSafeClient()ticket = "Hi, I've been trying to connect my Stripe account for 3 days and it keeps failing. I'm losing sales. Please help ASAP."response = client.system_one(
    state=ticket,
    questions={
        "department": Choice(
            instructions="Which team should handle this",
            criteria={
                "billing": "Payment or subscription issues",
                "technical": "Bugs or integration problems",
                "sales": "Pricing or account questions",
            },
        ),
        "frustration": Score(
            instructions="How frustrated the customer appears",
            criteria=[
                "Calm, just stating facts",
                "Frustrated but civil",
                "Very angry, strong language",
            ],
        ),
        "is_urgent": Noul(
            instructions="The message conveys urgency or time-sensitivity",
        ),
    },
)

Sin prompt engineering, sin instrucciones de «responde solo con JSON válido» y sin envoltorio de reintentos. Tres decisiones llegan en un solo viaje de ida y vuelta. Los SDK de Python y JavaScript funcionan sobre un único endpoint POST.

La parte que cambia cómo escribes código

Una respuesta de un LLM llega con la misma certeza plana tanto si el modelo sabe como si adivina. Jev, en cambio, devuelve una distribución.

El método de entrenamiento se llama RLCD, siglas de Reinforcement Learning for Calibrated Decisions, y su objetivo es que esas probabilidades reflejen con qué frecuencia acierta realmente el modelo. Eso significa que puedes ramificar según la duda:

• Por encima de 0.9, enruta el elemento automáticamente.
• Entre 0.6 y 0.9, escálalo a un modelo más grande.
• Por debajo, ponlo delante de una persona.

Es una rama que muchos equipos llevan años queriendo. Hasta ahora la simulaban con la confianza que el propio LLM dice tener, que predice más o menos lo mismo que la astrología.

Qué hicieron los testers el primer día

Los primeros usuarios hicieron una serie de experimentos, y uno de ellos muestra la forma del producto mejor que cualquier tabla de benchmarks. Un redactor de una empresa de medios le dio a Jev sus 27 artículos publicados y 10 falsos escritos a propósito con estilo de IA. Planteó 21 preguntas simultáneas sobre señales habituales de escritura automática. En total fueron 777 decisiones sobre 37 documentos. Todas llegaron en menos de 0.7 segundos, con un coste de alrededor de una cuarta parte de un centavo.

El CEO de la empresa continuó con cuatro comprobaciones sobre 12 fragmentos, enfrentadas directamente a un LLM de frontera. Jev necesitó una mediana de 0.35 segundos por fragmento y el LLM, 8.83. Es unas 25 veces más rápido y, según sus cuentas, unas 580 veces más barato.

La demo de Doom

Una demo fue la que hizo que la gente de Hacker News lo entendiera. TypeSafe conectó Jev para que jugara a Doom. No leía píxeles: recibía el estado del juego serializado como texto estructurado, a unas diez consultas por segundo. Al parecer, al ingeniero que lo montó le preocupaba ese ritmo de consultas, que sale a unos $7 la hora.

Una IA dentro de un bucle de juego es toda la propuesta, llevada al pie de la letra.

Dónde falla

La página principal promete «Zero Hallucinations», y es la afirmación que más merece discutirse. Lo que se garantiza es que la salida coincide con tu esquema, así que un Choice siempre cae en una de tus opciones. Eso no es lo mismo que acertar. Jev puede devolver una respuesta válida y equivocada con total seguridad, y el hilo de Hacker News lo dijo largo y tendido.

El experimento del redactor lo confirma. Se habían colocado siete defectos en el conjunto de prueba. Jev encontró seis y pasó por alto uno, un párrafo sobre un calendario compartido con el que padres y personal «enseñan juntos». El LLM de comparación sí lo detectó. Su propio veredicto fue sincero: si va a ir a producción, antes hay que hacer pruebas de precisión más cuidadosas.

Los límites duros también son reales:

• La ventana de contexto es de 32k tokens, lo que descarta trabajar con repositorios completos.
• Un Choice admite como máximo 255 opciones.
• Todavía no acepta imágenes como entrada.
• La arquitectura se mantiene en secreto. No hay paper ni evaluación independiente de RLCD, solo testimonios tempranos.

El precio no es el cambio que crees

$42 por cada mil millones de tokens de entrada parece absurdamente barato frente a un modelo de frontera, pero la unidad es distinta. Lo que compras son decisiones, y vas a tomar muchas más de las llamadas a LLM que hayas hecho nunca. La tarifa baja por token es lo que permite diez llamadas por segundo. No es una simple resta de tu factura actual.

Además, es acceso anticipado con lista de espera, así que puede que leas sobre él antes de poder probarlo.

¿Merece tu atención?

Sí, aunque no por los multiplicadores de velocidad. Jev destaca porque tiene un alcance honesto. No chatea, no razona en voz alta, no se explica y no finge lo contrario.

Su único trabajo es convertir entradas desordenadas en una decisión tipada que tu compilador puede comprobar, y hacerlo lo bastante rápido como para vivir dentro de un bucle. Quizá tu producto tenga un modelo de chat metido en un sitio que en realidad necesita una decisión. Para esa situación, Jev ofrece una solución de verdad distinta. Cuenta con construir alrededor del valor de confianza más que de la latencia.

Pruébalo con tus propios datos antes de acercarlo a nada importante, que es el consejo que los primeros testers no paran de repetir. Mucha gente ya duda de que un único modelo de texto para todo sea la herramienta adecuada para tareas concretas, y este es el primer intento serio de hacer algo diferente.