A spam check has a budget that most AI problems do not. Someone is sitting in front of a contact form with their finger on Send, and the answer has to arrive before they notice they are waiting. That is a few hundred milliseconds, total, including the network.
Large language models are very good at judging whether a message is junk. They are also built to write, which means they produce an answer one token at a time, and then something on our end has to read that text back and turn it into a number. For a filter that runs on every submission across thousands of sites, that is slow in exactly the place where slow is most visible.
So spam filters, ours included, lean on fast deterministic signals first and reach for the heavier model only where it earns its place. That works. It also means the sharpest judgment in the system is the part that is hardest to use everywhere.
ActiveLayer now runs Jev, a model built to make exactly that kind of call.
What Jev is
Jev comes from TypeSafe AI, a San Francisco company founded by Diogo Almeida, Erik Gafni and Sasha Sheng. It went into early access on 15 September 2026. TypeSafe calls it a System One model, and the defining property is easy to state: it does not write text.
You hand it a block of state, which can be an email, a log line, a form submission, a blob of JSON, along with a list of typed questions. It evaluates them in parallel and returns typed answers: a choice from a set you supplied, a score on a rubric you defined, or a probability on a yes or no question. Each answer carries its own calibrated confidence value.
Because the answer is drawn from a schema you provide rather than generated as a string, there is no output to parse and no format for the model to get wrong. It cannot invent a field, return prose where a number belongs, or wrap a verdict in an apology. TypeSafe reports end-to-end response times between 70 and 500 milliseconds.
The trade is real and worth stating plainly. Jev gives up the thing generative models are famous for. It cannot explain itself, cannot reason through several steps, and cannot handle a problem whose shape you have not decided in advance. It answers questions you already knew to ask.
Why that shape fits a spam check
A spam check is not an open question. It is a small, fixed set of decisions made under a latency budget, and the answer needs to be a number our code can threshold against, not a paragraph.
That is the same sentence twice. The description of what a System One model does and the description of what a spam filter needs are, for practical purposes, identical. Everything Jev gives up is something a spam check never wanted. Nobody needs the filter to explain itself in prose at the moment a form is submitted, and nothing downstream of the check can use a paragraph.
It also happens to be the case TypeSafe leads with. Their published evaluation sorted 19,528 emails into spam and legitimate mail with no training data at all, using a single yes or no question, and scored 96% accuracy. Writing a precise definition of what counted as spam took that to 98.3%, which matched a classifier trained on roughly 14,800 hand-labeled examples. Those are TypeSafe’s numbers, measured on their own harness and on email rather than on web form submissions.
Nothing had to be adapted to make the two meet. There was no adapter to write, no prompt to tune into returning clean JSON, no retry path for the times a model answers in the wrong format, and no parsing layer to maintain. You define the questions and the shape of the answers, and the answers come back in that shape. That is why the integration took a day rather than a sprint.
Anyone who has put a language model into a production path knows how much of that work there normally is, and how much of it is defensive: the schema validation, the repair prompts, the fallback for when a verdict arrives wrapped in an explanation nobody asked for. A model that cannot return a malformed answer deletes that entire category of code.
What went into our filter is a signal it did not have before, built on that model. A filter works with the signals available to it, and there is now one more.
Why five narrow questions beat one broad one
The speed is the headline. What matters more for a filter is that the questions are answered together.
A model that generates text answers one question at a time, so every extra question you want to ask is another wait you cannot afford inside a form submission. Jev evaluates the whole list in a single pass. One round trip comes back with five answers instead of one, which means asking five narrow questions costs the same wait as asking one broad one.
Narrow questions are also the ones a filter gets right. “Is this spam” is a judgment call with a lot packed into it. “Does this message contain a link to a domain unrelated to its text”, “is this written to evade a filter”, “would a real customer of this business plausibly send this” are smaller, sharper, and each comes back with its own confidence value that our code can weigh separately. That matters most on the messages that are nearly right. A real customer writing in a hurry and a spammer imitating one look similar under a single verdict, and different under five.
What this means for your forms
Your contact form now sits behind a filter with a sharper judgment available to it on the messages that are hardest to call. Obvious junk was never the difficult part. The difficult part is the message where a real customer writing badly and a spammer writing carefully look the same, and that is the part this is aimed at.
There is nothing to install, nothing to configure and no setting to go and find. It came with the service you already have.
Everything else works the way it did. The check runs on our servers, so your visitors never see a puzzle, never sort through pictures of traffic lights, and never have to prove anything. If our API cannot be reached, the check fails open and the submission goes through, because a form that silently stops working is a worse outcome than a piece of spam.
Jev sits inside that system, not in place of it. The deterministic signals still run and they still catch most of what arrives, which is what keeps the whole thing fast.
Get started
ActiveLayer is server-side spam protection for forms and comments. Install the plugin, paste your API key, and submissions start being checked. It works with the form and membership plugins you already use, and the documentation covers the REST API if you are protecting something we do not have an integration for.
Not sure whether your forms are catching what they should? Reach out. We read every message, and our team will help you get this running.