What the Hell Is Jev? The AI Decision Engine
You have probably seen the word Jev inside Melaya and wondered what on earth it is. Short version: Jev is not a chatbot, and neither is its free, self-hosted cousin Laya. They are decision engines. They do not write you a paragraph. They look at something, answer a typed question about it, and move on, in about a tenth of a second, thousands of times in a row. That quiet little tool removes one of the biggest hidden costs in real AI work, and Melaya just made it a drag-and-drop step in your agents.
Ask a large language model to write an email and it is magic. Ask it to answer the same tiny yes-or-no question ten thousand times, once per row in a spreadsheet, and the magic turns into a bill and a waiting bar. Each answer is a full generation: it thinks, it writes, it costs tokens, it takes a second or two. Multiply that by ten thousand and you have a slow, expensive way to do something that should feel instant.
Jev and Laya are a different kind of model built for exactly this, and most people have never heard of the category. It is called a System One model, and it is the fast, instinctive half of AI. This post explains what it is in plain language, why it quietly removes one of the biggest costs in real agent work, and how Melaya became the first agent builder where you can drop one straight into your own pipeline, hosted and paid or free and self-hosted on our own hardware, with no code.
Contents: what a System One model is, why deciding is the hidden bottleneck in agent work, the two engines Melaya ships, the speed we shipped them at, four money-making use cases from cold outreach to inbox triage, and the no-code way to add a decision to your own agents.
What is a System One model, in plain English
Psychologists describe two ways your brain makes choices. System 2 is the slow one: you sit down, weigh options, and reason it out, like doing long division or drafting a contract. System 1 is the fast one: you glance at a face and know it is angry, you catch a falling glass without planning, you read a sentence and instantly feel whether it is a complaint or a compliment. You are not writing an essay in your head. You just know.
A large language model is System 2 for computers. It reasons, it writes, it explains. Brilliant, but deliberate, and it charges you by the word. A System One model is the fast, instinctive half. You hand it some context and a typed question, and it hands back a calibrated answer with zero words generated. It does not chat. It decides. That is what Jev and Laya are.
A large language model writes you an answer. A System One model just answers, instantly, with a probability attached, and never spends a token writing prose. One is a novelist. The other is a judge who only ever says yes, no, or which one.
You hand it any text, an email, a post, a page, a ticket, and it answers one of three shapes of question. That is the whole vocabulary:
- Choice: pick one label from a set. Billing, technical, or sales. Spam or real. Buy, hold, or sell.
- Score: rate on a described scale. Urgency from low to critical, quality from poor to excellent.
- Noul: a yes or no where the probability itself is the signal. 'Is this a refund request?', answered 0 to 1.
- Every answer comes back with a confidence number attached, in about 100 milliseconds, with zero words generated.
That is it. No prompt engineering, no parsing paragraphs, no hoping the model returns valid JSON. You ask a typed question and get a typed answer back, the same way every time, fast enough to run over an entire dataset.
Why deciding is the hidden bottleneck in real agent work
Here is the thing nobody tells you when you start building agents. The exciting part, the writing and the acting, is a small slice of the work. The bulk of real agent work is judgment applied over and over: which of these 3,000 leads is worth contacting, which of these 800 pages is thin, which of these 500 support tickets is actually urgent, which of these reviews mention a bug. That is not writing. That is deciding, thousands of times.
If your only tool is a chat model, you loop it over every item, and you pay the System 2 tax on a System 1 job. It is slow, because each item is a full generation. It is expensive, because each item is a full bill. And it is fragile, because you are asking a novelist to reply with a clean label and praying the format holds. Most teams quietly give up and just look at the top 20, because scoring everything with an LLM is not affordable.
- System One model, scoring every itemAbout 100 ms each, zero output tokens, runs over the whole dataset without folding to a sample
- Chat model, one generation per itemSeconds each, full token cost, so at scale you are forced to look at a tiny top slice instead
A System One model removes that tax. Because a decision is a single fast pass with no words generated, you can afford to score everything, not a sample. The whole spreadsheet. Every page on the site. Every comment in the thread. The agent still uses a chat model for the parts that need writing and reasoning, and hands the "apply this judgment ten thousand times" part to the decision engine. Right tool, right job. This is the same instinct behind our deterministic-first reliability system: use the cheap, exact, calibrated mechanism wherever a decision can be one, and save the expensive model for what only it can do.
Jev and Laya: two decision engines, one interface, inside Melaya
Melaya ships two System One engines, and they speak the exact same language, so you can switch between them by changing one setting. You write your typed questions once and pick where the decision runs.
Jev is the hosted engine. It is a managed, calibrated decision service you connect like any other provider. You bring an API key, it runs on someone else's fast hardware, and it is metered by usage. Reach for it when you want the lowest latency and zero infrastructure.
Laya is the free one, and it is the part we are most proud of. It is an open-weight System One model that Melaya runs on its own CPU, so a decision costs you nothing beyond compute we already have. Same three question types, same calibrated answers, and because it is self-hosted, the data being judged never leaves our environment. It is the natural fit for privacy-sensitive work and for scoring at a volume where a per-call meter would sting. If you like keeping AI in-house, it pairs with the same thinking as self-hosted AI agents. For who publishes Laya and every place it runs in Melaya, from Fast Mode to MCP, read the Laya System One model guide.
| Jev (hosted) | Laya (free, self-hosted) | |
|---|---|---|
| Where it runs | Managed cloud service | Melaya's own CPU |
| Cost | Metered by usage | Free beyond compute |
| Best for | Lowest latency, no infra | Scale, privacy, on-prem |
| Speed | Fastest | About 100 ms per decision, measured |
| Interface | Identical typed questions | Identical typed questions |
- The same three primitives: choice to route or classify, score to rank on a described scale, noul for a calibrated yes or no
- Calibrated confidence on every answer, so your logic can threshold instead of guessing
- Batch tools that score an entire file of items in one call, ideal for thousands of rows
- A drop-in swap: move a workflow from paid Jev to free Laya without rewriting a single question
The point is not that decision models exist. Researchers have known about them for a while. The point is that Melaya is the first agent builder that lets a non-engineer drop one into a real pipeline, next to their web search and their email tools, and choose hosted or free with a click. That is the leap from "interesting paper" to "thing you can ship this afternoon."
Built in days, not quarters: our speed is the moat
We want to be honest about why this matters beyond the feature itself. The AI market does not reward the company with the cleverest idea. It rewards the company that turns a clever idea into something a customer can use, first. When a genuinely useful capability like calibrated System One decisions appears, the question is not "can we understand it," it is "how fast can we make it a button."
For Melaya, the answer was days. The connector, the batch tools, the free self-hosted service, per-user rate limits so nobody can swamp the shared engine, the metering, and the documentation all landed as one coherent surface, and it validated on real work on day one. That speed is not an accident. It is the direct result of an agent platform that treats every new capability as one more tool in a catalog of thousands of tools, wrapped in the same reliability and approval layers as everything else. Add the engine, and it inherits the whole runtime for free.
Most people who could benefit from a decision engine do not know it exists, let alone how to wire one into an agent. That is exactly the gap Melaya closes. You do not need to know the theory of System One models. You describe the judgment you want in plain words, pick free or hosted, and point it at your data. We did the hard part so the decision looks like any other step.
Use case one: qualifying a whole market on Reddit, for free
Here is a real one we run. Say you sell to founders and indie builders and you want to find, and genuinely help, the people on Reddit who are stuck on the exact problem you solve. Doing that by hand is a full-time job. Doing it with a chat model on every post is unaffordable at any real volume.
With a System One engine it becomes a pipeline that reads the whole room instead of skimming the top of it. An agent finds the communities where your buyers gather, the decision engine scores every candidate for fit in seconds, and then two harvest agents pull down the posts and the comments in parallel. The decision engine then qualifies every single item on four typed questions at once: is this a real pain we solve, what is the person's intent, how well do they fit our ideal customer, and would a reply add honest value.
That is the part that only a System One model makes possible. In one live run on our own free CPU, the pipeline crawled hundreds of posts across those communities and the decision engine qualified every single one, four typed questions apiece, turning a firehose no human could ever read into a ranked shortlist of the handful of people actually worth a personal reply. Doing the same with a chat model would put a token bill and a generation wait on every item, so in practice you would skim the top of one thread and miss the rest. Point it at a whole market instead of a sample and that is thousands of posts and comments a week, still for free, still scored down to the last one. Only then does a writing model draft a genuinely helpful reply, and, if you want, an agent posts it from your phone through Device Control.
- It scores the ENTIRE harvest, posts and comments, not a top-N sample, so no good lead is missed
- Four typed judgments per item in a single pass: pain, intent, fit, and reply-value
- Free and self-hosted, so scoring thousands of items costs nothing and the data stays in-house
- The chat model only touches the few leads that survive, which is where writing quality actually matters
Use case two: never miss a hot inbound lead or ticket
If you are a founder or a small team, your inbox is a firehose of forms, emails, and support tickets, and the expensive ones are the hot leads and the angry customers you did not get to in time. Reading them all is a tax on your day. Running a chat model on each one is overkill and adds up fast.
A decision engine turns that firehose into a ranked queue. Point it at every incoming message and ask three typed questions: is this a buyer or a browser, how urgent is it, and does it need a human right now. Every message gets a calibrated score in about a tenth of a second, so a solo founder opens a sorted list instead of a chronological pile, hot leads and blocking issues float to the top, and the routine stuff can be auto-acknowledged or routed. It is the cheapest possible way to make sure the message that pays your rent never sits unread for a day. This pairs naturally with an agent built for founders and small teams.
Use case three: turn a flood of customer feedback into a ranked to-do
Small and mid-size businesses drown in feedback: app-store reviews, support replies, survey answers, social mentions. The signal you actually need, a spike in a specific bug, a churn-risk complaint, a feature people keep begging for, is buried in the noise, and no one has time to read all of it.
Point a decision engine at every piece of feedback and ask it to score sentiment, whether it is a bug report, how urgent it is, and whether it signals churn risk. Now the whole flood sorts itself: the real bugs cluster, the angry-but-savable customers surface, and the praise you can quote in marketing separates from the routine. A team of three gets the insight of a team of thirty, because the reading-and-sorting work, the part that never scaled, is done for free in the background. It is exactly the kind of leverage a lean operations team is looking for.
Use case four: AI SEO audits over a whole site, coming to Melaya Marketing
The same shape unlocks a feature we are building next into Melaya Marketing. A serious SEO audit is judgment applied across a whole site: which pages are thin, which target no clear keyword, which have weak internal linking, which titles will truncate in search results. Today most audit tools either use rigid rules that miss nuance, or an LLM that can only afford to look at a sample.
A System One engine lets an audit score every page and every query, not a top slice, with calibrated judgments a marketer can actually rank and act on. Instead of "here are your 20 worst pages according to a rule," it becomes "here is every page, scored for thinness, keyword focus, and internal-link strength, sorted so you fix the highest-impact ones first." That is the kind of thoroughness that used to be impossible on a budget, and it is exactly what a decision engine makes cheap. It is a natural fit for teams running marketing on Melaya who want depth without a per-page bill.
How to add a decision to your own agent, with no code
You do not need any of the theory above to use this. Inside the Melaya agent builder, adding a decision step is three plain-language moves.
- Give an agent the decision tools: the free self-hosted set is always on, or connect Jev if you want the hosted engine
- Describe your questions in words: name the choice options, describe the score scale, or write the yes or no you want a probability for
- Point it at your data: hand it a file of items and it scores them all at once, then returns the top matches sorted for you
That is the whole job. No parsing, no format wrangling, no infrastructure to stand up for the free engine, because we host it. The decision step sits in your pipeline next to everything else, protected by the same human-in-the-loop and reliability layers as the rest of your agents, and you can chain it into a bigger workflow: harvest, decide, draft, approve, act. The decision engine is the quiet workhorse in the middle that makes the whole thing scale.
Why we build this way
Melaya's bet is simple. The winners in AI will not be the teams that can explain the most impressive research. They will be the teams that put the right tool in a normal person's hands, fast, and make the powerful thing feel ordinary to use. A System One decision engine is a perfect example: genuinely advanced under the hood, and genuinely boring to use, which is exactly how it should feel. You describe a judgment, we run it thousands of times in the blink of an eye, and you never think about tokens or theory again.
That is the through-line across everything we ship. Agents that can act on your phone and your browser, a reliability system that makes wrong actions structurally hard, private and compliant by design, and now a decision engine you can run for free at any scale. Different features, one mindset: take the hardest, most useful capabilities in AI and turn them into buttons a founder can press. Decisions were the missing button. Now they are in the box, and they are called Jev and Laya.
To see where Jev and Laya fit alongside the Marketing workspace and the browser and MCP work that shipped the same month, read the September 2026 recap.
