Jev, la IA que decide sin escribir: la he puesto a prueba contra GPT

Desde que llegó ChatGPT, los modelos de los que todo el mundo habla son chatbots: les haces una pregunta y te responden escribiendo. El 15 de septiembre salió el primero de su especie que no lo es. Se llama Jev, lo ha creado TypeSafe AI y no sabe escribir ni una palabra: toma decisiones y, junto a cada una, te dice lo seguro que está. Sus creadores prometen un flujo de trabajo 193 veces más rápido que un LLM de frontera. Una promesa así había que comprobarla, y lo hice: 105 correos de clientes de un software de gestión, seis modelos, dos idiomas y una comparación solo entre modelos que se equivocan tanto como Jev. Aquí tienes cómo fue, con el método, las tablas y el código Delphi.

Si has metido un LLM dentro de una aplicación de gestión, tarde o temprano lo habrás usado para una decisión pequeña: a qué departamento va este correo, qué tipo de documento acaba de llegar, si el cliente está enfadado. Funciona. Pero cada decisión te cuesta uno o dos segundos, además de los tokens de salida, y con diez mil correos al día el tiempo y la factura se convierten en el problema.

El 15 de septiembre TypeSafe AI anunció Jev, un modelo que no sabe escribir ni una palabra y solo devuelve decisiones. En su página principal asegura que un flujo de trabajo con Jev es 193,6 veces más rápido y 444,6 veces más barato que con un LLM de frontera. Hablé de ello en el episodio 7 del podcast “while true do;” (en italiano), donde prometí publicar aquí el método, las tablas y el código Delphi.

Qué es Jev

Le das un contexto, que TypeSafe llama state (el texto de un correo, un registro), y unas preguntas tipadas. Hay tres tipos:

• choice: elegir una de hasta 255 opciones, cada una descrita con palabras;
• score: situar el texto en una escala de 2 a 10 niveles;
• noul: una pregunta de sí o no, y la respuesta es la probabilidad del sí.

Nunca te devuelve texto que tengas que interpretar. Recibes la opción elegida, la distribución de probabilidad sobre todas las opciones y una confianza. Todas las preguntas se calculan en una sola pasada, así que añadir una apenas cambia el tiempo de respuesta. El precio oficial es de 0,042 dólares por millón de tokens de entrada, y la salida no se paga.

Desde el 18 de septiembre Jev también está en OpenRouter, en el endpoint POST /api/v1/systemone. Es lo que he usado yo: con una sola clave llamas tanto a Jev como a los LLM con los que lo comparas, y todos los tiempos incluyen el mismo paso por OpenRouter.

Llamarlo desde Delphi

La llamada es un POST con un cuerpo JSON, así que te bastan THTTPClient y System.JSON, sin ningún SDK. Esta es la petición que arma JevTriage_en, el programa de demostración: tres preguntas sobre un correo, una por tipo.

// The three questions for Jev: department (choice), frustration (score), urgency (noul).
function BuildJevRequest(const AModel, AEmail: string): string;
begin
  var lRoot := TJSONObject.Create;
  try
    lRoot.AddPair('model', AModel);
    lRoot.AddPair('state', AEmail);
    var lQuestions := TJSONObject.Create;
    lRoot.AddPair('questions', lQuestions);   // from here on lRoot owns it

    var lDepartments := TJSONObject.Create;
    lDepartments.AddPair('administration', 'Invoices, payments, charges, refunds');
    lDepartments.AddPair('technical support', 'Program errors, freezes and malfunctions');
    lDepartments.AddPair('sales', 'Quotes, new modules, licenses, training');
    lDepartments.AddPair('other', 'None of the above');   // always include the fallback option
    lQuestions.AddPair('department', TJSONObject.Create
      .AddPair('type', 'choice')
      .AddPair('instructions', 'Which department should handle this email?')
      .AddPair('criteria', lDepartments));

    var lLevels := TJSONArray.Create;
    lLevels.Add('Calm, states the facts');
    lLevels.Add('Annoyed but polite');
    lLevels.Add('Very angry, harsh tone');
    lQuestions.AddPair('frustration', TJSONObject.Create
      .AddPair('type', 'score')
      .AddPair('instructions', 'How frustrated is the customer?')
      .AddPair('criteria', lLevels));

    lQuestions.AddPair('urgent', TJSONObject.Create
      .AddPair('type', 'noul')
      .AddPair('instructions', 'Is the request urgent or does it have a close deadline?'));

    Result := lRoot.ToJSON;
  finally
    lRoot.Free;
  end;
end;

