System One Models: Instant AI Decisions at Scale

Everyone is racing to make AI talk. The bigger win, hiding in plain sight, is making AI decide. A System One model does not write you a paragraph. It looks at something, answers a typed question about it, and moves on, in about a tenth of a second, thousands of times in a row, for free. Melaya just made that a drag-and-drop tool inside your agents, and it is the kind of quiet advantage that compounds.

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.

There is a different kind of model built for exactly this, and most people have never heard of it. 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, either hosted and paid or free and self-hosted on our own hardware, with no code.

0output tokens per decisionit scores, it never writes

~100 msper decision on plain CPUmeasured, self-hosted

40 in 31 scommunities scored in a live runfree, on our own box

2engines, one interfacehosted Jev or free Laya

Contents: the two speeds of thinking and where System One fits, why "decide" is the hidden bottleneck in agent work, the two decision engines Melaya ships and how they differ, the speed at which we built this, two concrete money-making use cases, and the no-code way to add a decision step to your own agents.

What is a System One model, in plain English

A calm split image of instinctive versus deliberate thinking, rendered in bright Melaya brand light

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.

The one-sentence version

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.

It answers three shapes of question, and that is the whole vocabulary:

INYou give it some stateany text: an email, a Reddit post, a web page, a support ticket, a product review

?Choicepick one label from a set: billing, technical, or sales; spam or real; buy, hold, or sell

?Scorerate on a described scale: urgency low to critical, quality poor to excellent

?Noula yes or no where the probability itself is the signal: is this a refund request, 0 to 1

OUTA calibrated answerthe pick, the score, or the probability, each with a confidence number, in about 100 ms

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 "decide" is the hidden bottleneck in real agent work

A wall of thousands of small documents, a bright beam sorting them into neat stacks in Melaya light

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

Two glowing engine cores side by side, one hosted in the cloud and one on a local machine, bright brand palette

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.

	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

What both engines give an agent

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

A bright, fast assembly line of glowing components snapping into place, Melaya light studio

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.

The user-oriented part

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

A friendly operator watching a bright dashboard sort thousands of Reddit posts into a short list of strong leads

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. An agent discovers the communities where your buyers gather, then a decision engine scores every one of them for fit. In a live run, it scored 40 candidate communities in about 31 seconds on our own hardware, for free, and ranked them so only the strongest survived. Then two harvest agents pull posts and comments in parallel and the decision engine qualifies every single item on four typed questions at once: does this describe a real pain we solve, what is the person's intent, how well do they fit our ideal customer, and could we add honest value by replying. The thousands become a short list of the best few, and 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.

1Discover communitiesan agent finds the subreddits where your ideal customer actually gathers

2Score every one for freethe decision engine rates community fit and keeps only the strong matches

3Harvest and qualify at scalethousands of posts and comments scored on four typed questions in one pass each

4Draft and act on the best fewa chat model writes the reply, a human approves, an agent posts it on the phone

The decision engine is the reason the whole thing is affordable. It is what lets the pipeline consider the entire market instead of a handful of posts, which is the difference between a demo and a growth channel.

Use case two: AI SEO audits over a whole site, coming to Melaya Marketing

A bright, airy visualization of an entire website map being scored page by page in Melaya light

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 citations are ungrounded, 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

A simple, clean agent builder canvas with a decision tool being dropped onto an agent, bright UI

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.

What Melaya ships

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.

Frequently asked questions

What is a System One model?

A System One model is a fast, non-writing AI that answers typed questions about some input and returns a calibrated answer with zero words generated. The name borrows from psychology: System 1 is the brain's fast, instinctive judgment, System 2 is slow reasoning. A large language model is System 2 for computers, deliberate and priced by the word. A System One model is the fast half: it does not chat, it decides, in about a tenth of a second.

How is a System One model different from an LLM?

An LLM generates text: it reasons and writes a paragraph, which costs tokens and takes a second or two per answer. A System One model does not generate text at all. It scores a typed question and returns a pick, a rating, or a probability, in roughly 100 milliseconds, with no output tokens. Use the LLM for writing and reasoning, and the decision model for applying the same judgment across thousands of items affordably.

What are Jev and Laya in Melaya?

They are the two System One decision engines Melaya ships, and they share the same interface. Jev is a hosted, managed decision service you connect with an API key and pay by usage. Laya is a free, open-weight model that Melaya runs on its own CPU, so decisions cost nothing beyond compute we already have and the data never leaves our environment. You write your questions once and choose which engine runs them.

Is the free decision engine really free to use?

Yes. Laya runs self-hosted on Melaya's own hardware, so there is no per-decision meter. It answers the same choice, score, and noul questions as the hosted engine, at about 100 milliseconds per decision on plain CPU in our measurements, which is fast enough to score an entire dataset rather than a sample. Per-user rate limits keep the shared engine fair, and privacy-sensitive work stays in-house because nothing is sent to an outside API.

What can I use a decision engine for in an agent pipeline?

Anything that is judgment applied many times: qualifying thousands of sales leads, classifying support tickets by urgency and topic, routing requests to the right handler, scoring every page in an SEO audit, moderating content, ranking candidates, or filtering a large scrape down to the items worth acting on. The agent uses a chat model for writing and the decision engine for scoring at scale, which is what keeps the whole workflow fast and affordable.

Do I need to be technical to add one to my pipeline?

No. In the Melaya agent builder you give an agent the decision tools, describe your questions in plain words, and point it at your data. There is no parsing, no JSON wrangling, and no infrastructure to run for the free engine because Melaya hosts it. The decision step sits in your workflow like any other tool and is covered by the same human-in-the-loop and reliability protections as the rest of your agents.

Why does zero output tokens matter?

Because output tokens are where a chat model spends most of its time and most of your money. A System One model produces no output text, it emits a calibrated score, so each decision is both fast and cheap. That is the property that makes scoring an entire spreadsheet, website, or scrape practical, instead of being forced to look at a small top slice because a full LLM pass over everything would be too slow and too expensive.