Answers with a defined shape
Receive a choice, an ordered score, or P(true) that your application can process with its own rules.
A practical place to try Laya
Free Laya Model Online
Explore a free laya model in an interactive playground. Ask a real decision question, inspect its structured answer, and see how Laya handles your own example before you connect an application.
Choose a language route
Select English, multilingual, or automatic routing, then inspect the model that handled the request.
Ask related questions together
Share one state across questions to classify a case, score urgency, and identify intent in one request.
Understand the model
A decision model you can try in your browser
Laya is an open-weight family of decision models built to turn context into a bounded answer. Instead of asking for a paragraph that your program must interpret, you provide a state and one or more typed questions. The result can be a category, an ordered score, or a probability that a clear statement is true. This makes a free laya model useful when an application needs a predictable answer shape: label a support ticket, estimate urgency, or check whether a message contains a refund request.
The model does not take action on your behalf. It returns a decision signal for your software to inspect. Your application remains responsible for choosing a destination, applying permissions, setting confidence thresholds, and asking a person to review uncertain or consequential cases. You can explore that boundary with a free laya model here: change the context, define the options, and inspect the returned distribution before deciding how it should fit your product.
You can try a free laya model without installing Python, downloading model weights, or starting a machine-learning server. The browser playground sends your test to the Laya service configured for this site. Sign in to run a decision; the interactive workspace shows the request, result, probabilities, and timing together. A free laya model trial is therefore a quick way to explore a workflow, while a production integration still deserves a labeled test set and an explicit operating plan.
Laya shares a decision-shaped interface with Jev, but it is a separate model family. The same state and typed-question pattern can help you compare their behavior on examples that matter to your team. A free laya model session lets you develop a concrete question first, then inspect what an answer means for your own application instead of relying on a broad claim about model quality.
Three available routes
Choose the Laya route that fits your input
The playground exposes three model choices. Each gives the free laya model the same state and questions; the choice controls which Laya checkpoint receives them.
laya-english
Select this route when your task and examples are in English. It sends the request to Laya’s English checkpoint. A free laya model run with this option makes it easier to compare wording and labels on an English-only ticket queue or review task.
laya-multilingual
Select this route for Chinese or mixed-language input, or when you want to specify the multilingual checkpoint directly. A free laya model run can then use the same decision definition across multilingual examples. Check the result against each language your application will actually receive.
laya-auto
Let Laya route automatically from the text in your state. The request omits a model name and the response includes routing information. A free laya model trial with auto routing is convenient for exploration; verify the selected route with short, code-switched, and ambiguous examples before relying on it in production.
A practical workflow
Start with a question your application can use
01A helpful free laya model experiment begins with one input that resembles a real application event. For example, use a support message that includes the customer’s request and enough order context to distinguish a duplicate payment from a general billing question. Avoid pasting account secrets or data that your team should not send to the configured service.
02Next, write the decision in the shape your code expects. For a category, name the available choices and explain what each one means. For a score, list ordered levels from low to high. For a yes-or-no question, state a proposition directly. This structure lets a free laya model return an answer your software can read without scraping free-form prose.
03Keep each question focused. A ticket can ask which team should handle the issue, how urgent it is, and whether a refund was explicitly requested. All three questions use the same state, so include the evidence once and make each instruction say what should be judged. If the result seems surprising, refine the context or criteria and run the free laya model again.
04After the run, compare the answer with what a knowledgeable teammate would choose. Look at the probability distribution as well as the top choice: a plausible label with a close alternative may call for review. A free laya model output describes the model’s judgment for that prompt, not a guarantee of accuracy or a measured success rate for your workload.
Three structured answer types
Jev and Laya share the same decision primitives, so the request you explore here can also inform how you design downstream application code.
Use choice when your program expects one item from a named set. Options such as billing, technical, and other make the permitted output space clear. A free laya model result includes the selected choice and probabilities for the candidates, which can help your workflow send routine cases to a queue and flag close calls.
Use score for an ordered scale such as routine, time-sensitive, and blocking. The score is an expected position on the levels you define, so it may be fractional. A free laya model score is not automatically a percentage; your application should interpret it using the meanings and boundaries of its own scale.
Use noul for a focused true-or-false proposition. It returns P(true), a value from zero to one, rather than a Boolean. Criteria can describe what true and false mean. A free laya model result near the midpoint may deserve a manual review, while a business-specific threshold should be validated against labeled examples.
Interactive playground
Try a free Laya model online
The workbench below is the same interactive playground used across this site, opened with Laya selected. Change the model selector to compare English, multilingual, and automatic routing while keeping the question format familiar.
English decision model. Keep inputs short: the per-question budget is 512 tokens for English or 1,024 for multilingual, including instructions and options. Longer inputs may be truncated.
Free after sign-in · API uses credits
Draft saved in this browser · Your draft will be restored after sign-in.
Your next decision starts here.
Run the loaded example or edit the input. Results are returned by the model.
choicescorenoul
Edit the shared state and describe the evidence that matters to the decision. Add or remove questions, rename an option, or replace the example with a small piece of representative text. Running the free laya model requires signing in, and web playground runs are free. The model selector stays available as you edit so you can compare routes without rebuilding your questions.
Use the Request tab to inspect exactly what the playground will send. The Results view separates the predicted answer from the probability distribution, while the Response tab shows the complete service envelope. When you save a configuration or open a previous run, the chosen model stays attached to the request. That makes a free laya model experiment easier to reproduce and discuss with another person on your team.
The Compare rules view can run two captured configurations over the same labeled cases. Capture one version, adjust its model or question criteria, capture a second version, and inspect which answers changed. This free laya model workflow makes comparison more concrete than changing several prompt details at once, although a small hand-built dataset is still only an early evaluation.
Application integration
Move from browser experiment to API
Once you have a useful request, the Code tab can produce a server-side cURL, JavaScript, or Python example for the selected model. Calls from your application require an API key and use account credits.
The key is a placeholder. Create a site API key and keep its real value in a server-side environment variable.
Example: send a decision request from your server
// Server-side JavaScript (Node 20+ or Bun). Set JEV_API_KEY.
const response = await fetch("https://jevaimodel.net/v1/systemone", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.JEV_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
"model": "laya-multilingual",
"state": "I was billed twice for order A-4471. Please refund the extra payment.",
"questions": {
"route": {
"type": "choice",
"instructions": "Which team should handle this ticket? Use other when no option fits.",
"criteria": {
"billing": "Payments, charges and refunds",
"technical": "Bugs and product errors",
"account": "Login and account access",
"other": "None of these teams"
}
}
}
}),
});
const body = await response.json();
if (!response.ok || body.code !== 0) throw new Error(body.message);
console.log(body.data.result.answers);
console.log(body.data.creditsUsed);Keep the API key in your server environment and send it with an Authorization: Bearer header. Do not place a production key in browser JavaScript, a public repository, or a shared sample. A free laya model test in the signed-in playground does not require you to expose a key in the page; API access is for server-side integration.
The API request uses the same state, questions, and model names as the workbench. For laya-english and laya-multilingual, the service selects the corresponding checkpoint. With laya-auto, the service leaves model routing to Laya. The response includes routing.model so you can inspect which checkpoint handled an automatically routed request. Each free laya model request still needs normal input validation and appropriate error handling in the calling application.
Successful API requests are charged according to the site’s published input-token credit formula; output tokens are free. Check the pricing and usage pages for current account details before estimating a larger deployment. A free laya model web run is useful for exploration, while repeated API experiments consume credits and should be budgeted like other hosted inference traffic.
The complete request is bounded in size and question count. Laya’s documented per-question context budgets are shorter than many chat-model contexts: about 512 tokens for the English route and 1,024 for the multilingual route, including instructions and options. Long state can be truncated. A free laya model integration should select relevant evidence before sending it and test how the service handles the longest real examples you expect.
laya-english · Set the English checkpoint explicitly for English input.
laya-multilingual · Set the multilingual checkpoint explicitly for Chinese or multilingual input.
laya-auto · Omit the upstream model parameter and route automatically from the input.
Evaluate the decisions that matter to you
A single free laya model answer can show whether the interface makes sense, but production readiness takes repeated examples. Assemble cases that include ordinary messages, confusing wording, missing evidence, multilingual inputs, and requests that belong outside your available categories. Write down the expected answer before running the model so the evaluation does not shift after seeing a prediction.
Measure the errors that have different business consequences. Sending a refund request to the wrong queue, overlooking a safety issue, and escalating a routine request are not interchangeable outcomes. Decide which mistakes need a person to review them, and tune thresholds on a separate labeled set. A free laya model probability can support that policy, but it does not choose the policy for you.
Compare checkpoints and routing with the same states, questions, and expected answers. Record answer quality, calibration, language-specific behavior, end-to-end latency, and the share of cases that need review. A free laya model test becomes more useful when it answers a specific deployment question, such as whether automatic routing works reliably for brief Chinese messages.
Published benchmark results offer context, not a promise for your data. The source guide describes different outcomes for base English, multilingual, and task-tuned checkpoints and cautions that the test sets are not interchangeable. A free laya model workflow should use the exact route and criteria you intend to deploy, then retain its own examples and decision policy as the practical evidence.
Plan for real-world behavior
Know the operational limits before launch
Laya is not a chat assistant and does not produce a natural-language rationale for every decision. Keep instructions specific, put relevant facts in the state, and treat the structured response as one input to application logic. A free laya model should not be asked to infer a long chain of unstated policy from a vague instruction.
A probability is not a calibrated confidence guarantee. Test clear positives and negatives for your exact wording, then inspect ambiguous examples. For noul, make sure criteria.true and criteria.false reflect the business meaning of yes and no. A free laya model result can be confident and still be wrong, so preserve deterministic controls for actions with material consequences.
Choice questions can become harder as their option set grows. Keep labels distinct, describe edge cases, and include a sensible fallback for out-of-scope inputs. If a free laya model confuses sibling categories, try clearer criteria or a staged decision that narrows the choice set, then evaluate the revised flow on held-out cases.
Language detection can be uncertain for short, mixed-script, or code-switched text. Explicitly choose the route when the application already knows the language, or test auto routing across the actual language distribution. A free laya model result should be grouped by language during evaluation so strong performance in one language does not hide failures in another.
A hosted API moves model serving out of your application, but it adds network, provider availability, and account-credit considerations. Apply timeouts, handle non-JSON gateway errors, and choose a retry policy that avoids duplicate work. A free laya model playground session is not a substitute for measuring production latency and capacity at your expected traffic level.
Frequently asked questions
Can I use a free Laya model online without installing anything?+
Yes. Sign in, choose a Laya route, and run an example in the browser playground. There is no local checkpoint download or Python setup for a free laya model web experiment.
Does free mean every type of use is free?+
The signed-in web playground runs are free. Calls from your own application use the API and account credits. A free laya model session is for browser testing; review the pricing page for API costs.
Which Laya model should I select?+
Use laya-english for English inputs, laya-multilingual for multilingual inputs, and laya-auto when you want Laya to route from the state. A free laya model comparison on representative examples is the best way to choose.
Does the model return a written explanation?+
No. It returns structured categories, scores, or probabilities. Your application can decide how to present the result. A free laya model output should not be treated as a generated rationale.
Can I trust the returned probability as accuracy?+
No. It is a model output, not measured accuracy. Evaluate a free laya model on labeled cases from your own workflow and decide how uncertain results should be handled.
Can I use the playground results in production automatically?+
The playground is a place to explore and evaluate. Before an automated action, add application rules, access checks, monitoring, and a review path for consequential or uncertain decisions. A free laya model evaluation helps you gather evidence for that choice.
Start with one real decision
Bring a short, representative example to the playground, make the expected answer shape explicit, and see how Laya responds. A free laya model run gives you a concrete starting point; your own evaluation determines whether the behavior fits the workflow you plan to build.