Typed Decision Models for Agents: Jev vs Laya

1. The Problem: LLM Calls Where a Judge Would Do

Look at a typical support agent. Before it drafts any reply it must answer narrow questions: who owns the case, does the policy cover it, how urgent is it, is this message a prompt injection. Each answer has a bounded space you can enumerate before seeing the ticket. Yet most stacks send each question to a chat model and pray the JSON parses.

The pattern that fixes it: keep exact work in code, keep generation in the LLM, and put a fast judgment gate between them. The gate reads unstructured state and returns typed values with probabilities. Thresholds, permissions and side effects stay in ordinary software where you can test them.

2. Minimum Concepts: Choice, Score, Noul, Calibration

Both Jev and Laya expose the same three question types. Learn these four ideas and every sample below reads like plain English.

3. Tutorial, Part 1: Jev SDK in Python

Install the official SDK, set TYPESAFE_API_KEY, and call system_one with a state plus typed questions. This shape is copied from the official Python SDK docs — Choice criteria is a map of option to description (None for a bare label), Score criteria is an ordered list, and answers come back split into nouls, choices and scores.

One call, three judgments, batched in parallel

# pip install typesafe-sdk  # TYPESAFE_API_KEY in 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)   # winning label
print(response.scores["urgency"].score)  # weighted position, 0..2

Questions in one request share the prepared state and are evaluated in parallel — a tenth question costs tokens but almost no extra time. The model never authorizes anything: your code reads the probabilities and applies the policy, with an explicit uncertain band routed to humans.

Policy gate: act, review, or reroute

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

if p_billing > 0.90:
    queue_refund_checks(state)      # code verifies amounts, identity, limits
elif p_billing > 0.55:
    route_to_human(state, response) # uncertain band goes to review
else:
    route_to_specialist(state)

4. Tutorial, Part 2: Laya Router + the Flywheel

Laya runs locally and speaks the same three primitives through dict schemas. Start with the built-in presets for instant triage, then use the Router when traffic mixes languages — it inspects the input script and picks the right checkpoint per request with under 2% overhead.

Preset triage in three lines

# pip install laya
import laya

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

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

Same task through 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?",
        },
    },
)

The flywheel pattern (documented in the Jev-Flywheel study) keeps the engine frozen and adapts around it: refit a small decision head over the answers when reviewers disagree, and run steering rounds where an analyst proposes a new question a human approves. On the same 140 labels and 600 held-out items, that layer lifted Jev from 0.768 to 0.870 and Laya from 0.722 to 0.802, calibrating both (ECE 0.030 and 0.015). Full fine-tuning of Laya’s open weights on the same budget reached 0.896 — higher accuracy, but 42% of unrelated answers drifted, so every other score needs revalidating.

5. Common Mistakes in Production

These five failure modes come straight from the versioned limitation docs of both models. Budget for all of them before your first live decision.

Conclusion

The useful idea is bigger than either product: many agent steps need a bounded judgment, not another paragraph. Jev packages that as a managed decision API with a 64k window you rent; Laya offers inspectable Apache-2.0 weights with 512/1024-token windows you own, fine-tune and calibrate yourself.

Give each layer the job it handles best: code does exact work and owns actions, a tested decision model turns text into bounded answers, LLMs generate and reason, humans resolve consequential uncertainty. Start this week by replacing one LLM classification call with a typed decision and a threshold — that single gate usually pays for the whole pattern.