Laya

Laya is a small open model that decides instead of writing. You give it a piece of text and a few typed questions — yes/no, pick one, or a position on a scale — and it answers each with probabilities in a fraction of a second. TurboLLM runs it on its own Laya engine (Windows, macOS and Linux, on CPU or GPU), beside your chat model, and serves it in a playground and at POST /v1/systemone. This page walks through it from nothing to a working answer.

What Laya is

Laya is a System One decision model (Apache-2.0). It doesn't chat and it writes no prose: one pass over your text gives you a typed answer for every question you asked. The three question types are the ones on the Jev page, and the request and response use the same field names, so anything you write against one works against the other.

Laya or Jev?

TurboLLM serves both at /v1/systemone. They differ in how they run:

Before you start

• TurboLLM 1.14.1 or newer. The version is at the bottom of the sidebar (the screenshots below show v1.14.1). Laya support arrived in that release.
• Internet for the first setup only. The Laya engine is a Python environment with PyTorch (several GB with GPU support), and the model is about 1.5 GB. Once both are on disk, TurboLLM starts Laya in Hugging Face offline mode, so serving needs no network.
• A desktop OS. The Laya engine is built for Windows, macOS and Linux, on CPU, NVIDIA or Apple GPU. The model is small (about 1.5 GB), so it doesn't need a big card.

Set it up, step by step

1. Install the Laya engine

   Open Engines, find the Laya card (“System One decision models”) and press Install. TurboLLM sets up an isolated Python environment for it and picks the PyTorch build that matches your machine, so this can take a while. The card shows progress.

   Do this before downloading the model. Until the Laya engine is installed, TurboLLM doesn't show a Laya model in your library.

   

   Laya is never the “active” engine, so you won't be asked to activate it, and your chat engine stays as it is. A Laya model simply always runs on the Laya engine.

2. Find the exact model

   Open Models → Discover and search for laya. Pick convaiinnovations/laya, at the top of the results. You don't need to switch engines: the screenshots were taken with llama.cpp as the active chat engine.

   Or skip the search: press the link icon next to the search box (Import from URL) and paste the exact address:

   https://huggingface.co/convaiinnovations/laya

   Copy
   localhost:6996

   
   Only this repo

   The search also lists other repos with “laya” in the name (other projects, and conversions). Pick convaiinnovations/laya exactly. Its name and the Download Laya model button are how you know you have the right one.

3. Download it

   The repo panel says “Laya decision model — runs on the Laya engine” and shows the size (about 1.5 GB). Press Download Laya model. TurboLLM fetches the English and multilingual checkpoints together, as one folder named laya in your models folder. Progress shows in Downloads.

   localhost:6996

   

4. Load it

   When the download finishes, open the Library tab. The row is named laya and carries a LAYA badge. Press Load. On the test machine it was ready in under ten seconds.

   

   Once it is running the row turns green and the button becomes Eject:

   

   If you started the load from this browser, a toast appears with an Open playground button. TurboLLM never navigates for you.

   

   Your chat model is not unloaded. Laya loads into its own slot beside it, and Chat, Code and Routines all keep working. For as long as Laya is loaded, the Workspace sidebar shows a link to the playground:

   

5. Ask it something in the playground

   Open the playground from the toast or the sidebar link. Press Run and you get answers for the example that is already there.

   localhost:6996

   

   It is the same JSON-first playground as the Jev Playground, and its parts work the same way:

   • Header. laya · Laya · running, and under it Checkpoints: english, multilingual.
   • Two editors that are the request. state is the text the questions are about (JSON, or plain text, which is sent as a string). questions is the JSON map of questions. What you type is exactly what gets sent.
   • Run (or Ctrl+Enter, Cmd+Enter on macOS). Nothing is sent until you run.
   • Answers. One card per question: the yes/no number, the chosen option with every option's probability, or the scale score with every level's probability.
   • Response and curl tabs. The raw JSON that came back, and the exact curl for the request you just ran, ready to copy into your own code.
   • Examples dropdown, for a support ticket with all three question types and other ready-made inputs.

6. Try another language

   Laya carries a multilingual checkpoint and chooses between the two itself. Paste text in another script into state and run. Here the state is Hindi (“I was charged twice in March, please refund the duplicate amount”) and the questions are still in English:

   localhost:6996

   

   The footer reads answered by the multilingual checkpoint. The response's routing block names the checkpoint and why it was chosen. See Which checkpoint answered.

