Laya Decision Engine

Laya Decision Engine

A small decision and routing model that picks a choice, scores something or verifies a claim in one pass, in about 25 milliseconds, without writing any text. Served as a REST API or a Gradio demo.

Made by saleejkuruniyan on Hugging Face. These notes are Mindket's, written from its Space page and README; the app's own files and license are on Hugging Face.

About

What it is: Laya is a small model, about 150M parameters, that makes quick decisions instead of writing text. It handles three kinds of question in a single forward pass. A choice picks one option, a score rates something on a scale, and a verification checks a claim.

Because it never generates text, it cannot make up an answer. The README aims for responses under 30 milliseconds and offers it as a REST service or as a Hugging Face demo.

Who it suits: It suits developers who run an AI pipeline and want a cheap, fast step to route work, such as deciding which tool or format a task needs, before a larger model is called.

Industry | Who uses it | How they use it | Example
Edtech | Content teams | Route a lesson concept to the right diagram or video engine | Sending a ray optics concept to a plotting library
AI platforms | Backend engineers | Pre-route requests before calling an expensive model | Saving tokens on every routed diagram or section
Education tools | Developers | Sort exam flashcards into action types | Marking a card as draw and label, memorize or explain
AI development | Developers | Test the decision API from a script | Calling the predict endpoint from a Python client

Skip it if you need a model that writes or explains in text, since this one only returns decisions.

Where to use it: The engine runs in these places.

• A web browser, on the Space's page at Hugging Face
• A Docker container on your own machine or a server, serving a REST API
• A Docker Compose setup, or an EC2 host such as the README describes
• Your own Python code, through the REST API

Use case | Who | What they get back
Choose between options | Pipeline builders | The picked option with a confidence and probabilities
Health check the service | Operators | A short status reply
Try it in a browser | Anyone curious | A demo page on Hugging Face

How to set it up: Online you only need a browser. For your own copy you need these.

• Python 3.12 for the Gradio demo, or Docker for the REST service
• Python and pip, for the hf download command
• Room for a model of about 300 MB

1. Install the huggingface_hub package.
2. Download the Space's files into a folder with the hf command.
3. Move into that folder.
4. Install gradio and the packages in requirements.txt.
5. Start the demo with python app.py.

pip install -U huggingface_hub
hf download saleejkuruniyan/laya-api --repo-type space --local-dir laya-api
cd laya-api
pip install gradio
pip install -r requirements.txt
python app.py

For the REST service, build the image and run it in Docker, or use Docker Compose.

docker build -t laya-api .
docker run -d --name laya -p 8000:8000 --restart unless-stopped laya-api

docker compose up -d

How to use it: Send a JSON request to the predict endpoint with a short description of the situation and the questions to answer. Each question names its type, instructions and the criteria for each option. A health endpoint reports whether the service is up. The repository includes test_client.py and test_curl.sh to try it.

{
  "state": "Ray diagram showing refraction of white light through a triangular glass prism splitting into VIBGYOR colors.",
  "questions": {
    "diagram_engine": {
      "type": "choice",
      "instructions": "Which diagram engine is best suited for rendering this concept?",
      "criteria": {
        "matplotlib": "ray optics, light mechanics, magnetic field lines, coordinate graphs, vectors",
        "svg": "electrical circuits, resistors in parallel/series, logic gates, chemical glassware",
        "generative_ai": "biological specimens, organ cross-sections, human anatomy, realistic 3D scenes"
      }
    }
  }
}

Tool | What it does
choice | Picks one option from a list you describe
score | Gives an ordinal rating
noul | Verifies a claim
POST /predict | Takes the request above and returns the answers
GET /healthz | Reports that the service is healthy

Example: You send the prism diagram description and ask which diagram engine fits best. The service answers matplotlib with a confidence of 0.89, and shows 0.08 for svg and 0.03 for generative_ai, in about 25 milliseconds.

For newcomers and experts: If you are new, think of it as a fast multiple choice grader. You describe a situation and the options, and it picks one without writing a sentence. Start with the demo page.

If you know the field, it is a non-autoregressive decision model, so one forward pass yields the answer and no tokens are sampled. Self-hosted on CPU the README reports about 20 to 25 milliseconds, against about 35 milliseconds plus network time on ZeroGPU.

Describe the state in JSON
List the questions and options
One forward pass scores every option
The API returns the pick and probabilities

Good to know: The README compares the two ways to run it, and it recommends self-hosting for steady use.

Topic | Hugging Face ZeroGPU | Self-hosted
Model size | About 150M parameters | About 150M parameters
Daily quota | About 5 minutes, used up after 5 to 8 calls | No quota
Speed | About 35 ms plus a network hop | About 20 to 25 ms on CPU
API | Gradio queue stream | REST requests to predict

• License: apache-2
• Cost to run: no fee named for self-hosting. The README says the ZeroGPU demo has a daily quota
• Data it reaches: the state and questions you send, and the model files it keeps in a Hugging Face cache folder
• Not for: generating text, since it only returns decisions

On Hugging Face, 13 November 2026

• Likes: 1
• Built with: gradio
• License: apache-2.0

Links

• Space: https://huggingface.co/spaces/saleejkuruniyan/laya-api
• Files: https://huggingface.co/spaces/saleejkuruniyan/laya-api/tree/main

Try it

Open the Space in your browser, or copy it to your own Hugging Face account from its page. Nothing in this kit runs by itself.