Jev

1. Una nueva forma de utilizar la inteligencia artificial

El 15 de septiembre de 2026, una compañía llamada TypeSafe AI presentó, en acceso anticipado, Jev, su primer modelo de una categoría que denominó System One Models. La propuesta no pasó desapercibida y poco después otras compañías siguieron su estela con modelos como Microsoft-Decision-1, OpenAI Decisions o Liquid AI d1 API. Y no fue para menos, pues la verdad es que la propuesta es muy interesante, pero, antes de entrar en materia, vamos a analizar por qué lo llamaron y categorizaron así para comprender mejor qué es lo que se busca con este tipo de modelos.

En 2011, el psicólogo y premio Nobel de Economía Daniel Kahneman publicó un libro titulado Thinking, Fast and Slow (Pensar rápido, pensar despacio), en el cual exploraba cómo funciona el pensamiento humano y por qué nuestras decisiones no son tan racionales como creemos y muchas veces se basan en sesgos.

En el ensayo, Kahneman distinguía dos modos de procesamiento mental: uno es rápido, automático, intuitivo, prácticamente inconsciente y nos permite reaccionar y tomar decisiones sin esfuerzo aparente; y otro es lento, deliberado, analítico y aflora cuando necesitamos concentrarnos, razonar o resolver problemas complejos. Para nombrarlos adoptó los términos Sistema 1 y Sistema 2, propuestos antes por los psicólogos Keith Stanovich y Richard West, de donde se deriva el nombre de este tipo de modelos, que se espera que sean muy rápidos, como una idea fruto de la intuición.

Vamos ahora con el nombre del modelo. Jev recibe su nombre de William Stanley Jevons (1835-1882), un economista británico conocido por formular la paradoja de Jevons, la cual sostiene que, cuando una tecnología aumenta la eficiencia con la que utilizamos un recurso, su consumo total puede aumentar en lugar de disminuir.

Jevons lo observó en el siglo XIX con el carbón. Las máquinas de vapor cada vez más eficientes hicieron que utilizar carbón resultara más rentable, lo que impulsó su consumo. Y esta es la idea que los creadores de Jev trasladaron a la inteligencia artificial: cuanto más barata, rápida y eficiente sea la inteligencia artificial, más aplicaciones encontraremos para utilizarla y mayor será su consumo total.

Rapidez, por lo tanto, pero también eficiencia y utilidad. Veamos si estas tres características confluyen de verdad en este modelo.

2. Para qué sirve Jev

Jev es un modelo de IA diseñado para recibir información y responder preguntas cuyas posibles respuestas y tipos están definidos de antemano. Es decir, no genera libremente texto como un LLM convencional, sino que produce decisiones estructuradas, tipadas y acompañadas de probabilidades. Dicho de otra forma, responde indicando la probabilidad de que cada una de las respuestas posibles, fijadas de antemano, sea la más acertada.

Esto se entiende bien con un ejemplo. Si le preguntamos a un modelo tradicional si el gato es el animal más adorable del planeta tierra, nos responderá con cualquier parrafada de texto: «¡Científicamente no hay una respuesta definitiva, pero en el corazón de muchos, definitivamente sí!». Pero Jev nos responderá algo así:

{
    Sí: 60%
    No: 40%
}

Bueno, quizás no sea el ejemplo más evidente del mundo para explicar la utilidad de los modelos de Sistema 1, pero este otro caso espero que sí. Imaginemos un sistema para clasificar reseñas. Si es negativa, nuestro sistema debe responder con disculpas y, si es buena, con un agradecimiento. Jev nos vendría de perlas para esto, ya que bastaría enviarle la reseña y las posibles respuestas para obtener de forma muy rápida y barata algo así.

{
    Positiva: 70%
    Negativa: 30%
}

En síntesis, nos sirve como un modelo con una función de clasificación probabilística y esto TypeSafe lo presenta como una nueva primitiva de inteligencia para software.

3. ¿Cómo puede ser tan rápido?

Un LLM convencional escribe su respuesta token a token, de modo que cada palabra depende de las anteriores y hay que esperar a que termine la última. Jev no escribe nada. Según TypeSafe, rellena todos los campos de la respuesta de una sola pasada y en paralelo, cada uno con su probabilidad, y por eso añadir una pregunta más apenas cambia el tiempo de respuesta (su documentación recomienda precisamente eso, preguntar de más, porque sale casi gratis).

Esa es la explicación de la propia empresa y conviene tomarla como tal, porque no ha publicado la arquitectura, los pesos ni un artículo técnico. Lo que cuenta es que ha desarrollado una arquitectura nueva, un muestreador paralelo y un método de entrenamiento propio, Reinforcement Learning for Calibrated Decisions, con el que las probabilidades se optimizan frente a resultados reales y no frente a lo que prefiere un evaluador humano, como ocurre con el RLHF.

Dos cosas más. Jev es un modelo cerrado y alojado, que solo se usa a través de su API, así que dependemos de ellos. Y TypeSafe dice que Jev «no puede alucinar». Lo que garantiza es que la respuesta siempre tendrá la forma que hemos pedido, un choice que sea una de nuestras opciones o un número entre 0 y 1. No garantiza que acierte. Puede equivocarse como cualquier otro modelo, y para eso están las probabilidades, para saber cuándo fiarse.