Esta es la versión en inglés de la demo. En el zip está también el original en italiano, JevTriage, porque en una empresa de software italiana los correos llegan en italiano. Si trabajas con System.JSON y quieres repasar la API fluida y quién es dueño de qué, tienes la guía completa de JSON en Delphi.

La respuesta se lee con GetValue<T> y una ruta: answers.department.choice, answers.department.confidence, answers.urgent.noul. Después es el código, no el modelo, el que decide el enrutamiento comparando la confianza con dos umbrales:

// Routing is decided by the code, not by the model: confidence is just a number to compare.
function RouteByConfidence(const ADepartment: string; AConfidence: Double): string;
begin
  if (ADepartment = 'other') or (AConfidence < HUMAN_THRESHOLD) then
    Result := 'to an operator (a person decides)'
  else if AConfidence >= AUTO_THRESHOLD then
    Result := Format('automatic to "%s"', [ADepartment])
  else
    Result := Format('to "%s" with caution (needs confirmation)', [ADepartment]);
end;

AUTO_THRESHOLD vale 0,85 y HUMAN_THRESHOLD vale 0,5. Más abajo verás que 0,85 es optimista.

Cuatro correos, una ejecución real

JevTriage_en manda los mismos cuatro correos a Jev y a google/gemini-2.5-flash-lite, al que le pide que escriba un JSON con los mismos tres campos. Esta es la salida completa de una ejecución real de hoy:

Email 1: "Good morning, this month you charged the fee for the management software twice to our company card. Could you reverse the second charge? Thanks, Marta Rossi"
  Jev (typesafe/jev-1.13-20260917) in 455 ms
    department:   administration  (confidence 1.00)
                  administration=1.00  other=0.00  technical support=0.00  sales=0.00  
    frustration:  0.04 of 2  (confidence 0.95)
                  0=0.96  1=0.04  2=0.00  
    urgent:       no  (probability of yes 0.21)
    routing:      automatic to "administration"
  LLM (google/gemini-2.5-flash-lite) in 1101 ms
    department: administration, frustration: 1, urgent: true  (no probabilities, no confidence)

Email 2: "Since this morning, whenever I print an invoice the program closes with a memory access error. I have forty invoices to send out by tonight, I don't know what to do anymore!!!"
  Jev (typesafe/jev-1.13-20260917) in 373 ms
    department:   technical support  (confidence 0.99)
                  technical support=1.00  sales=0.00  administration=0.00  other=0.00  
    frustration:  1.75 of 2  (confidence 0.62)
                  0=0.00  1=0.25  2=0.75  
    urgent:       yes  (probability of yes 0.98)
    routing:      automatic to "technical support"
  LLM (google/gemini-2.5-flash-lite) in 715 ms
    department: technical support, frustration: 2, urgent: true  (no probabilities, no confidence)

Email 3: "Hello, we are a firm with twelve workstations and we would like a quote for the warehouse module and for staff training. No rush."
  Jev (typesafe/jev-1.13-20260917) in 365 ms
    department:   sales  (confidence 1.00)
                  sales=1.00  other=0.00  administration=0.00  technical support=0.00  
    frustration:  0.00 of 2  (confidence 1.00)
                  0=1.00  1=0.00  2=0.00  
    urgent:       no  (probability of yes 0.04)
    routing:      automatic to "sales"
  LLM (google/gemini-2.5-flash-lite) in 524 ms
    department: sales, frustration: 0, urgent: false  (no probabilities, no confidence)

Email 4: "Hi, I just wanted to tell you that yesterday's course was really useful. See you soon!"
  Jev (typesafe/jev-1.13-20260917) in 401 ms
    department:   other  (confidence 0.82)
                  other=0.87  administration=0.00  technical support=0.00  sales=0.13  
    frustration:  0.00 of 2  (confidence 1.00)
                  0=1.00  1=0.00  2=0.00  
    urgent:       no  (probability of yes 0.02)
    routing:      to an operator (a person decides)
  LLM (google/gemini-2.5-flash-lite) in 575 ms
    department: other, frustration: 0, urgent: false  (no probabilities, no confidence)

Email   Jev ms   LLM ms   Jev token in/out   LLM token in/out   Jev cost       LLM cost
    1      455     1101         460 / 84            113 / 18    $0.0000193     $0.0000185
    2      373      715         467 / 82            121 / 19    $0.0000196     $0.0000197
    3      365      524         459 / 81            110 / 18    $0.0000193     $0.0000182
    4      401      575         450 / 81            104 / 18    $0.0000189     $0.0000176
Total     1594     2915                                        $0.0000771     $0.0000740