To unload Laya, press Eject on its row in Models. Nothing is deleted.

Use it from your own code

POST /v1/systemone is on the same address and port as the rest of TurboLLM's API (http://localhost:6996 by default). For a Laya model the request is exactly the one described on the Jev page: state, model and a map of questions, each with a type, instructions and (for choice and score) criteria. The field names follow TypeSafe AI's public System One API.

• model is the model's name in your library (laya), or its id from GET /v1/models, which looks like laya|laya|<size in bytes>. The alias jev-latest selects a Jev model and never a Laya one, so name Laya explicitly.
• Loaded on demand. With Auto model-swap on (Settings → Gateway), the first request loads Laya for you, into its own slot beside your chat model. With it off, load Laya from Models first, or the request fails with 503.
• Auth is the same as the rest of /v1: a key is needed only when Require API key is on. See API overview.
• Laya answers /v1/systemone only. Sending it to /v1/chat/completions, /v1/embeddings or /v1/messages returns 400 laya_model_wrong_endpoint.

This is the request the playground runs for its support-ticket example:

curl http://localhost:6996/v1/systemone \
  -H "Content-Type: application/json" \
  -d @- <<'EOF'
{
  "model": "laya",
  "state": "I've been unable to connect my payment provider for three days and the integration keeps failing. I'm losing sales, please help as soon as possible.",
  "questions": {
    "urgent": { "type": "noul", "instructions": "Does the message convey urgency?" },
    "team": {
      "type": "choice",
      "instructions": "Which team should handle this message?",
      "criteria": {
        "billing": "Payment, invoices, refunds or subscription charges",
        "technical": "Bugs, outages or integration problems",
        "sales": "Pricing, plans, upgrades or discounts"
      }
    },
    "mood": {
      "type": "score",
      "instructions": "What is the customer's tone?",
      "criteria": [
        "Calm, just asking or stating facts",
        "Mildly annoyed but polite",
        "Clearly frustrated",
        "Very angry, strong language"
      ]
    }
  }
}
EOF

# Only when Require API key is on, add:
#   -H "Authorization: Bearer <your key>"

import requests

headers = {"Content-Type": "application/json"}
# headers["Authorization"] = "Bearer <your key>"  # only when Require API key is on

resp = requests.post(
    "http://localhost:6996/v1/systemone",
    headers=headers,
    json={
        "model": "laya",
        "state": "I've been unable to connect my payment provider for three days and the integration keeps failing. I'm losing sales, please help as soon as possible.",
        "questions": {
            "urgent": {"type": "noul", "instructions": "Does the message convey urgency?"},
            "team": {
                "type": "choice",
                "instructions": "Which team should handle this message?",
                "criteria": {
                    "billing": "Payment, invoices, refunds or subscription charges",
                    "technical": "Bugs, outages or integration problems",
                    "sales": "Pricing, plans, upgrades or discounts",
                },
            },
            "mood": {
                "type": "score",
                "instructions": "What is the customer's tone?",
                "criteria": [
                    "Calm, just asking or stating facts",
                    "Mildly annoyed but polite",
                    "Clearly frustrated",
                    "Very angry, strong language",
                ],
            },
        },
    },
)
if not resp.ok:
    raise RuntimeError(resp.json()["error"]["message"])

body = resp.json()
answers = body["answers"]
print("urgent", answers["urgent"]["noul"])
print("team", answers["team"]["choice"], answers["team"]["probabilities"])
print("mood", answers["mood"]["score"])
print("answered by", body["routing"]["model"], "-", body["routing"]["reason"])

const res = await fetch("http://localhost:6996/v1/systemone", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    // "Authorization": "Bearer <your key>", // only when Require API key is on
  },
  body: JSON.stringify({
    model: "laya",
    state: "I've been unable to connect my payment provider for three days and the integration keeps failing. I'm losing sales, please help as soon as possible.",
    questions: {
      urgent: { type: "noul", instructions: "Does the message convey urgency?" },
      team: {
        type: "choice",
        instructions: "Which team should handle this message?",
        criteria: {
          billing: "Payment, invoices, refunds or subscription charges",
          technical: "Bugs, outages or integration problems",
          sales: "Pricing, plans, upgrades or discounts",
        },
      },
      mood: {
        type: "score",
        instructions: "What is the customer's tone?",
        criteria: [
          "Calm, just asking or stating facts",
          "Mildly annoyed but polite",
          "Clearly frustrated",
          "Very angry, strong language",
        ],
      },
    },
  }),
});
if (!res.ok) throw new Error((await res.json()).error.message);

