Better Together: How Jev and LLMs Build an Optimized AI SOC

Two Questions, One Email

A user reports an email to the SOC. Across the top sits a tidy banner, Verified by IT, and the link inside leads to a login page that looks almost right. Two very different questions follow. The first is quick: is this credential phishing? An experienced analyst answers it in seconds. The second is slow: if this is an attack, who else received it, did anyone click, and what did those accounts do next? That one takes real investigation.

Every SOC runs on both kinds of question, yet most AI SOCs send all of them to the same reasoning model, the kind of large language model (LLM) that thinks before it answers. Jev, the System One model TypeSafe AI put into early access last month, is built for the first kind. It isn't an LLM: rather than generating text word by word, it takes the current state and a set of questions and returns one of the answers you defined, with a calibrated probability, in 70 to 500 milliseconds. Its documentation published failure modes and first independent security test all point the same way. The useful question for security teams isn't whether Jev beats LLMs, but what an AI SOC looks like when Jev and an LLM work together, because the pair does far better than either one alone.

Where Jev Fits

A rule of thumb from the launch discussion is a good guide: if an analyst can decide it in under ten seconds, it is probably a job for Jev. That covers a large share of the model calls a typical AI SOC makes. These are bounded choices over a known set of answers, made at high volume:

• Alert triage: asking several yes-or-no questions of an alert at once, such as whether it matches a known-benign admin pattern, involves a privileged identity, or shows execution rather than an attempt.
• Deduplication, correlation and routing: deciding whether two alerts are the same activity, whether a finding belongs to an open case, and which playbook or queue an alert should go to.
• Phishing and hunting screens: giving reported email a category and urgency, and screening candidate hunting hits against the hypothesis.
• Evidence filtering: scoring results from SIEM, EDR and threat intelligence for relevance before they reach an investigation.
• Action guardrails: checking, before an automated workflow isolates a host or disables an account, that the action fits the evidence.

Jev suits these jobs because of the shape of its answers. It can only return an option you defined, so code can act on the result directly, and its probabilities are trained to match how often it is right, so a 0.92 is something a pipeline can set thresholds on. At roughly $0.0004 per decision on one published workload, it is also cheap enough to ask about everything, not just the events a rule happened to flag.

Where Jev Needs a Partner

Jev's limits are just as clear. Investigation, threat research and evidence synthesis are open-ended: the answer isn't on a list, and finding it means chaining facts together. TypeSafe's own notes on jev-1.13 add weaknesses that land squarely on security data: the model doesn't count reliably, reads dates as text, and handles IP addresses, ports and hashes worse than ordinary words.

The bigger concern is adversarial input. In Check Point's first look at Jev, an attacker who controlled one section of a document flipped Jev's verdict in 25 of 27 runs, usually by the fourth turn, for about $0.56 per break. Labelling the content as untrusted barely helped. The winning attacks didn't issue commands; they planted plausible evidence that the warning signs had already been resolved, which is exactly what the "Verified by IT" banner in our example does. In a SOC, attackers write email bodies, file names, command lines and ticket text, so a lone Jev verdict is an argument they can win cheaply.

The strongest defence Check Point measured was reasoning. A reasoning model can notice that a document contradicts itself before it commits. It isn't immune, since the best reasoning setup was still broken in 19% of attempts, but the cost of a successful attack rose to $4.39. Reasoning models carry their own limit, though: they are far too slow and expensive to sit in front of every alert, email and login. Each model is weak exactly where the other is strong, which is why neither Jev nor an LLM should run the SOC on its own end to end.

Better Together: Designing the Handoff Between Jev and LLMs

So, the real design question isn't which model to use, but where one hands off to the other. Go back to the reported email. Jev classifies it in milliseconds as likely credential phishing, marks it urgent and pulls the most relevant evidence from the mail gateway and identity logs. Because the banner is attacker-written and the case is high-risk, it moves to a reasoning agent whatever Jev's score says. The agent works out who else received the email, who clicked and what each account did next, starting from the evidence Jev already filtered rather than the whole SIEM. When it recommends disabling an account, Jev checks in milliseconds that the action fits the evidence, and a human approves anything with real impact.