Costs come from OpenRouter's usage.cost field (in credits, 1 credit = 1 USD).
Timings include the hop through OpenRouter.

El primer correo es un cargo duplicado, escrito con calma. Según Flash Lite el cliente está molesto y la petición es urgente. Jev dice que está tranquilo y que no es urgente, y lo dice con las probabilidades al lado.

El cuarto correo es una nota de agradecimiento, y aquí los dos coinciden: other, tranquilo, no urgente. Jev elige other con una confianza de 0,82, y el código manda el correo a un operador, como hace con cualquier other sea cual sea la confianza.

En cuanto al coste, con tres preguntas Jev cuesta lo mismo que Flash Lite, incluso un poco más: la petición a Jev ocupa unos 460 tokens de entrada, la del LLM unos 110. La ventaja de precio de Jev es la salida gratuita, y con tres respuestas cortas hay poco que ahorrar en salida. Pero cuatro correos no demuestran nada, y Flash Lite es el modelo más barato de la lista: por eso escribí JevBench.

El benchmark: 105 correos, seis modelos

El benchmark hace el mismo trabajo a gran escala, con estas reglas:

• 105 correos de clientes de una empresa que desarrolla software de gestión: cargos duplicados, facturas rechazadas por el SDI (el sistema italiano de intercambio de facturas electrónicas), nóminas que no se calculan, peticiones de presupuesto, bajas, spam, phishing. 61 son difíciles a propósito: sarcasmo, frustración contenida, negaciones (“no es urgente, pero para mañana por la mañana…”), una petición escondida en la posdata de una newsletter;
• 25 preguntas por correo (departamento, módulo de la aplicación, frustración, urgencia, petición de reembolso, amenaza de irse, datos sensibles, etc.), formuladas en grupos de 3, 10 y 25 por llamada;
• seis modelos vía OpenRouter: Jev 1.13, Gemini 2.5 Flash Lite, GPT-5.6 Luna, GPT-5.6 Terra, Gemini 3.1 Pro, DeepSeek V4 Pro. Las mismas instrucciones para todos, sin ajustar el prompt;
• la exactitud equilibrada (balanced accuracy) como métrica principal, con intervalos de confianza bootstrap al 95%. La exactitud simple premia a un modelo que siempre responde “no”: aquí un modelo que diera siempre la clase más frecuente tendría un 84% de exactitud simple y un 41% de equilibrada;
• primero la calidad, después los tiempos: la velocidad y el coste solo los comparo entre Jev y el LLM más barato que se equivoca tanto como Jev o menos. Un modelo diez veces más barato que falla uno de cada tres correos no sirve como sustituto de Jev.

No hay ningún modelo de Anthropic, y no es que les tenga manía: las respuestas esperadas las escribió y revisó Claude Opus 5, y un modelo de la misma familia partiría con ventaja en los casos límite. Yo fijé las reglas de etiquetado y decidí personalmente el caso más discutido; los demás casos discutidos los decidió el mismo modelo en mi nombre, y nadie volvió a comprobar a mano cada etiqueta.

La prueba principal es en inglés, porque TypeSafe dice que Jev rinde mejor en inglés y no quería ponerlo en desventaja sin decirlo. Después la repetí en italiano.

Quién entiende más

Cada celda te dice cuánto ha entendido un modelo en los 105 correos en inglés, con ese número de preguntas por llamada. Las columnas no son tres ejecuciones de la misma prueba: “3 decisiones” son las tres primeras preguntas (departamento, frustración, urgencia), “10” las diez primeras, “25” todas. Cada columna añade preguntas nuevas, algunas más difíciles, y por eso Jev baja de 97,2 a 94,8: con 25 entra también el impacto del problema en el cliente, donde Jev se queda en el 68%.

El número es la exactitud equilibrada, en porcentaje. Para cada pregunta, cada respuesta posible se puntúa por separado: para “urgente”, tomas la proporción de correos urgentes que el modelo reconoció como urgentes y la de no urgentes que reconoció como no urgentes, y haces la media de las dos. Después haces la media de todas las preguntas. Así una respuesta rara cuenta tanto como una frecuente. Un modelo que a “urgente” responde siempre “no” acierta 88 correos de 105, pero aquí saca un 50. Dar siempre la respuesta más frecuente a cada pregunta saca 34,4 con 3 decisiones, 39,4 con 10 y 41,4 con 25: ese es el mínimo con el que comparar la tabla.

