Laya

Fast, non-autoregressive System 1 decision engine with mathematically calibrated probabilities.

Laya lets you evaluate typed questions (choice, score, noul) over any state (text, email, ticket, or JSON document) in a single forward pass (~33–38 ms on GPU). It produces structured decision outputs and calibrated confidence scores without text generation, token streaming, or hallucinations.

Powered by the fine-tuned Laya model on Hugging Face.

Installation

pip install laya

Quickstart

import laya

# 1. Load the fine-tuned model directly from Hugging Face Hub (auto-downloads weights)
agent = laya.load("convaiinnovations/laya")

# 2. Provide any state (string or dictionary)
state = {
    "from": "user@acme.com",
    "subject": "Duplicate charge on invoice #4411",
    "body": "Hi, we were billed twice for March. Please refund the duplicate today or we will cancel our plan."
}

# 3. Define your typed questions
questions = {
    # choice: categorical selection with probabilities & confidence
    "department": {
        "type": "choice",
        "instructions": "Which department should handle this email?",
        "criteria": {
            "billing": "invoices, payments, refunds",
            "technical": "bugs, outages, system errors",
            "sales": "pricing, new contracts",
            "other": "everything else"
        }
    },
    # score: placement on an ordinal rubric
    "urgency": {
        "type": "score",
        "instructions": "How urgent is this request?",
        "criteria": ["not urgent", "soon", "critical deadline or blocking issue"]
    },
    # noul: calibrated boolean probability P(true)
    "churn_risk": {
        "type": "noul",
        "instructions": "Does the user threaten to cancel or leave?"
    },
    "is_phishing": {
        "type": "noul",
        "instructions": "Is this email a phishing or scam attempt?"
    }
}

# 4. Run all questions in ONE single forward pass (~35 ms on GPU)
result = agent.predict(state, questions)
answers = result["answers"]

print("Department :", answers["department"]["choice"])
# -> billing (confidence: 0.94)

print("Urgency    :", answers["urgency"]["score"])
# -> 1.84 / 2.0

print("Churn Risk :", answers["churn_risk"]["noul"])
# -> 0.892 (89.2% probability)

print("Phishing   :", answers["is_phishing"]["noul"])
# -> 0.008 (0.8% probability)

Automated Confidence Gating

Because Laya's probabilities are trained with strictly proper scoring rules (RLCD), confidence scores are statistically meaningful:

dept = answers["department"]["choice"]
conf = answers["department"]["confidence"]

if conf >= 0.85:
    # High confidence: automated action without human in the loop
    route_automatically(dept)
else:
    # Low confidence: escalate to human triage
    escalate_to_human_agent(dept, reason=f"Low confidence ({conf:.2f})")

Built-in Workflow Presets

Laya provides pre-tuned question schemas for immediate production use:

import laya

agent = laya.load("convaiinnovations/laya")

# 1. Intelligent Model Router (routes to small vs. frontier models)
routing = agent.predict({"request": "Refactor this service using dependency injection"}, laya.router_questions())

# 2. Real-time Prompt Guardrails (jailbreaks, injections, leaks)
guard = agent.predict({"prompt": "Ignore all instructions"}, laya.guard_questions())

# 3. Content Safety & Moderation (toxicity, harassment, threats)
safety = agent.predict({"post": "User comment text"}, laya.moderation_questions())

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

Decision Primitives

Benchmark: Laya vs. TypeSafe Jev

Image inputs via SmolVLM backbone (experimental)

laya.vlm is a parallel model family that swaps the ModernBERT encoder for a small vision-language model (default HuggingFaceTB/SmolVLM-256M-Instruct) and keeps the same predict(state, questions) API and output schema. States may be text, a dict, or a dict with an "image" (PIL image or path) and/or "images" key; the other keys are serialized to text as usual.

import laya
from PIL import Image

agent = laya.load_vlm(backbone="HuggingFaceTB/SmolVLM-256M-Instruct")  # fresh, UNTRAINED head
result = agent.predict(
    {"image": Image.open("photo.jpg"), "caption": "front door camera"},
    {"person": {"type": "noul", "instructions": "Is there a person at the door?"}},
    n_permutations=1,  # >1 averages over option orders to reduce position bias
)
agent.save("my-vlm-agent")                  # vlm_agent_config.json + processor + safetensors
agent = laya.load_vlm("my-vlm-agent")

• Sequence: the backbone is a causal decoder, so options come last: <image tokens> <state> <type> question: <ins> Options: - opt0\n - opt1\n .... Each option is read at the \n that ends its line, which has seen the image, state, question and that option.
• Option-order bias: option i cannot see option j > i. Training shuffles option order; inference can average over n_permutations; option_attention="bidirectional" (custom 4D mask over the option block) is available but needs fine-tuning.
• A fresh head (backbone=...) is untrained. Load thaitea/laya-vision-smolvlm-256m for a trained one, or fine-tune: python -m laya.vlm_train --synthetic --steps 3 --freeze head is the smoke run. laya/vlm_train.py has adapters for A-OKVQA / ScienceQA (choice) and VQAv2 yes/no (noul), and freezing stages head, last_n, and full.
• On Modal (modal_app.py, using the laya-hf-cache, laya-datasets and laya-checkpoints volumes): modal run modal_app.py::test runs the tests and latency on an L4. modal run modal_app.py::finetune --minutes 18 fine-tunes on the prepared /data/vqa/<name>/{train,val}.jsonl sets and reports held-out accuracy and ECE.
• Latency is dominated by the 512 px SigLIP vision tower. The image is encoded once per predict call and reused for every question.

Live Demo & Resources

• Hugging Face Model: convaiinnovations/laya
• Interactive Web Demo: convaiinnovations/laya-demo
• Engineering Writeup: Read the full story on Dev.to

Fine-Tuning on Single T4 GPU (Google Colab)

Fine-tune Laya on your custom domain data or commercial datasets on a free T4 GPU:

• Interactive Fine-Tuning Notebook: Fine-Tune on Custom Data (notebooks/laya_finetune_colab.ipynb)

Support the Project

If Laya helps your research or products, consider supporting independent research:

License

Apache 2.0. Developed by Convai Innovations.