If you have been watching the AI tooling space, you have seen a new kind of model show up: one that does not write, and only decides.
These models are fast, cheap, and unusually well suited to the actual work of SEO and GEO, which is mostly a long series of small judgments rather than a writing problem. Laya is the open one. You can download it, run it on your own machine, and pay nothing per call.
This guide is the entry point to everything in this series. It explains what Laya is, how to get it running, the eight SEO and GEO jobs it does well, and the jobs it does badly. Each job links to a full workflow article, so you can start here and go as deep as you need.
The short version
Laya is a decision model. You give it a piece of text or a JSON object, plus a question with a fixed set of possible answers. It returns the answer with a probability attached, in a single pass, in tens of milliseconds, without generating any text.
It was released under the Apache 2.0 license on 18 September 2026. It runs on a laptop. There is no API key and no per-call cost.
That is the whole idea. Everything else is detail.
Why a decision model fits SEO work
Most of the AI in an SEO stack is a text generator doing a job that does not need text.
You ask it to sort two hundred keywords by intent, and it writes you two hundred paragraphs of reasoning you did not ask for. You ask it whether a page already links to another page, and it produces a confident sentence instead of a yes or no. You pay per token for all of it, and you send your client's data to someone else's server to get it.
A decision model does none of that. It reads your input and your question, and it produces a probability distribution over the answers you defined. There is no text to hallucinate, because there is no text generation step at all. There is no JSON to fail to parse, because the output is already structured.
And most of SEO work is not writing. It is deciding:
- Is this query informational, comparative, transactional, or navigational?
- Does this page already satisfy that intent, or do we need a new one?
- Should these two pages be merged, or kept separate?
- Does this passage have a real reason to link to that page?
- Is this draft thin, or is it fine?
- Did this AI answer mention our brand, or only our competitor?
Every one of those is a small judgment with a fixed set of outcomes. That is the shape a decision model is built for, and it is the shape a text generator is wasteful for.
The three decision types
Laya answers three kinds of questions. Everything you build with it is one of these three, so it is worth learning them properly before you write a single prompt.
choice — pick one from a list
You provide the options, and Laya returns a probability for each.
SEO example: "Which search intent does this query have?" with options learn, compare, buy, navigate, brand.
You get back something like learn: 0.91, compare: 0.06, buy: 0.02, navigate: 0.01, brand: 0.00. The full distribution is the useful part, not just the winner. A query that comes back compare: 0.48, buy: 0.45 is genuinely ambiguous, and you want to know that.
score — rate on a scale
You define an ordered scale, and Laya returns the expected value.
SEO example: "How well does this page answer the question in this passage?" on a 0 to 4 scale from not at all to completely.
This is the type you use for relevance, quality, and priority judgments. It is also the type most likely to be misused, because people treat the returned number as a precise measurement when it is really a calibrated opinion.
noul — yes or no
You state a proposition, and Laya returns the probability that it is true.
SEO example: "This page already contains a link to that page." You get back a single probability.
This is the cheapest question type, and it is the one you should use to filter large candidate sets before doing anything more expensive.
One practical constraint on `choice`: keep the option list to roughly twenty or fewer. Laya's options share a fixed budget of 256 tokens in the model's output head, so a very large label set leaves too few tokens per label and accuracy falls off sharply. If you have forty intent labels, you do not ask one question with forty options. You ask a cascade of narrower questions. That pattern gets its own article.
Three question types. Everything you build with Laya is one of these.
The four-stage loop
Every workflow in this series follows the same shape. It is worth internalizing now, because it is what keeps these systems honest.
generate and reason -> decide -> execute -> reviewGenerate and reason. A language model, or you, produces the material: the draft, the candidate list, the captured answers, the page inventory. This is where the expensive model does its work.
Decide. Laya answers the fixed questions about that material. This is the cheap, fast, high-volume step.
Execute. Ordinary code takes the decisions and does something with them: writes a spreadsheet, queues a task, applies an edit, sends a request for review.
Review. Low-confidence decisions and anything with real consequences go to a human.
The reason this loop matters is that it puts the expensive model where it is actually needed and the cheap model where the volume is. It also puts a human at the end, which is the only thing that makes any of it safe to ship.
The expensive model reasons. Laya decides. Code executes. A human reviews.
Install Laya and run one decision
Before you read any further, get it running. It takes a few minutes.
Install
pip install layaOr load the weights directly:
from transformers import AutoModel
model = AutoModel.from_pretrained(
"convaiinnovations/laya",
device_map="auto",
)device_map="auto" uses a GPU if one is available and falls back to CPU if not. The model is small enough to run on a laptop.
Which checkpoint
- English base, around 421M parameters, 512-token context. Use this for English-only work.
- Multilingual, around 322M parameters, 1024-token context, more than a hundred languages.
If your content is not English, use the multilingual checkpoint. This is not optional, and the failure modes section below explains why.
Your first real decision
Pick twenty queries from your own Search Console export. Write a choice question with four intent options. Run them through Laya. Then read the twenty answers yourself and count how many you agree with.
That number is your baseline. If it is high enough to be useful, you have a workflow. If it is not, you have learned something important in five minutes instead of five weeks.
The eight jobs Laya is good at
This is the map of the series. Each job has a full article behind it.
1. Classifying search intent at scale
The most obvious fit. A query goes in, an intent label comes out, with a confidence value you can use to route the ambiguous ones to a human. The main design problem is the wide-taxonomy limit, which you solve with a cascade of narrow questions rather than one large one.
Read the full workflow: Laya for search intent classification at scale
2. Auditing content and routing it
For each page, decide one of four things: keep, update, merge, or remove. This is a choice question, and it is one of the highest-value uses of a decision model because it is exactly the kind of judgment that gets skipped when a human has five thousand pages to review.
Read the full workflow: Laya for content audits
3. Finding internal link opportunities
Does this passage have a real reason to link to that page? That is a noul question, and internal linking is one of the best fits for this model class because it is thousands of yes/no calls rather than a writing task.
There is an important limit here, and it gets its own article, because choosing among fifteen candidate pages is a wide-option choice question, which is exactly where Laya is weakest.
Read the full workflow, and the limits: Laya for internal linking
4. Reranking search results and retrieval
The two-stage pattern: use cheap similarity search to get a shortlist, then use Laya to judge true relevance. First-stage similarity and real relevance diverge constantly, which is why reranking exists.
Read the full workflow: Laya as a local reranker
5. Scoring AI answers for GEO
Capture what ChatGPT, Perplexity, and the other engines say about your category, then score each answer into named, mentioned, or absent. Because Laya runs locally, the captured answers never leave your machine, which matters when they contain client data.
Read the full workflow: Laya for GEO answer scoring
6. Guarding your own agents
A local model is the right place to check whether an agent is about to do something destructive, whether an input is a prompt-injection attempt, or whether a workflow is stuck in a loop. This is a noul question, and it is one of the best uses of a small local model.
Read the full workflow: using Laya to check your own agents
7. Fine-tuning on your own labels
This is the capability that makes an open model genuinely different, not just cheaper. You can train Laya on your own labeled decisions and get a model that knows your taxonomy better than any general model does.
Read the full workflow: fine-tuning Laya on your own SEO labels
8. Running it all locally, at a known cost
Every job above depends on the same infrastructure question: what does running this locally actually cost, and when is it cheaper than paying per call? That deserves its own answer rather than a footnote.
Read the full analysis: running Laya locally
The jobs Laya is bad at
Equal time for the other side, because this is where people waste weeks.
Writing anything. Laya does not generate text. It will not draft your meta descriptions, your article, or your anchor text. That is a language model's job, and it is a different stage of the loop.
Open-ended reasoning. If you cannot enumerate the possible answers, Laya is the wrong tool. "What is wrong with this page" is not a decision-model question. "Is this page thin" is.
Wide option sets. Anything with more than roughly twenty options in a single choice question degrades badly. You have to redesign the question, not just ask it harder.
Zero-shot accuracy on your specific task. This is the most important one. The base checkpoint's zero-shot accuracy on the benchmark its own authors published is 0.362, which they describe as close to random. The headline number that gets quoted, 0.766, came from a checkpoint fine-tuned on that benchmark's training data. If your task is specific, expect to fine-tune or to accept lower accuracy than the marketing suggests.
Multilingual content, if you use the English checkpoint. See below.
The two failure modes to know before you start
This is the section most introductions skip, and it is the one that will save you the most time.
Failure mode 1: script blindness
Laya's English checkpoint is English-only. If you feed it content in another script, it may not just perform poorly. It may perform poorly and be extremely confident about it.
There is a documented case where the English checkpoint scored 0.080 accuracy on Bengali script while reporting 0.945 confidence. That is the worst possible combination: a wrong answer you would never think to question.
The fix: route by script before you decide anything. If your content is not in the script your checkpoint was trained on, send it to the multilingual checkpoint. Laya ships with a router for exactly this purpose. Use it. Do not assume the model will notice that it cannot read the input.
Failure mode 2: overconfidence in general
Laya's probability outputs are not perfectly calibrated. Its reported calibration error is worse than the closed alternative's, and the temperature parameter used to tune it was fitted on training data.
Practically, this means you should not take the confidence number at face value. A 0.9 from Laya does not mean a 90% chance of being right.
The fix: set your confidence threshold from your own labeled data, not from the model's documentation. Run Laya over a few hundred decisions you have already made by hand, look at where it agrees and where it disagrees, and pick a threshold that gives you an acceptable error rate on the decisions you plan to automate. Anything below that threshold goes to a human.
Your 30-minute starter plan
If you want to prove this is useful before committing to anything, do this.
Minutes 0 to 10. Install Laya and confirm it runs. Load the English checkpoint if your content is English.
Minutes 10 to 20. Export a few hundred queries from Search Console. Write one choice question with four intent options. Run it.
Minutes 20 to 30. Hand-label fifty of those queries yourself. Compare your labels to Laya's. Note your agreement rate and look at the confidence values on the disagreements.
By the end you have three things: a working install, a measured accuracy number for your own data, and a sense of whether the confidence values are useful for routing. That is enough to decide whether to build the full workflow.
If the agreement rate is high, move on to the intent classification article. If it is low, try fine-tuning before you give up on the model, because that is where the real accuracy lives.
What to do next
Start with the 30-minute plan above. Then pick the one job from the list of eight that would save you the most time, and read that article.
If you are unsure where to start, begin with intent classification. It is the simplest workflow, it produces an immediately useful artifact, and it will teach you the confidence-gating pattern that every other workflow depends on.
And keep your baseline numbers. Every article in this series builds on them, and by the end you will have a measured picture of what this model can and cannot do for your SEO and GEO work.
Read the rest of the series
This article is part of a thirteen-part series on using Laya for SEO and GEO work.
- What Laya is: the open decision model, explained
- Running Laya locally: hardware, latency, and the real cost model
- Laya for search intent classification at scale
- Fine-tuning Laya on your own SEO labels
- Laya as a local reranker for internal search and RAG
- Laya for GEO answer scoring, offline
- Laya for content audits: keep, update, merge, remove
- Laya for internal linking, and where it breaks
- Guardrails: using Laya to check your own agents
- Laya vs Jev: an honest decision guide
- Building a hybrid stack: Laya local, Jev cloud
- The open-model trade: what you own when you self-host
Author: Maya Ellison, 12-Year GEO Strategy Researcher at Auspia. Maya writes about AI search visibility, brand entity clarity, and practical GEO operating systems for growth teams.
