Fast Judgments, Not More Text: Bringing Jev and Laya into MatterMine

Ask most AI legal tools a question and you get an essay back. It might be a good essay. But someone still has to read it, check every case it mentions, and decide whether to trust it. For a busy practitioner, a confident paragraph with no indication of how sure the system actually is can create more work, not less.

While building MatterMine, we kept running into the same pattern. Many of the hardest parts of legal research aren’t writing problems at all. They’re judgment problems:

• Of these thirty passages, which ones actually answer the question?
• Does this quoted passage really support the proposition it’s cited for?
• Is the system sure enough to show this result, or should a person look at it first?

These are exactly the questions a new class of AI model is built for. Here’s how we’re incorporating them into MatterMine.

System One models: answers, not essays

The name comes from Daniel Kahneman’s distinction between System 1 thinking — fast, intuitive judgment — and System 2 — slow, deliberate reasoning. Large language models like the ones behind most chatbots are general-purpose generators: they write text, code, and long explanations of their reasoning.

A System One model does something narrower. You give it some state (a passage of text, a search query, a JSON object) and a set of typed questions, and it returns structured answers with probabilities attached. As TypeSafe’s documentation puts it, these models “do not write replies, produce code, or generate explanations of their reasoning.” They make fast, focused judgments that software can use directly.

The question types are deliberately simple:

• Choice — pick one option from a defined set (e.g. supports / contradicts / says nothing), with a probability for every option.
• Score — rate something against ordered, described levels (e.g. how relevant a passage is, from “unrelated” to “directly on point”).
• Noul — a single probability that a yes/no statement is true.

Because the output is a number rather than a paragraph, our code stays in charge. MatterMine decides what to do with each answer: show it, sort by it, or hand it to a person.

Jev and Laya

TypeSafe offers System One models through an API, and Jev is its flagship model. It’s trained for calibrated decisions, meaning its probabilities are tuned to reflect real uncertainty rather than sounding confident by default.

Laya is an open-source, Jev-compatible System One model. The Laya model weights are published by Convai Innovations under Apache 2.0, and the @receptron/laya package runs them in Node.js and TypeScript using ONNX Runtime. The request and response shape follows Jev’s system_one API, so the same questions work with either model.

That compatibility matters to us. It means we can choose where each judgment runs:

• Jev, through TypeSafe’s hosted API, where we want their flagship model and its managed infrastructure.
• Laya, running inside our own infrastructure, for workloads where we want the processing to stay entirely in our environment, or where we’re making large numbers of small calls and want predictable costs.

For a legal product, where firms care deeply about where their matter information goes, having that choice built into the architecture rather than added later is a real advantage.

Where it fits in MatterMine

1. Re-ranking search results

MatterMine first finds candidate passages quickly using conventional search. It’s fast and cheap, but keyword matching often puts the most useful passage at position eight instead of position one.

We’re adding a re-ranking step: for each candidate, a System One model judges how well the passage answers the user’s actual question, and MatterMine reorders the shortlist by that judgment. TypeSafe has published a demonstration of this pattern on CLERC, a public dataset of court-opinion passages. In their test, the correct passage came first for 30% of queries, up from 5% with keyword search alone. It’s a vendor-run test on a small sample (40 queries), so we’re measuring it against our own data, but the direction is very encouraging.

A re-ranker can only reorder what search found; it can’t add a passage that search missed. So we’re improving retrieval and re-ranking together.

2. Checking citations

AI-generated summaries that cite authority are only useful if the citations are real and say what’s claimed. We check each citation in two steps:

1. Does the quote exist? Plain code checks that the quoted text actually appears in the source judgment. If it doesn’t, it’s flagged as fabricated, and no AI is needed to work that out.
2. Does it support the claim? A single Choice question asks whether the passage supports, contradicts, or says nothing about the proposition it’s cited for.

This turns “trust me” into a clear verdict for each citation: verified, unsupported, contradicted, or fabricated.

3. Knowing when to ask a human

Every answer comes with a probability, so MatterMine can set thresholds and act on them. High-confidence results flow through; uncertain ones are flagged for the user to review, or handed to a slower reasoning model for a closer look.

We’re conservative here. Calibration is measured across many predictions, so it doesn’t guarantee that any single answer is right. TypeSafe’s own citation-check example included an unsupported citation that scored highly enough to be auto-accepted. That’s why we start with strict thresholds, tune them against real legal material, and never treat a model’s probability as a substitute for professional judgment. MatterMine helps practitioners find and check authority faster; it doesn’t replace their review.

Why this approach

Building with small, typed judgments instead of open-ended generation gives us a few things we value:

• Measurable — each judgment can be tested against known answers, so we can see exactly where the model is strong and where it isn’t.
• Composable — relevance, support, and confidence are separate signals that code combines with clear, explainable rules.
• Efficient — many small questions can be asked in parallel over the same text, keeping research fast.
• Flexible on hosting — the same questions run on hosted Jev or self-hosted Laya, depending on the job.

What’s next

We’re rolling these capabilities into MatterMine progressively, starting with re-ranking and citation checks, and validating each one on Australian case law before it reaches users. If you’re a legal professional who wants faster research with clearer signals about what to trust, take a look at MatterMine or get in touch with our team. We’d love to hear what judgments you’d like your research tools to make for you.

Cover photo by Sasun Bughdaryan on Unsplash.