Entre corchetes va el intervalo de confianza al 95%. Lo calculé remuestreando al azar los 105 correos 2000 veces (bootstrap): con otra muestra de correos parecidos, el resultado caería casi siempre dentro de ese intervalo. Cuanto más ancho es el intervalo, menos preciso es el número, y con 3 preguntas es ancho porque cada error pesa más. Pero para decidir si un LLM es mejor o peor que Jev no basta con mirar si los intervalos se solapan: comparé cada modelo con Jev correo a correo, sobre los mismos remuestreos, y solo cuentan las diferencias cuyo intervalo no incluye el cero.

Con 3 y con 10 decisiones por llamada ningún LLM lo hace mejor que Jev con un margen que se pueda distinguir del ruido. Con 25 solo Gemini 3.1 Pro lo supera, por 2,3 puntos [0,9; 3,7]. Flash Lite es peor en todos los niveles, así que su tropiezo con los cuatro correos de antes no fue mala suerte.

Ningún modelo devolvió un JSON roto en las 2835 llamadas del benchmark, 1890 en inglés y 945 en italiano. Con los modelos de hoy los errores de esquema son raros, así que para elegir Jev hacen falta otros motivos.

Cuánto más rápido, cuánto más barato

Jev responde en un tercio de segundo, más o menos, y tarda lo mismo con 3 preguntas que con 25: 320, 341 y 337 ms de media. Los LLM, en cambio, tienen que escribir cada respuesta, y se ralentizan: GPT-5.6 Terra pasa de 1397 a 2338 ms, Gemini 3.1 Pro de 4625 a 7151.

Esta tabla, para la ejecución en inglés, compara Jev con el LLM más barato cuya exactitud iguala a la de Jev en cada nivel:

La relación de costes la calculé con los precios de hoy en OpenRouter, así que cambia en cuanto cambia un precio. Los tiempos incluyen el paso por OpenRouter, que desde aquí añade entre 20 y 30 ms de ida y vuelta (mediana de 20 ms en la ejecución en inglés, 28 en la italiana).

Si comparas Jev con un modelo de frontera, los números crecen. Mil correos con 25 preguntas cuestan 0,08 dólares con Jev, 2,17 con GPT-5.6 Terra y 11,82 con Gemini 3.1 Pro, que además tarda 21 veces más que Jev. Veintiuna veces sigue estando muy lejos de 193, pero enseña de dónde salen los números de TypeSafe: comparan Jev con modelos de frontera.

En italiano

En italiano repetí la prueba con Jev y los dos modelos de OpenAI:

La calidad de Jev se queda donde estaba en inglés. La única diferencia que se sostiene estadísticamente se da con 3 decisiones, 1,9 puntos [0,6; 3,7]. Los LLM, en cambio, se ralentizan en italiano, porque el mismo correo ocupa más tokens: con 25 decisiones GPT-5.6 Luna pasa de 1886 a 2864 ms, mientras que Jev pasa de 337 a 348.

Los correos en inglés son una traducción hecha por un LLM de originales en italiano escritos por un LLM. Una diferencia entre los dos idiomas también podría venir de la traducción. El script build_en.py comprueba que cada correo traducido conserve las respuestas esperadas del original, pero el estilo no lo puede comprobar.

La confianza: ¿“no puede alucinar”?

TypeSafe dice que Jev no puede alucinar. Eso vale para la forma: no te devolverá un campo que no pediste ni una opción que no existe. Los errores de juicio siguen ahí. Si le preguntas algo que el texto no dice, no puede responder “no lo sé”: reparte la probabilidad entre las opciones que le diste y elige una. Por eso la opción other del código de arriba no es opcional.

Lo que te protege es la confianza. La tabla muestra las respuestas choice y score de Jev, con 25 decisiones, agrupadas por confianza declarada:

(El número de respuestas y la confianza media son de la ejecución en inglés.)

Por encima de 0,95 la confianza se sostiene. En la zona intermedia Jev es optimista: cuando dice 0,90 acierta algo más de tres veces de cada cuatro. La confianza sube junto con la exactitud, así que es útil, pero el umbral lo tienes que medir con tus propios datos. Con estos números, el 0,85 de JevTriage_en dejaría pasar de forma automática bastantes respuestas equivocadas: en mis datos el umbral razonable para actuar sin confirmación es 0,95.

Lo que no demuestra

La prueba vale para una tarea: correos de clientes de un software de gestión italiano, con las mismas instrucciones para todos. No te dice cómo se comportan los modelos en otros dominios, qué sacarían los LLM con un prompt bien trabajado o con unos cuantos ejemplos, ni cuánto varía el resultado de una ejecución a otra, porque solo hay una ejecución. Los correos difíciles están sobrerrepresentados a propósito, así que los porcentajes absolutos son más bajos de lo que verías con tráfico real. Y las respuestas esperadas las escribió un LLM, no un equipo de personas con café y mucha paciencia.