In that flow, Jev gives the reasoning model focus: a pre-sorted queue and fewer, better inputs, so expensive reasoning is spent only where it's needed. The reasoning model gives Jev scrutiny: a second, harder-to-fool look wherever an attacker controls the input. Together, they also change what a SOC can afford to look at. When a judgment costs a fraction of a cent, every authentication event can get a question and low-severity alerts can be re-scored regularly instead of quietly ageing out, while the reasoning layer works on a far better-chosen set of cases. A few rules keep the partnership safe:

• Let Jev escalate, never silently close. Use confident benign verdicts to deprioritise rather than delete, and sample auto-closed alerts so drift shows up early.
• Send attacker-controlled content to the LLM. Keep SOC-generated telemetry apart from content an attacker wrote and never let a Jev verdict on the latter be the final word on a high-risk case.
• Keep the arithmetic in code. Counts, time windows and IP ranges belong in deterministic enrichment; hand Jev the result as a named fact.
• Test the combined system. Evaluate on your own labelled alerts, with injected content in attacker-controlled fields, and re-run on every model version.

Jev or Laya: Hosted or Local

Once the fast layer is in place, there's one more choice to make: where it runs. Laya is an open-weight decision model built on the same idea of bounded answers rather than free-form text. Jev is the managed, hosted option; Laya can run locally and be fine-tuned for one narrow task. For a SOC handling many customers' data, the choice is mostly about data, not accuracy. Jev needs approved data egress, which is a contractual question for each customer, while Laya keeps the data in place but leaves you owning the compute, serving and evaluation. Many teams will use both: Jev where egress is approved and speed to production matters, and a fine-tuned Laya for customers whose data can't leave, or for one high-volume decision such as deduplication, where a narrow model can outperform a general one. Neither is proven on security workloads by general benchmarks, so both need testing on your own labelled alerts before production.

Where HarkX Comes In

This is how we think about agent design at HarkX. An AI SOC earns trust by matching each decision to the right kind of intelligence: fast judgment where the choice is bounded, deeper reasoning from agents like StriX for investigation and TigrX for threat hunting where it isn't, and a human wherever a decision carries real consequences, with every step transparent about why it was made.

Two Speeds, One SOC

Jev is a decision model, not an LLM, and the two aren't substitutes. Jev doesn't replace LLMs, and LLMs can't do Jev's job at SOC scale. On its own, Jev is fast but easy to argue with; an LLM on its own is careful but too slow and costly to look at everything. Paired, each covers the other's blind spot.

The Takeaway

Jev and reasoning models (LLMs) work best together. The strongest AI SOC isn't built on Jev alone or on a reasoning model alone, but on both: Jev makes the thousands of quick calls fast, cheap and measurable, and reasoning models bring scrutiny to the cases and inputs that need it. The engineering that matters now is the handoff between them.

To see how HarkX's AI agents balance speed with scrutiny across your SOC, book a demo today.

Additional Resources

• Beyond the Brain: How HarkX Uses an AI Harness in the Modern SOC
• How SOC Teams Can Govern Autonomous Security Operations
• From Threat Hunting to Vibe Hunting: How Context-Aware Agents Transform the Hunt

Frequently Asked Questions

What is Jev, and where does it fit in a SOC?

Jev is a System One decision model from TypeSafe AI. It isn't a large language model: instead of generating text, it answers bounded questions by returning one of a defined set of options with a calibrated probability, in well under a second. In a SOC, it fits the high-volume calls an analyst could make in seconds, such as alert triage, deduplication, routing, phishing classification, evidence filtering and checks on automated actions.

Why use Jev and an LLM together instead of one alone?

Each covers the other's weakness. Jev is fast and cost-effective enough to look at everything, but it is easy for an attacker to talk out of the right answer. A reasoning model is much harder to fool and can handle open-ended investigation, but it is too slow and costly to sit in front of every event. Pairing them lets Jev sort and filter at scale while reasoning models scrutinise the cases that matter.

Can Jev close alerts automatically?

It shouldn't on its own. A false escalation costs a few minutes, while a false suppression can cost a breach. The safer pattern is to let confident benign verdicts lower an alert's priority, send high-risk or uncertain cases to a reasoning agent or a human, and regularly review a sample of auto-closed alerts.

How vulnerable is Jev to prompt injection?

In Check Point's first independent test, an attacker controlling one section of a document flipped Jev's verdict in 25 of 27 runs. Since attackers write much of a SOC's input, Jev's verdicts on attacker-controlled content should be backed by corroborating telemetry and a reasoning model's review before they drive any high-risk decision.