Hemos estado usando los LLM como un martillo para cada problema de IA, incluso para decisiones simples. Jev maneja esas decisiones en milisegundos a una fracción del costo. Vamos a entender cómo funciona y dónde encaja.
TypeSafe AI lanzó Jev el 15 de septiembre de 2026, y la reacción fue inusualmente fuerte para un modelo que no puede mantener una conversación, escribir código ni generar un solo párrafo útil.
Bueno, esa limitación es precisamente el punto.
La mayoría del software no necesita otro chatbot. Necesita tomar miles de pequeñas decisiones, por ejemplo: ¿Es urgente este ticket? ¿Qué modelo debe manejar esta solicitud? ¿Es peligroso este comando de shell? ¿Responde este pasaje recuperado a la pregunta?
Los equipos suelen enviar cada decisión a un LLM de propósito general. El modelo genera una respuesta token por token, la aplicación la analiza, la valida y reintenta cuando el formato es incorrecto. Funciona, pero es lento y costoso para una decisión con cinco posibles respuestas.
Jev está construido específicamente para esas decisiones. TypeSafe lo llama un modelo de Sistema Uno: entra estado no estructurado, salen respuestas tipadas y probabilidades.
Desglosemos qué significa eso, dónde encaja y dónde el marketing necesita un poco de moderación.
Primero, el problema que Jev está resolviendo
Los LLM se volvieron mucho más fáciles de conectar al software una vez que llegaron las llamadas a herramientas (tool calling) y las salidas estructuradas.
Las llamadas a herramientas permiten que un modelo solicite una función con un formato predecible. Las salidas estructuradas permiten que devuelva JSON que sigue un esquema. Ambas eliminaron una gran cantidad de análisis frágil.
Pero el modelo subyacente sigue siendo generativo. Incluso cuando la respuesta es solo una palabra "billing*", produce tokens secuencialmente. Pagas por la entrada, esperas la generación y a menudo pagas más por la salida.
Ahora coloca eso dentro de un bucle de agente.
1while not done:2 action = llm(context)3 result = run_tool(action)4 context += result
El modelo puede ser llamado nuevamente para elegir una herramienta, juzgar un resultado, detectar riesgos, decidir si la tarea está completa y seleccionar el siguiente modelo. Una sola ejecución de un agente puede contener muchas llamadas que requieren juicio pero sin prosa generada.
Jev apunta a esas llamadas.
Su apuesta es simple: la generación de lenguaje es la interfaz equivocada cuando el código ya conoce las posibles respuestas.
Qué es realmente Jev
La descripción precisa más corta es un motor de decisiones semánticas.
Envías a Jev dos cosas:
- Estado: el texto o JSON que describe la situación actual.
- Preguntas: las decisiones que quieres que tome sobre ese estado.
Cada pregunta declara su forma de respuesta por adelantado. Jev admite tres primitivas:
- Choice (Elección): selecciona una opción de una lista que defines y devuelve una probabilidad para cada opción.
- Score (Puntuación): coloca la entrada en una escala ordenada que defines, como bajo, medio y alto.
- Noul: responde una pregunta de sí o no devolviendo la probabilidad de que sea verdadera.
Noul es el nombre de TypeSafe para la primitiva estilo booleano. El nombre inusual importa menos que la salida (un número entre 0 y 1 con el que tu código puede actuar).
1{2 "model": "jev-latest",3 "state": "The deploy failed twice and customers are seeing 500s.",4 "questions": {5 "urgent": {6 "type": "noul",7 "instructions": "Does this need attention right now?"8 },9 "owner": {10 "type": "choice",11 "instructions": "Which team should handle this?",12 "criteria": {13 "engineering": "Product failures and outages",14 "billing": "Charges, invoices, and refunds",15 "sales": "Pricing and new accounts"16 }17 }18 }19}
La respuesta contiene una probabilidad de urgencia y una distribución de probabilidad sobre los tres equipos. No hay ningún párrafo para interpretar ni un cuarto equipo que el modelo pueda inventar.
Tu programa mantiene el control:
1if urgent > 0.9 and owner == "engineering":2 page_on_call()3elif confidence < 0.6:4 send_to_human_review()5else:6 add_to_queue(owner)
Esta es la razón por la que la gente sigue llamando a Jev una sentencia switch inteligente. La frase suena despectiva, pero captura la parte útil del diseño. El código ordinario posee las ramas. El modelo suministra el juicio difuso que el código ordinario no puede calcular de manera confiable.
La diferencia importante respecto a un LLM
Un LLM tradicional y Jev pueden clasificar ambos un ticket de soporte. Llegan a la respuesta de manera diferente y son útiles en diferentes partes de un sistema.
TypeSafe dice que Jev evalúa todas las preguntas en una solicitud en paralelo. Eso cambia cómo diseñas el flujo de trabajo. En lugar de hacer una pregunta, esperar y decidir cuál viene después, puedes hacer todas las preguntas independientes sobre el mismo estado en una sola solicitud y dejar que el código use las respuestas que necesita.
La empresa reporta una latencia de extremo a extremo entre 70 y 500 milisegundos y un precio de $0.042 por millón de tokens de entrada, con la salida gratis. Sus afirmaciones principales alcanzan aproximadamente 200 veces más rápido y 400 veces más barato que los flujos de trabajo comparables de LLM.
Esos grandes múltiplos provienen de las evaluaciones de flujo de trabajo propias de TypeSafe y se sitúan en el extremo favorable de la comparación. Trátalos como un techo, no como una promesa para cada aplicación. La ventaja subyacente sigue siendo creíble, ya que Jev evita largas trazas de razonamiento y salida generada porque fue diseñado para decisiones acotadas.
Por qué importan las probabilidades
Una respuesta tipada resuelve solo la mitad del problema.
Supongamos que Jev enruta un ticket a facturación. La etiqueta seleccionada te dice quién ganó. La distribución de probabilidad te dice cuán reñida estuvo la carrera.
1{2 "choice": "billing",3 "probabilities": {4 "billing": 0.52,5 "technical": 0.46,6 "sales": 0.027 },8 "confidence": 0.189}
Enrutar ese ticket automáticamente sería imprudente. Facturación ganó, pero apenas. Una respuesta de baja confianza debería activar una rama diferente.
Esto les da a los desarrolladores un patrón práctico:
- Alta confianza: actúa automáticamente cuando la consecuencia es pequeña.
- Confianza media: pide confirmación o llama a un modelo más potente.
- Baja confianza: envía el caso a una persona o recopila más información.
Los umbrales pertenecen al código, donde pueden ser revisados y cambiados. Una etiqueta de panel puede tolerar una predicción débil. Un comando que elimina datos debería requerir un estándar mucho más alto.
TypeSafe entrena a Jev usando Aprendizaje por Refuerzo para Decisiones Calibradas, o RLCD. El objetivo es que la confianza refleje la precisión a través de muchas predicciones. Si un modelo da a un conjunto de respuestas una probabilidad del 90 por ciento, aproximadamente el 90 por ciento de esas respuestas deberían ser correctas.
La afirmación sobre alucinaciones necesita precisión
TypeSafe dice que Jev no puede alucinar. Esa afirmación es cierta solo bajo una definición estrecha.
Jev no puede devolver una opción fuera del esquema. Si defines billing, technical y sales, la respuesta no puede inventar legal. Tampoco puede producir prosa malformada donde tu código esperaba una etiqueta.
Pero puede elegir con confianza la opción válida equivocada.
La seguridad de tipos previene formas inválidas. No garantiza un juicio correcto. Esa distinción importa porque un error válido según el esquema aún puede reembolsar al cliente equivocado, enrutar incorrectamente un incidente o aprobar un comando peligroso.
Una oración más segura es "Jev no puede romper el esquema de salida declarado, pero aún puede estar equivocado".
Dónde encaja Jev dentro de un agente
Jev funciona mejor cuando se usa junto con un LLM en lugar de reemplazarlo.
El LLM maneja el trabajo que requiere lenguaje o razonamiento más profundo. Planifica, escribe, explica y usa herramientas. Jev maneja las decisiones frecuentes alrededor de ese trabajo.
Tres ubicaciones son especialmente convincentes.
Enrutamiento de modelos
Una búsqueda simple no necesita el mismo modelo que una revisión de arquitectura. Jev puede puntuar la solicitud y elegir el modelo menos costoso probable para completarla.
1route = jev.choice(2 state=user_request,3 options={4 "fast": "Lookups, extraction, and small local edits",5 "powerful": "Architecture, ambiguity, and high-stakes work",6 },7)89model = fast_model if route == "fast" else powerful_model
El router no responde a la solicitud. Decide qué modelo debería hacerlo.
Control de riesgo de herramientas
Antes de que un agente ejecute un comando de shell, Jev puede clasificarlo como de solo lectura, reversible o destructivo. Preguntas separadas pueden verificar si elimina archivos, cambia el historial de Git, toca producción o sale del repositorio.
Las acciones de solo lectura de alta confianza pueden continuar. Las acciones destructivas o inciertas pueden pausarse para aprobación humana. La integración de Jev de LangChain aplica este patrón a través de middleware que verifica una llamada a herramienta antes de la ejecución.
Verificación y supervisión
Un agente puede afirmar que una tarea está terminada mientras las pruebas aún fallan. Jev puede inspeccionar el estado y responder preguntas acotadas: ¿Pasaron las pruebas? ¿Está el agente repitiendo la misma acción? ¿Sigue la salida la política? ¿Debería revisarse este resultado?
No reemplazará una prueba dura cuando existe una. Agrega una verificación semántica donde la regla depende del significado.
Problemas que Jev puede resolver hoy
Los mejores casos de uso comparten tres propiedades. Puedes nombrar las posibles respuestas, un humano cuidadoso podría juzgar la entrada rápidamente, y la decisión ocurre con suficiente frecuencia para que la latencia o el costo importen.
Soporte y operaciones
- Clasifica intención, urgencia, departamento, spam y frustración del cliente.
- Enruta reembolsos y excepciones de políticas a través de varias comprobaciones pequeñas.
- Ordena registros e incidentes por severidad semántica antes de que una persona los lea.
Una sola solicitud puede hacer todas estas preguntas sobre el mismo ticket. Luego, el código combina las respuestas en la política real de enrutamiento de la empresa.
Búsqueda y recuperación
- Reordena pasajes recuperados según si responden a la consulta.
- Verifica si una cita respalda una afirmación.
- Filtra fragmentos irrelevantes antes de enviar contexto a un LLM costoso.
Las embeddings son excelentes para encontrar texto semánticamente relacionado. Jev puede tomar la decisión más estrecha de si un pasaje particular es útil para esta pregunta.
Calidad y seguridad
- Analiza prompts buscando jailbreaks o inyección de prompts.
- Verifica contenido generado contra una política o rúbrica.
- Marca cambios de código o llamadas a herramientas arriesgadas antes de que se ejecuten.
Estas comprobaciones deben estar junto a controles deterministas. Un clasificador semántico es útil para riesgos difusos, mientras que permisos, sandboxes y pruebas hacen cumplir reglas que el software puede verificar exactamente.
Clasificación de alto volumen
- Etiqueta documentos, papers de investigación, listados de productos o mensajes de clientes.
- Convierte texto libre en características para un modelo tradicional de aprendizaje automático.
- Puntúa cada elemento en un corpus grande contra la misma rúbrica.
Aquí es donde el bajo costo por llamada se convierte en algo más que un número de benchmark. Una decisión que era demasiado cara para ejecutar en cada fila puede moverse al pipeline normal de datos.
Interfaces en tiempo real
- Elige la próxima acción del navegador de elementos de página conocidos.
- Puntúa tono o claridad mientras una persona escribe.
- Selecciona una acción de un estado estructurado de juego o simulador.
Jev es solo texto hoy, así que estos sistemas deben convertir primero el entorno a texto o JSON. No está mirando la pantalla ni jugando desde píxeles.
Dónde Jev es la elección equivocada
Jev se vuelve menos útil tan pronto como el espacio de respuestas deja de ser conocido.
- No puede escribir una respuesta, resumir un documento, generar código ni explicar su razonamiento.
- Es poco confiable para aritmética, conteo, comparación de fechas o manipulación exacta de cadenas. Mantén esas operaciones en el código.
- Tiene dificultades cuando una decisión requiere varios pasos ocultos de razonamiento. Divide el juicio en preguntas más pequeñas o usa un modelo de razonamiento.
- No puede extraer un valor desconocido directamente. Encuentra valores candidatos primero, luego deja que Jev elija entre ellos.
- El contexto irrelevante puede reducir la precisión. Envía solo el estado requerido para la decisión.
- Pesos cerrados, acceso anticipado, entrada solo de texto y datos de calibración independientes limitados hacen que sea demasiado pronto para confiar ciegamente.
Hay también una regla más simple: si el código determinista ya resuelve el problema correctamente, mantén el código. Una sentencia if normal es más rápida, más barata y más fácil de probar que cualquier modelo.
Cómo usar Jev sin crear un nuevo modo de fallo
Un modelo barato aún puede ser caro si sus errores crean reintentos, revisión manual o incidentes de producción. Mide todo el flujo de trabajo, no el precio del token.
Un despliegue sensato se ve así:
- Elige una decisión acotada, de bajo riesgo, con posibles respuestas claras.
- Escribe la rúbrica antes de llamar al modelo. Define qué pertenece a cada opción.
- Recopila ejemplos representativos con respuestas esperadas, incluyendo casos ambiguos y adversarios.
- Ejecuta Jev en modo sombra junto al flujo de trabajo actual sin permitirle cambiar el comportamiento.
- Grafica la precisión contra la confianza y establece umbrales basados en tus datos.
- Automatiza la rama más segura primero y mantén un humano o un modelo más potente para casos inciertos.
- Fija o registra la versión del modelo, preguntas, criterios y umbrales para que los cambios puedan reproducirse contra el mismo conjunto de evaluación.
Las preguntas son parte del programa. Trátalas como código: versionéalas, revísalias y pruébalas siempre que cambie el modelo o la rúbrica.
El cambio real
Jev no es interesante porque vence a un LLM escribiendo. Se niega a escribir.
Su contribución es una interfaz de modelo con forma de software: tipos de respuesta fijos, incertidumbre explícita, preguntas paralelas y ramificación controlada por código.
Eso lo hace un compañero útil para los modelos generativos. El LLM produce el plan, la explicación o el código. Jev enruta la solicitud, bloquea la acción riesgosa, verifica el resultado y decide cuándo la incertidumbre es suficientemente alta para escalar.
La idea más amplia importa incluso si otro modelo eventualmente reemplaza a Jev. Hemos pasado años pidiendo a los modelos generativos realizar todo tipo de inteligencia a través de texto. Muchos sistemas de producción no necesitan más palabras. Necesitan un pequeño y rápido juicio que el software ordinario pueda usar de manera segura.
Esa es la categoría que Jev está intentando construir.
Por dónde empezar
No empieces reconstruyendo tu agente alrededor de Jev. Encuentra una decisión que actualmente requiera una llamada lenta a un LLM o una expresión regular que siga rompiéndose.
Dale a Jev el estado mínimo, define las posibles respuestas y registra sus probabilidades junto al resultado actual. Deja que demuestre que merece una rama antes de entregarle todo el flujo de trabajo.
El modelo mental más útil sigue siendo el más simple → Jev agrega juicio donde una sentencia if ordinaria entiende los valores pero no su significado.
Fuentes y lecturas adicionales
- TypeSafe AI: Presentando Modelos de Sistema Uno y Jev
- LangChain: Construyendo un Harness con Jev
- Flavio Copes: Una mirada profunda a Jev
Espero que hayas disfrutado la lectura.
Nos vemos en la próxima.
¡Salud! :)
