← todos los posts
agentes·21 de septiembre de 2026·6 min

Qué es Jev System One y cuándo conviene usarlo en tu backend

Aprendé a usar Jev System One para tomar decisiones tipadas sin loops generativos, bajando costos y latencia en tus agentes de IA.

Tu agente recibe una acción sensible (como borrar una base de datos) y le pedís a un LLM grande que te devuelva un JSON para decidir si la bloquea o no. El modelo procesa todo el contexto, genera 80 tokens palabra por palabra y vos rezás para que el JSON no venga roto.

Es un desperdicio enorme de cómputo. TypeSafe AI (startup fundada por Diogo Almeida, Erik Gafni y Sasha Sheng, con 40M USD de ronda seed liderada por DCVC) presentó Jev como su modelo de System One. En este post te explico cómo funciona Jev System One, qué cambia en tu arquitectura y cuándo te conviene usarlo para filtrar decisiones antes de gastar en modelos pesados.

Qué es a nivel computacional el modelo Jev System One

En psicología, el “Sistema 1” es el pensamiento rápido e intuitivo, mientras que el “Sistema 2” es el análisis lento y deliberado.

En software solemos usar modelos autorregresivos (que generan texto token por token sobre vocabularios gigantes) para tareas simples como clasificar tickets, enrutar datos o validar permisos. No tiene sentido gastar memoria y tiempo en generar un JSON cuando solo necesitás un booleano.

flowchart TD
    subgraph Generativo["Pipeline Generativo Tradicional"]
        A["Input + Prompt + JSON Schema"] --> B["Prefill (Prompt Processing)"]
        B --> C["Autoregressive Loop (Token x Token)"]
        C --> D["Parsing JSON / Pydantic Validation"]
        D --> E["Decisión Final (Riesgo de parsing error)"]
    end

    subgraph SystemOne["Pipeline Discriminativo Nativo (Jev)"]
        F["State + Typed Questions"] --> G["Single Forward Pass (sin loop autorregresivo)"]
        G --> H["Salidas tipadas en paralelo"]
        H --> I["Typed Decision + Calibrated Probabilities"]
    end

Cómo resuelve cada pregunta (sin generar texto)

TypeSafe no hizo pública la arquitectura interna de Jev. En la documentación oficial de TypeSafe AI solo aclara que usa un “parallel sampler” para resolver las respuestas en paralelo. La comunidad infiere que actúa como un backbone discriminativo con cabezales tipados, sin emitir texto.

Hacia afuera, el modelo devuelve tres tipos de datos concretos:

  1. Noul (Binario): una respuesta a una pregunta por sí o por no, que devuelve la probabilidad continua (de 0 a 1) de que una afirmación sea verdadera.
  2. Choice (Categórico): una opción dentro de un conjunto cerrado de opciones, con la distribución de probabilidad y un puntaje de confianza.
  3. Score (Ordinal): un valor numérico continuo calibrado sobre niveles ordenados (como bajo, medio y alto), junto con su distribución y confianza.

Calibración vía RLCD (Reinforcement Learning for Calibrated Decisions)

Jev aplica RLCD (Reinforcement Learning for Calibrated Decisions) en su fine-tuning para calibrar las probabilidades. Un softmax clásico suele tener sobreconfianza y marca 0.99 en aciertos reales del 75%.

Con RLCD, si el modelo devuelve 0.70 en una probabilidad, cerca de 7 de cada 10 casos con ese puntaje deberían ser positivos reales. TypeSafe no dio más detalles del entrenamiento, así que el nombre es lo único confirmado.

Desarmando el mito de “cero alucinaciones”

TypeSafe AI dice en su marketing que Jev “no puede alucinar”. Conviene separar la estructura del contenido:

  • Garantía estructural (Verdadera): no hay errores de sintaxis, JSON truncados, llaves sin cerrar ni tipos mal convertidos. El resultado no nace de un texto parseado, sino de salidas directamente tipadas.
  • Infalibilidad semántica (Falsa): el modelo puede equivocarse al decidir. Puede marcar una acción destructiva como segura o asignar 0.85 de certeza a una categoría errónea.

La ventaja real es que el error queda limitado a la decisión estadística, sin romper tu código por problemas de serialización.

Implementación: API, latencias y branching condicional

La latencia de Jev va de 70 a 500 ms (el valor típico ronda los 100 ms). El piso corresponde a estados chicos con pocas preguntas; el techo aparece cuando el contexto es largo y hay muchas preguntas juntas.

Cuesta 0.042 USD por millón de tokens de entrada y no cobra por tokens de salida. Su rol ideal en tu backend es funcionar como filtro previo o compuerta de paso.

import os
import requests

API_URL = "https://api.typesafe.ai/v1/systemone"
API_KEY = os.environ["TYPESAFE_API_KEY"]  # la key vive en SSM/env, nunca hardcodeada

