Modelos de Decisión Tipados para Agentes: Jev vs Laya

1. El Problema: Llamadas LLM Donde Bastaría un Juez

Mira un agente de soporte típico. Antes de redactar cualquier respuesta debe contestar preguntas estrechas: quién atiende el caso, si la política lo cubre, qué urgencia tiene, si el mensaje es una inyección de prompt. Cada respuesta tiene un espacio acotado que puedes enumerar antes de ver el ticket. Y aun así la mayoría de stacks envía cada pregunta a un modelo de chat y reza para que el JSON parsee.

El patrón que lo arregla: el trabajo exacto queda en código, la generación queda en el LLM, y entre medias pones una puerta de juicio rápida. La puerta lee estado no estructurado y devuelve valores tipados con probabilidades. Umbrales, permisos y efectos secundarios quedan en software ordinario, donde puedes testearlos.

2. Conceptos Mínimos: Choice, Score, Noul, Calibración

Tanto Jev como Laya exponen los mismos tres tipos de pregunta. Aprende estas cuatro ideas y cada ejemplo de abajo se lee como inglés llano.

3. Tutorial, Parte 1: SDK de Jev en Python

Instala el SDK oficial, define TYPESAFE_API_KEY y llama a system_one con un estado más preguntas tipadas. Esta forma está copiada de los docs oficiales del SDK Python — los criteria de Choice son un mapa de opción a descripción (None para etiqueta simple), los de Score una lista ordenada, y las respuestas vuelven separadas en nouls, choices y scores.

Una llamada, tres juicios, en paralelo

# pip install typesafe-sdk  # TYPESAFE_API_KEY en env
from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

with TypeSafeClient() as client:
    response = client.system_one(
        state={"document": "I was charged twice. Please fix this ASAP."},
        questions={
            "billing": Noul(instructions="Is this ticket about billing?"),
            "tone": Choice(
                instructions="What is the customer tone?",
                criteria={"calm": None, "frustrated": None, "angry": None},
            ),
            "urgency": Score(
                instructions="How urgent is this ticket?",
                criteria=["can wait", "this week", "today"],
            ),
        },
    )

print(response.nouls["billing"].noul)    # P(yes), 0..1
print(response.choices["tone"].choice)   # etiqueta ganadora
print(response.scores["urgency"].score)  # posición ponderada, 0..2

Las preguntas de un mismo request comparten el estado preparado y se evalúan en paralelo — una décima pregunta cuesta tokens pero casi nada de tiempo extra. El modelo nunca autoriza nada: tu código lee las probabilidades y aplica la política, con una banda explícita de incertidumbre que va a humanos.

Puerta de política: actuar, revisar o re-rutear

p_billing = response.nouls["billing"].noul

if p_billing > 0.90:
    queue_refund_checks(state)      # el código verifica importes, identidad, límites
elif p_billing > 0.55:
    route_to_human(state, response) # la banda incierta va a revisión
else:
    route_to_specialist(state)

4. Tutorial, Parte 2: Router de Laya + el Flywheel

Laya corre en local y habla los mismos tres primitivos con schemas de diccionario. Empieza con los presets incluidos para triage inmediato, y usa el Router cuando el tráfico mezcle idiomas — inspecciona el script del input y elige el checkpoint por request con menos del 2% de overhead.

Triage con presets en tres líneas

# pip install laya
import laya

agent = laya.load("convaiinnovations/laya")  # 421M, inglés, ctx 512

triage = agent.predict(
    {"message": "My payment failed twice"},
    laya.triage_questions(),  # intent, urgency, frustration, churn
)

La misma tarea con Router.predict

from laya import Router

router = Router(preload=True)

decision = router.predict(
    {"message": "I was charged twice. Please refund the duplicate today."},
    {
        "owner": {
            "type": "choice",
            "instructions": "Which team owns the primary issue?",
            "criteria": {
                "billing": "charges, invoices, refunds, subscriptions",
                "technical": "product failures or errors",
                "account": "login, permissions, or account security",
                "other": "none of the listed teams fits",
            },
        },
        "refund_requested": {
            "type": "noul",
            "instructions": "Does the customer explicitly request a refund?",
        },
    },
)

El patrón flywheel (documentado en el estudio Jev-Flywheel) mantiene el motor congelado y adapta alrededor: reajusta una pequeña decision head sobre las respuestas cuando los revisores discrepan, y corre steering rounds donde un analista propone una pregunta nueva que un humano aprueba. Con las mismas 140 etiquetas y 600 ítems held-out, esa capa subió a Jev de 0.768 a 0.870 y a Laya de 0.722 a 0.802, calibrando ambos (ECE 0.030 y 0.015). El fine-tuning completo de los pesos abiertos de Laya con el mismo presupuesto llegó a 0.896 — más accuracy, pero el 42% de las respuestas no relacionadas derivaron, así que cada otro score debe revalidarse.

5. Errores Comunes en Producción

Estos cinco modos de fallo salen directos de los docs de limitaciones versionados de ambos modelos. Presupuesta los cinco antes de tu primera decisión en vivo.

Conclusión

La idea útil es más grande que cada producto: muchos pasos de un agente necesitan un juicio acotado, no otro párrafo. Jev lo empaqueta como API de decisiones gestionada con ventana de 64k que alquilas; Laya ofrece pesos inspeccionables Apache-2.0 con ventanas de 512/1024 tokens que posees, fine-tuneas y calibras tú.

Dale a cada capa el trabajo que mejor maneja: el código hace trabajo exacto y posee las acciones, un modelo de decisión testeado convierte texto en respuestas acotadas, los LLMs generan y razonan, los humanos resuelven la incertidumbre con consecuencias. Empieza esta semana reemplazando una llamada LLM de clasificación por una decisión tipada con umbral — esa sola puerta suele pagar el patrón entero.