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 el punto clave.
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 fragmento 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 si el formato es incorrecto. Eso 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 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 resuelve Jev
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 devolver JSON que sigue un esquema. Ambos 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 elige una opción de una lista que defines y devuelve una probabilidad para cada opción.
- Score coloca la entrada en una escala ordenada que defines, como baja, media y alta.
- Noul responde a una pregunta de sí o no devolviendo la probabilidad de que sea verdadera.
Noul es el nombre que TypeSafe usa para la primitiva estilo booleano. El nombre inusual importa menos que la salida (un número entre 0 y 1 sobre 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 probabilidades 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 proporciona 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 distintas partes de un sistema.
TypeSafe dice que Jev evalúa todas las preguntas de 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 gratuita. Sus afirmaciones principales alcanzan aproximadamente 200 veces más rápido y 400 veces más barato que los flujos de trabajo comparables con 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 cadenas de razonamiento y salida generada porque fue diseñado para decisiones acotadas.
Por qué importan las probabilidades
Una respuesta tipada solo resuelve 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 probabilidades te dice cuán reñida fue 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 en un 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 utilizando 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 un conjunto de respuestas con un 90 por ciento de probabilidad, 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 facturación, técnica y ventas, 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 incorrecta.
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 enrutador 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 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 LangChain con Jev 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 estricta cuando exista 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
- Clasificar intención, urgencia, departamento, spam y frustración del cliente.
- Enrutar reembolsos y excepciones de políticas a través de varias comprobaciones pequeñas.
- Clasificar logs 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
- Reclasificar fragmentos recuperados según si responden a la consulta.
- Verificar si una cita respalda una afirmación.
- Filtrar 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 fragmento particular es útil para esta pregunta.
Calidad y seguridad
- Filtrar prompts para jailbreaks o inyección de prompts.
- Verificar contenido generado contra una política o rúbrica.
- Marcar 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
- Etiquetar documentos, papers de investigación, listados de productos o mensajes de clientes.
- Convertir texto libre en características para un modelo tradicional de aprendizaje automático.
- Puntuar 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
- Elegir la siguiente acción del navegador de elementos de página conocidos.
- Puntuar tono o claridad mientras una persona escribe.
- Seleccionar una acción desde un estado estructurado de juego o simulador.
Jev es solo texto hoy, por lo 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 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 limitados de calibración independiente 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 y 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 primero la rama más segura 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: versiona, revisa y prueba 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, explicación o código. Jev enruta la solicitud, controla 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 que realicen 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 intenta 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 los Modelos Sistema Uno y Jev
- LangChain: Construyendo un Harness con Jev
- Flavio Copes: Una inmersión profunda en Jev
Espero que hayas disfrutado la lectura.
Nos vemos en la próxima.
¡Salud! :)