payload = {
    "model": "jev-latest",
    "state": {
        "user_role": "billing_admin",
        "action": "delete_tenant_database",
        "account_balance": -150.00,
        "is_enterprise": True,
    },
    "questions": {
        "is_high_risk": {
            "type": "noul",
            "instructions": "Is this action destructive or a commercial risk?",
        },
        "routing_lane": {
            "type": "choice",
            "instructions": "Determine the execution priority queue.",
            "criteria": {
                "automated_execution": "Safe, reversible, low impact.",
                "tier2_support": "Needs a human operator.",
                "compliance_hold": "Legal or financial review required.",
            },
        },
    },
}

resp = requests.post(
    API_URL,
    json=payload,
    headers={"Authorization": f"Bearer {API_KEY}"},
    timeout=10.0,
)
resp.raise_for_status()
answers = resp.json()["answers"]

# Gating por umbral de probabilidad calibrada
THRESHOLD = 0.80
risk_prob = answers["is_high_risk"]["noul"]        # 0..1
lane = answers["routing_lane"]["choice"]
lane_conf = answers["routing_lane"]["confidence"]

if risk_prob < THRESHOLD or lane_conf < THRESHOLD:
    print(f"[FALLBACK] Certeza marginal ({risk_prob:.2f} / {lane_conf:.2f}). A revisión humana.")
elif risk_prob >= THRESHOLD:
    print(f"[INTERRUPT] Acción crítica ({risk_prob:.2f}). Cola: {lane}")
else:
    print(f"[EXECUTE] Autorizada ({risk_prob:.2f})")

Arquitectura de gating: Caso de uso en pipeline editorial

El mejor uso de un modelo System One es filtrar contenido antes de llamar a modelos de razonamiento caros. Si recibís miles de artículos por RSS, podés evaluar la relevancia técnica primero.

flowchart TD
    A["Payload de Entrada (RSS / Contexto)"] --> B["Jev System One (70-100 ms)"]
    B --> C{"Validación de Relevancia Técnica (Score >= 0.70 & Prob >= 0.85)"}
    C -- "No cumple umbral" --> D["Drop / Fast-path Log (Costo marginal ~0)"]
    C -- "Aprobado" --> E["Modelo de Frontera / Razonamiento (~3-10s)"]
    E --> F["Generación y Síntesis Final"]

Con este esquema descartás rápido (en menos de 100 ms) cerca del 85% del volumen irrelevante. Así no gastás tokens de un modelo generativo en textos que no valen la pena.

Tradeoffs técnicos: Jev vs. SLMs locales vs. Structured outputs

Antes de sumar una API cerrada a tu stack, compará las opciones disponibles:

Dimensión LLM de Frontera / Tier Razonamiento SLM Compacto (Tier Mini / Grammars) Modelo Open-Weight In-House (ModernBERT / DeBERTa) System One Dedicado (Jev)
Mecanismo Generación autorregresiva token x token Constrained decoding (JSON Schema) Forward pass nativo con clasificación heads Forward pass único, respuestas tipadas (calibradas vía RLCD)
Latencia típica 1.500 ms – 6.000 ms 200 ms – 600 ms 15 ms – 40 ms (vía TensorRT / ONNX) 70 ms – 500 ms
Costo por 1M tokens 2.00 USD – 15.00 USD 0.15 USD – 0.60 USD Costo fijo de cómputo propio (GPU/vCPU) 0.042 USD (salida gratis)
Garantía de tipo Probabilística con auto-corrección Guiada por gramática (Grammar-masking) Estructural por cabezal de salida Estructural por cabezal de salida
Calibración empírica Pobre (sobrecalibrado) Regular Requiere fine-tuning manual de calibración Alta (calibración nativa vía RLCD)
Lock-in / Infraestructura API de terceros API de terceros o weights abiertos Control total, zero egress, sin lock-in API propietaria de TypeSafe AI

Cuándo tiene sentido cada alternativa

  1. SLM propio (In-House): si ya tenés clústeres propios (Triton, TensorRT-LLM) y datos etiquetados. Lográs latencias sub-30ms sin enviar datos afuera ni pagar por llamada.
  2. Structured Outputs en SLM mini: si tu flujo necesita extraer texto libre, reformatear código o sacar entidades abiertas junto a la decisión.
  3. Jev (System One API): si buscás ramificar lógica sobre texto o JSON sin mantener infraestructura propia, con buena calibración y menor costo que un LLM generalista.

Qué auditar el lunes en tu arquitectura

  1. Medí tu consumo real de tokens: revisá en tus métricas cuántas llamadas a LLMs gastan más de 500 tokens solo para sacar un booleano o elegir una categoría.
  2. Sumá compuertas condicionales: antes de invocar herramientas de escritura o modelos caros, poné un clasificador con umbral estricto (probabilidad mayor o igual a 0.80). Si no llega al corte, frenás la ejecución.
  3. Dividí las tareas del pipeline: usá modelos rápidos de un solo paso para validar datos y tomar decisiones de control. Dejá los modelos generativos solo para redactar y transformar texto.

No hace falta meter el LLM más grande en cada rincón de tu sistema. Lo más eficiente es armar un flujo donde la generación pesada solo arranque cuando los filtros previos confirmen que es necesario.

¿Y la versión open-weights? Corrí Jev contra Laya, el modelo System One open-source, sobre los mismos titulares. Spoiler: el trade-off es conveniencia cerrada vs control local.