4. Tres tipos de decisiones

Jev ofrece tres primitivas fundamentales:

• Choice. Cuando debe elegir entre alternativas. Por ejemplo, clasificar un ser vivo como mamífero, pescao o seta. Devuelve la opción seleccionada y una distribución de probabilidades entre las alternativas.

• Score. Cuando debe puntuar según una escala, como puede ser el caso de tener que valorar qué incidencia debe resolverse antes en una escala de 1 a 5, con criterios definidos para cada nivel. El valor devuelto es una posición entre esos niveles, contando desde 0, y puede quedar entre dos de ellos.

• Noul. Cuando debe evaluar una afirmación, como podría ser un guardarraíl en el que controlamos si un mensaje se ajusta o no a las cuestiones para las que está diseñado un modelo.

Además, el SDK oficial de TypeSafe AI permite integrar Jev en aplicaciones Python, JavaScript y TypeScript mediante una API sencilla. Para utilizarlo, debemos construir una petición que contiene tres elementos principales:

• model, que identifica el modelo que queremos utilizar (por ejemplo, jev-latest);
• state, que proporciona la información o el contexto sobre el que el modelo debe tomar decisiones;
• y questions, que define el conjunto de preguntas que queremos que Jev responda utilizando ese contexto.

state puede contener información estructurada, como mensajes, atributos de un usuario o datos de una operación. Dentro de questions, cada pregunta se identifica mediante una clave (por ejemplo, intent o urgent) y especifica su type, que determina el tipo de respuesta esperado: choice para elegir entre varias alternativas, score para asignar una puntuación y noul para evaluar la probabilidad de una afirmación. El campo instructions describe en lenguaje natural qué debe evaluar el modelo. Por ejemplo, "Identifica la intención principal del usuario" indica qué decisión debe tomar Jev a partir de la información proporcionada en state.

Por último, criteria permite definir las alternativas y su significado en las preguntas de tipo choice. Por ejemplo, podemos establecer cancel como «Cancelar la suscripción», refund como «Solicitar una devolución» y other como «Otra intención». En las de tipo score define los niveles de la escala, y en las noul es opcional y aclara qué significan el sí y el no. Jev analiza el contexto, interpreta las instrucciones y devuelve una respuesta estructurada con la alternativa seleccionada y sus probabilidades. La idea fundamental es separar los datos (state), las decisiones que queremos obtener (questions) y las reglas que describen cómo interpretarlas (instructions y criteria), permitiendo incorporar inteligencia probabilística a nuestra lógica de negocio sin delegar en el modelo la ejecución de las operaciones.

Aterricemos esto con un ejemplo de lo más cotidiano. Imaginemos que estamos desarrollando un sistema de selección de aventureros para una mazmorra. Un dragón acaba de solicitar refuerzos y necesitamos decidir a quién enviar, si representa un peligro y si merece la pena negociar con él.

Le enviamos a Jev esta petición:

{
  "model": "jev-latest",
  "state": {
    "message": "Soy Grumthar, dragón milenario. He devorado a los últimos doce caballeros que vinieron a rescatar a la princesa. Por cierto, ¿tenéis algún fontanero? El volcán está perdiendo lava."
  },
  "questions": {
    "intent": {
      "type": "choice",
      "instructions": "Identifica qué necesita el dragón",
      "criteria": {
        "combat": "Quiere luchar contra aventureros",
        "plumber": "Necesita un fontanero",
        "friendship": "Busca compañía"
      }
    },
    "dangerous": {
      "type": "noul",
      "instructions": "¿Representa un peligro mortal?"
    },
    "sanity": {
      "type": "score",
      "instructions": "Evalúa su estabilidad emocional",
      "criteria": [
        "Al borde del colapso",
        "Muy inestable",
        "Irritable pero manejable",
        "Estable",
        "Imperturbable"
      ]
    }
  }
}

Una posible respuesta simulada sería:

{
  "answers": {
    "intent": {
      "choice": "plumber",
      "probabilities": {
        "combat": 0.08,
        "plumber": 0.91,
        "friendship": 0.01
      }
    },
    "dangerous": {
      "noul": 0.99
    },
    "sanity": {
      "score": 2
    }
  }
}

Y nuestro software podría tomar la siguiente decisión:

dangerous = answers["dangerous"].noul
intent = answers["intent"].choice

if dangerous > 0.95:
    send_dragon_proof_plumber()
elif intent == "friendship":
    send_psychologist()
else:
    send_adventurers()

Resolución del Gremio de Aventureros

Enviar un fontanero ignífugo de nivel 80. Se desaconseja enviar caballeros. Doce precedentes desfavorables.

La gracia, como vemos, es que Jev no necesita escribir una historia sobre el dragón ni reflexionar durante varios segundos acerca de sus motivaciones. Evalúa tres preguntas concretas, devuelve decisiones tipadas y deja que nuestro programa determine qué hacer.