Hay dos cosas que decidir antes incluso de probarlo. Hoy Jev es solo una API en la nube, en acceso anticipado, sin pesos publicados y sin instalación on-premise: los correos de tus clientes salen de tu infraestructura y van a una startup que salió a la luz hace una semana, tras dos años trabajando en secreto. Y la configuración fija typesafe/jev-1.13, no el alias jev-latest, porque los umbrales de confianza valen para una versión concreta.

Descárgalo y pruébalo

El código está aquí: jev-delphi-demo.zip. Dentro encontrarás la demo en inglés (JevTriage_en) y en italiano (JevTriage), JevBench, el dataset en italiano y en inglés, los resultados completos con los CSV y bench/METODOLOGIA.md, que explica cada decisión con mucho más detalle que este artículo.

Necesitas Delphi 13 (debería funcionar también en 12 y 11, pero no lo he probado), el código fuente de DelphiMVCFramework para MVCFramework.DotEnv, que lee el archivo .env, y una clave de OpenRouter con algo de crédito. Copia .env.example como .env, pon tu clave y compila:

call "C:\Program Files (x86)\Embarcadero\Studio\37.0\bin\rsvars.bat"
msbuild JevTriage_en.dproj /p:Config=Debug /p:Platform=Win64
JevTriage_en.exe

JevTriage_en cuesta menos de un centavo de dólar. Con seis modelos JevBench hace 1890 llamadas por idioma y tarda una hora larga. La ejecución en inglés costó unos 3,5 dólares; la italiana, con tres modelos y 945 llamadas, unos 0,9. Antes de lanzarlo, prueba JevBench.exe --selftest, que ejecuta todos los informes sobre resultados inventados sin llamar a ningún modelo. Cualquier argumento desconocido detiene el programa, así que un argumento mal escrito no pone en marcha una ejecución de pago.

Para mi opinión, es decir, dónde lo pondría en una aplicación de gestión y dónde no, escucha el episodio 7 de “while true do;” (en italiano). La paradoja de Jevons, de la que Jev toma el nombre, está en los episodios 4 y 5 (en italiano). La documentación oficial de Jev está en docs.typesafe.ai.

Preguntas frecuentes

¿Qué es Jev de TypeSafe AI? Jev es un modelo que TypeSafe AI llama “System One”: no genera texto, recibe un contexto y unas preguntas tipadas (choice, score, noul) y devuelve para cada una la respuesta, la distribución de probabilidad sobre las opciones y una confianza. Se anunció el 15 de septiembre de 2026 y se usa a través de una API, directamente con TypeSafe o vía OpenRouter.

¿De verdad Jev es 200 veces más rápido que un LLM? En el benchmark de Daniele Teti con 105 correos de un software de gestión, Jev fue de 4 a 8 veces más rápido que el LLM más barato con la misma exactitud, y unas 20 veces más rápido que Gemini 3.1 Pro. Las cifras de 193 veces del fabricante vienen de flujos de trabajo elegidos por TypeSafe y comparan Jev con modelos de frontera.

¿Jev se equivoca menos que GPT y Gemini? Con 3 y 10 decisiones por llamada ninguno de los LLM probados supera a Jev en exactitud equilibrada. Con 25 decisiones solo Gemini 3.1 Pro es mejor, por unos 2 puntos. Gemini 2.5 Flash Lite es peor en todos los niveles.

¿Es fiable la confianza de Jev? En la parte alta, sí: por encima de 0,95 Jev acertó el 96,5% de las veces. En la franja intermedia es demasiado optimista: cuando declara alrededor de 0,90 acierta el 77,6% de las veces. Por eso el umbral para pasar un caso a una persona hay que ajustarlo con tus propios datos.

¿Cómo se llama a Jev desde Delphi? Con un POST JSON al endpoint /api/v1/systemone de OpenRouter, usando THTTPClient y System.JSON de la RTL. El código completo, benchmark incluido, se puede descargar desde danieleteti.it.

¿Quién escribió las respuestas esperadas del benchmark? Las respuestas esperadas las escribió y revisó Claude Opus 5. Daniele Teti fijó las reglas y decidió el caso más discutido; los demás casos discutidos los decidió el mismo modelo en su nombre, y nadie volvió a comprobar a mano cada etiqueta. Por eso no hay ningún modelo de Anthropic en la comparación.