S
Shawn Gordon
Guest
What Does It Have to Do with Your Data Catalog?
Every so often, something lands in the AI world, and we all lose our minds for a while as we dive into it. Right now, that something is Jev.
In a short stretch, the community has dropped lists packed with demos and repos, a built-in evaluator in LangSmith, agent frameworks adding support, and public benchmark boards. Everyone is excited about an AI (or SI) thing that can't chat, can't write code, and can't explain itself. It doesn't write at all. It decides things. Let’s talk about that.
Jev comes from TypeSafe AI and is billed as a "System One" model, a nod to Kahneman's fast, intuitive thinking. You hand it some state, either text or JSON, along with typed questions. A choice question picks from up to 255 options. A score question rates on a scale of 2 to 10. A yes/no question returns a probability, and Jev answers all of them in one pass, with no text generation, in roughly half a second.
The two selling points are cost and calibration. TypeSafe lists $0.042 per million input tokens with free output, and its probabilities are trained to match how often it is actually right. That lets you say "above 95%, automate; below that, send it to a person."
It has real limits, though. Because the answer has to come from a fixed list, it can't invent a sentence, but it can absolutely pick the wrong option. Mastra tried it on GitHub issue triage and got about 13% accuracy, because deciding priority needs context Jev can't see.
I wrote about OpenMetadata a year ago, and I want to be clear that what follows is a design idea, not a shipped integration. But the fit is obvious once you look at the work an open-context platform like OMD does for AI.
Take classification. OpenMetadata can auto-tag columns, but that is largely pattern-based, and there is an open community request for pluggable classifiers that return a confidence score and leave an audit trail. A decision model like Jev seems like a natural fit. You pass it a column's name, data type, description, a few sample values, and the table around it. Then you ask a choice question (which classification applies?) and a yes/no question (does this hold personal data?).
The confidence score then does the heavy lifting. Above a high threshold, the API applies the tag. If it rates in the middle, it lands in a steward's review queue. Below that, nothing happens. People still make the judgment calls, and they stop spending their days on the obvious ones.
The same pattern works for agents as well. OpenMetadata ships an MCP server, so an AI agent can read and change the metadata graph. A fast yes/no check ("should this change need a human to approve it?") makes a sensible guardrail before an agent edits an owner or removes a tag.
The big caveat for me with hosted Jev: your metadata goes to TypeSafe's API. Column names are probably fine, but sample data is almost certainly a problem for a lot of installations.
That privacy issue is what made me look at Laya. It comes from Convai Innovations, ships under Apache 2.0, and you run it yourself. There is no API. The English model is ModernBERT-large with a decision head, about 421 million parameters, so it fits on a modest GPU or even a CPU. It answers the same three question types and clocks around 33 milliseconds per question on a T4.
As enticing as that is, Laya is pretty weak out of the box. Convai's own numbers have it scoring 6.04 against Jev's 57.91 on broad benchmarks, and they position it as a model you fine-tune for a specific job. Context is short (512 tokens by default), large label sets hurt accuracy, and its confidence runs overconfident until you get the temperature right.
Here is why I think that's less of a problem for a catalog than for most people. Fine-tuning needs labeled examples, and a catalog full of stewarded metadata is exactly that: columns someone confirmed as sensitive, glossary terms people assigned, tiers a team signed off on. You could train a small model on your own decisions and never have anything leave your network.
I’ve been harping on context for AI with anyone that will listen for months now. A decision model is only as good as the state you hand it. Ask it about a column called id with nothing else, and you get a guess. Tell it the table, the upstream source, the owner, the glossary term, how often it's queried, and what quality tests it passes, and the question becomes answerable. That’s what I’m talking about with context.
That is what a catalog is. OpenMetadata pulls technical metadata, lineage, ownership, usage, quality signals, and policies into one graph, and exposes it through APIs, SDKs, and an MCP server. Assembling the right state for a decision model mostly means querying what is already there.
So I see the two as complementary. The model gets you fast, cheap judgment, and the catalog supplies what the judgment is about. Neither is much use alone: a decision model with no context will guess, and a catalog with no automation leaves your stewards tagging by hand.
None of this has been tested on real catalog data, and obviously that is where the rubber meets the road to see what happens. The Jev ecosystem has PII-checking tools whose own notes admit they can't tell public figures from private individuals and that borderline cases flip between runs. Keep your regex and checksum validation in the loop, and keep people on the low-confidence calls. A consistently wrong classifier that runs cheaply is just a faster way to tag things badly.
A sensible first experiment is one narrow job, such as sensitive versus non-sensitive columns. Score it against tags your stewards have already confirmed, then compare hosted Jev on column names only with a fine-tuned Laya running locally. There is also OpenJev, an independent Jev-style model, but its weights are licensed CC BY-NC 4.0, so it's fine for research but not for shipping in a product.
The point isn't that a small decision model replaces your catalog or your stewards. It's that the catalog finally has a cheap, fast way to act on the context it already holds.
Introduction
Every so often, something lands in the AI world, and we all lose our minds for a while as we dive into it. Right now, that something is Jev.
In a short stretch, the community has dropped lists packed with demos and repos, a built-in evaluator in LangSmith, agent frameworks adding support, and public benchmark boards. Everyone is excited about an AI (or SI) thing that can't chat, can't write code, and can't explain itself. It doesn't write at all. It decides things. Let’s talk about that.
So what the heck is Jev?
Jev comes from TypeSafe AI and is billed as a "System One" model, a nod to Kahneman's fast, intuitive thinking. You hand it some state, either text or JSON, along with typed questions. A choice question picks from up to 255 options. A score question rates on a scale of 2 to 10. A yes/no question returns a probability, and Jev answers all of them in one pass, with no text generation, in roughly half a second.
The two selling points are cost and calibration. TypeSafe lists $0.042 per million input tokens with free output, and its probabilities are trained to match how often it is actually right. That lets you say "above 95%, automate; below that, send it to a person."
It has real limits, though. Because the answer has to come from a fixed list, it can't invent a sentence, but it can absolutely pick the wrong option. Mastra tried it on GitHub issue triage and got about 13% accuracy, because deciding priority needs context Jev can't see.
Where OpenMetadata comes in
I wrote about OpenMetadata a year ago, and I want to be clear that what follows is a design idea, not a shipped integration. But the fit is obvious once you look at the work an open-context platform like OMD does for AI.
Take classification. OpenMetadata can auto-tag columns, but that is largely pattern-based, and there is an open community request for pluggable classifiers that return a confidence score and leave an audit trail. A decision model like Jev seems like a natural fit. You pass it a column's name, data type, description, a few sample values, and the table around it. Then you ask a choice question (which classification applies?) and a yes/no question (does this hold personal data?).
The confidence score then does the heavy lifting. Above a high threshold, the API applies the tag. If it rates in the middle, it lands in a steward's review queue. Below that, nothing happens. People still make the judgment calls, and they stop spending their days on the obvious ones.
The same pattern works for agents as well. OpenMetadata ships an MCP server, so an AI agent can read and change the metadata graph. A fast yes/no check ("should this change need a human to approve it?") makes a sensible guardrail before an agent edits an owner or removes a tag.
The big caveat for me with hosted Jev: your metadata goes to TypeSafe's API. Column names are probably fine, but sample data is almost certainly a problem for a lot of installations.
Enter Laya
That privacy issue is what made me look at Laya. It comes from Convai Innovations, ships under Apache 2.0, and you run it yourself. There is no API. The English model is ModernBERT-large with a decision head, about 421 million parameters, so it fits on a modest GPU or even a CPU. It answers the same three question types and clocks around 33 milliseconds per question on a T4.
As enticing as that is, Laya is pretty weak out of the box. Convai's own numbers have it scoring 6.04 against Jev's 57.91 on broad benchmarks, and they position it as a model you fine-tune for a specific job. Context is short (512 tokens by default), large label sets hurt accuracy, and its confidence runs overconfident until you get the temperature right.
Here is why I think that's less of a problem for a catalog than for most people. Fine-tuning needs labeled examples, and a catalog full of stewarded metadata is exactly that: columns someone confirmed as sensitive, glossary terms people assigned, tiers a team signed off on. You could train a small model on your own decisions and never have anything leave your network.
Context is key
I’ve been harping on context for AI with anyone that will listen for months now. A decision model is only as good as the state you hand it. Ask it about a column called id with nothing else, and you get a guess. Tell it the table, the upstream source, the owner, the glossary term, how often it's queried, and what quality tests it passes, and the question becomes answerable. That’s what I’m talking about with context.
That is what a catalog is. OpenMetadata pulls technical metadata, lineage, ownership, usage, quality signals, and policies into one graph, and exposes it through APIs, SDKs, and an MCP server. Assembling the right state for a decision model mostly means querying what is already there.
So I see the two as complementary. The model gets you fast, cheap judgment, and the catalog supplies what the judgment is about. Neither is much use alone: a decision model with no context will guess, and a catalog with no automation leaves your stewards tagging by hand.
Conclusion
None of this has been tested on real catalog data, and obviously that is where the rubber meets the road to see what happens. The Jev ecosystem has PII-checking tools whose own notes admit they can't tell public figures from private individuals and that borderline cases flip between runs. Keep your regex and checksum validation in the loop, and keep people on the low-confidence calls. A consistently wrong classifier that runs cheaply is just a faster way to tag things badly.
A sensible first experiment is one narrow job, such as sensitive versus non-sensitive columns. Score it against tags your stewards have already confirmed, then compare hosted Jev on column names only with a fine-tuned Laya running locally. There is also OpenJev, an independent Jev-style model, but its weights are licensed CC BY-NC 4.0, so it's fine for research but not for shipping in a product.
The point isn't that a small decision model replaces your catalog or your stewards. It's that the catalog finally has a cheap, fast way to act on the context it already holds.