const { answers, routing } = await res.json();
console.log("urgent", answers.urgent.noul);
console.log("team", answers.team.choice, answers.team.probabilities);
console.log("mood", answers.mood.score);
console.log("answered by", routing.model, "-", routing.reason);

The real response to that request, unedited (Windows, 2026-09-25):

{
  "model": "laya|laya|1486444724",
  "answers": {
    "urgent": {
      "type": "noul",
      "noul": 0.7621,
      "confidence": 0.7621,
      "answer_confidence": 0.7621,
      "action": { "act_probability": 1 }
    },
    "team": {
      "type": "choice",
      "choice": "billing",
      "probabilities": { "billing": 0.5867, "technical": 0.219, "sales": 0.1943 },
      "confidence": 0.1227,
      "answer_confidence": 0.5867,
      "action": { "act_probability": 1 }
    },
    "mood": {
      "type": "score",
      "score": 1.8595,
      "legend": {
        "0": "Calm, just asking or stating facts",
        "1": "Mildly annoyed but polite",
        "2": "Clearly frustrated",
        "3": "Very angry, strong language"
      },
      "probabilities": { "0": 0.0206, "1": 0.1974, "2": 0.6838, "3": 0.0981 },
      "confidence": 0.3595,
      "answer_confidence": 0.6838,
      "action": { "act_probability": 1 }
    }
  },
  "usage": { "input_tokens": 222, "output_tokens": 0 },
  "routing": { "model": "english", "reason": "English Latin text" }
}

Laya put this ticket about a failing payment integration under billing (0.59) rather than technical (0.22). That is the real result, not a tidied one. It is a reason to run Laya on your own messages and read the numbers before you rely on them. See What the numbers are.

The response fields

Which checkpoint answered

The laya folder holds two checkpoints, and Laya picks one for each request. routing.model is english or multilingual, and routing.reason says why. The two reasons seen in the runs above:

This is the same Hindi request as the screenshot, and its real response:

{
  "model": "laya|laya|1486444724",
  "answers": {
    "refund": { "type": "noul", "noul": 0.9889, "confidence": 0.9889, "answer_confidence": 0.9889, "action": { "act_probability": 1 } },
    "department": {
      "type": "choice",
      "choice": "billing",
      "probabilities": { "billing": 0.9493, "technical": 0.0054, "sales": 0.0453 },
      "confidence": 0.8019,
      "answer_confidence": 0.9493,
      "action": { "act_probability": 1 }
    }
  },
  "usage": { "input_tokens": 117, "output_tokens": 0 },
  "routing": {
    "model": "multilingual",
    "reason": "non-Latin script (devanagari, 100% of letters); the English checkpoint cannot read it"
  }
}

The request behind it had "model": "laya", the Hindi sentence as state, and two English questions: a noul (Does the customer ask for a refund?) and a choice between billing, technical and sales.

How fast

On the machine these numbers came from (Windows, NVIDIA GPU, 2026-09-25), the first request, which had to load Laya, took about 9 seconds. Once it was loaded, requests took 0.27 to 0.36 seconds end to end over HTTP, for the English ticket above and for the Hindi one. That is one machine and a few requests, not a benchmark.

Errors you may meet

What the numbers are, and what they aren't

• They are Laya's own probabilities. TurboLLM doesn't recompute them for a Laya model (it does for Jev). Laya's model card says these probabilities ship over-confident, so a 0.95 is not a 95% chance of being right. Check them on your own data before you act on a threshold.
• One example is not an evaluation. The runs above are two requests. They show the shape and the speed. They don't show how accurate Laya is on your task.
• Write neutral instructions. A question that presupposes the answer tends to skew the result. The advice on the Jev page was measured on a Jev model, not on Laya, but it is a sensible default here too.
• Long text is cut short, silently. Laya reads only the start of a long state: about 320 tokens of English text, or about 768 of multilingual text, in the tests so far. It accepts longer text, and nothing in the response says it was cut. Summarise or split long content yourself. Laya itself refuses a state over 50,000 characters or more than 64 questions with a 422.
• The typed-decisions checkpoint isn't available. The Laya repo also holds a checkpoint fine-tuned for four fixed workflows. TurboLLM doesn't download it, and the request has no way to pick a checkpoint. Laya's own router chooses between English and multilingual only.

Troubleshooting

Next