Veamos ahora un ejemplo más real.

5. Un último ejemplo

Con Jev podemos hacer muchas cosas, como poner guardarraíles a la entrada y a la salida de un sistema de IA. El mayor problema para revisar cada pregunta antes de enviarla al modelo principal y cada respuesta antes de mostrarla es que añadimos coste y latencia, incluso si usamos un modelo ligero. Como Jev es rápido y barato, puede venirnos genial para hacer esas comprobaciones.

Aunque se puede integrar con otras herramientas, como LangChain o Claude, para este artículo vamos directamente con Python.

Lo primero es registrarse en la web oficial, poner unos 5$ y sacar un api key. Lo guardamos en un archivo .env con el nombre TYPESAFE_API_KEY, que es la variable que lee el SDK, y lanzamos uv.

uv init --bare

Instalamos el sdk.

uv add typesafe-sdk

Ahora imaginemos que tenemos un bot asistente de una web de inglés y queremos que solo responda a cuestiones que de verdad tienen que ver con el aprendizaje de este idioma. Podríamos preparar algo así y guardarlo como main.py.

from typesafe_sdk import Noul, NoulCriteria, TypeSafeClient

pregunta = "¿Cuándo se usa el present perfect?"

# El SDK lee la clave de la variable de entorno TYPESAFE_API_KEY.
with TypeSafeClient(model="jev-latest") as client:
    respuesta = client.system_one(
        state=pregunta,
        questions={
            # Noul responde con una probabilidad de "sí" entre 0 y 1.
            "sobre_ingles": Noul(
                instructions="¿La pregunta está relacionada con aprender o practicar inglés?",
                criteria=NoulCriteria(
                    true=(
                        "Pide ayuda con gramática, vocabulario, pronunciación, "
                        "traducción, corrección o práctica del inglés."
                    ),
                    false=(
                        "Pide información o ayuda sobre otro tema, aunque "
                        "esté escrita en inglés."
                    ),
                ),
            ),
        },
    )

p = respuesta.nouls["sobre_ingles"].noul

# Tres vías en lugar de dos: lo claro se decide solo y lo dudoso lo ve una persona.
if p >= 0.7:
    print("Enviar al profesor")
elif p <= 0.3:
    print("Rechazar por estar fuera de tema")
else:
    print("Dudoso: que lo revise una persona")

Lo ejecutamos con uv run --env-file .env main.py, que carga el .env antes de lanzar el script.

Fíjate en que el resultado no es un sí o un no, sino un número. Eso nos deja fijar los umbrales según lo que cueste equivocarse (el 0,7 y el 0,3 son un punto de partida razonable) y mandar a una persona lo que queda en medio. Es más útil que una simple etiqueta de «confianza alta», porque permite construir políticas de ejecución y escalado cuantificables, y nos abre la puerta a diseñar agentes donde la inteligencia generativa se utiliza de forma selectiva y no como motor obligatorio de cada transición de estado.

6. ¿Confluyen de verdad?

Al principio nos preguntábamos si Jev reunía rapidez, eficiencia y utilidad. La utilidad creo que ha quedado a la vista con los ejemplos. Lo de la rapidez y la eficiencia es harina de otro costal y hay que mirarlo con lupa, porque las cifras de TypeSafe son suyas. Presumen de ser entre 40 y 200 veces más rápidos y baratos que los modelos de frontera, y en su propio blog reconocen que sus pruebas se ejecutan desde sus portátiles, que las respuestas de referencia son la media de otros LLM y que no pueden demostrar que su precio no esté subvencionado.

Hay una medición externa, un preprint de la Universidad de Texas en Austin llamado System1-Arena, que compara 30 modelos con las mismas peticiones. En tareas no agénticas, Jev 1.13 acierta un 72,6 %, algo más que GPT-6 Luna, un modelo rápido que se queda en el 71,2 %. Lo hace en 321 milisegundos frente a 1.276 y por unos 0,05 dólares cada mil peticiones frente a 0,14. Pero Claude Opus 5.5, con razonamiento, llega al 81,1 %, aunque tarda unos 2,3 segundos y cuesta unos 10 dólares. Y hay terrenos donde Jev flojea. En previsión acierta un 44 % frente al 62 % de Opus, y en los entornos agénticos de bucle cerrado se queda en un 17 % de éxito, por debajo de Luna.

Rápido y barato, entonces, sí; pero lo de superior es discutible.

Bueno, pues por hoy vamos a dejarlo aquí.

7. Para saber más

• Presentación de Jev y los modelos System One. La explicación de TypeSafe sobre qué problema intenta resolver Jev y cómo se diferencia de un modelo que genera texto.
• System1-Arena. El preprint de la Universidad de Texas en Austin que compara modelos System One con LLM, con las cifras que hemos comentado.
• Choice, Score y Noul. La documentación de las tres primitivas que hemos utilizado en los ejemplos.
• Guardarraíles para aplicaciones con LLM. Un ejemplo completo de comprobaciones a la entrada y a la salida, con decisiones tomadas por el código.
• SDK oficial de Python. Instalación y uso del cliente con el que hemos hecho la última prueba.