{"slug": "jev-and-duckdb-plain-english-conditions-in-sql", "title": "Jev and DuckDB: Plain-English Conditions in SQL", "summary": "TypeSafe AI released Jev, a \"System One\" model that returns typed answers with calibrated probabilities instead of generated text, on September 15, 2026, and within ten days community-built DuckDB extensions let users filter, classify and score table rows with plain-English conditions. TypeSafe quotes 70–500 ms end-to-end latency and $0.042 per million input tokens with output tokens free, and the launch followed a $40 million seed round. Hamilton Ulmer posted on X that his DuckDB extension classifies about 1,000 rows from any CSV, Parquet file or table in roughly ten seconds, while Zachi's pg-jev Postgres function judged 129 rows in about a second for under a tenth of a cent before Actian hired him.", "body_md": "# Jev and DuckDB: Plain-English Conditions in SQL\n\n*TL;DR: TypeSafe AI released Jev, a model that returns typed answers instead of text, on September 15, 2026. Within ten days, several community extensions let you filter, classify and score DuckDB rows with plain-English conditions. This post covers what Jev is, how the extensions work and the posts and videos about them.*\n\nSay you have a Parquet file of 50,000 support tickets and want to know which customers are angry. A [`LIKE` pattern](https://duckdb.org/docs/lts/sql/functions/pattern_matching.html) won't find that. The usual options are to label data and train a classifier, or to send each row to a chat LLM and parse the text it returns. The first takes work up front. The second is slow and costs more per row.\n\nOn September 15, 2026, [TypeSafe AI introduced Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev), a model that answers this kind of question with a typed value and a probability instead of a paragraph. Within a week, [Hamilton Ulmer posted on X](https://x.com/hamiltonulmer/status/2100370557405667768) that he had built a DuckDB extension that classifies about 1,000 rows from any CSV, Parquet file or table in roughly ten seconds. Other DuckDB extensions appeared over the next few days.\n\nThis post describes what Jev is, how the extensions work and where to read more.\n\n## \n[What Jev Is](#what-jev-is)\n\nJev is what TypeSafe calls a *System One model*: you send it a state and a set of questions, and it returns typed answers with calibrated probabilities. It never generates a sentence. In the [launch post](https://typesafe.ai/blog/introducing-system-one-models-and-jev), founder Diogo Almeida (who worked on the research behind ChatGPT at OpenAI) describes it as a function call backed by frontier intelligence. The name refers to Kahneman's fast System 1 thinking and to the economist William Stanley Jevons.\n\nThere are three question types, and each corresponds to something SQL already has:\n\n| Jev type | What it returns | SQL analogue | \n|---|---|---|\n| Noul | A yes/no judgment with a probability | A `BOOLEAN` predicate in`WHERE` | \n| Choice | One option from a fixed list (up to 255) | An `ENUM` column you can`GROUP BY` | \n| Score | A position on an ordered rubric | An ordinal you can `ORDER BY` | \n\nTypeSafe quotes 70–500 ms end-to-end latency and $0.042 per million input tokens, with output tokens free. All questions in a request are evaluated in parallel, so asking five questions about a row takes little more time than asking one. The launch post lists \"map-reducing over big data\" as a target use case, which is the kind of work people use DuckDB for.\n\nFor independent context, [The New Stack's launch coverage](https://thenewstack.io/typesafe-jev-system-one/) covers the $40 million seed round. [LangChain's post on building a harness with Jev](https://www.langchain.com/blog/building-a-harness-with-jev) shows where it fits inside an agent loop. [Hyperstack's deep dive](https://www.hyperstack.cloud/technical-resources/tutorials/jev-inside-typesafe-ais-first-system-one-decision-model) reproduces the scoring mechanism on an open model and checks TypeSafe's speed claims against LangChain's benchmark. Note that the headline 190× speedup figures come from TypeSafe's own workflow evals.\n\n## \n[pg-jev and the DuckDB Ports](#pg-jev-and-the-duckdb-ports)\n\nThe first SQL integration was for Postgres. On September 17, Zachi [posted pg-jev on X](https://x.com/iam_zachi/status/2100679300756435135): a `jev()` function that turns a plain-English condition into a `WHERE` clause, with no index and no embeddings. His demo judged 129 rows in about a second for under a tenth of a cent, and you can try it on mock tables in the [pg-jev live demo](https://pgjev.zachi.dev/). The [source is on GitHub](https://github.com/realZachi/pg-jev). Four days later, [Actian hired him](https://runtimewire.com/article/actian-hires-pg-jev-creator-mahmoud-zachi-enterprise-ai).\n\nDuckDB ports followed within days. The closest to the original is [judoaseeta/duckdb-jev](https://github.com/judoaseeta/duckdb-jev), which keeps pg-jev's function names.\n\n### \n[Installation](#installation)\n\nWith the exception of the [`jev` community extension](https://duckdb.org/community_extensions/extensions/jev), most of the extensions are not yet distributed through the community extensions repository, so you build them yourself and load them as unsigned extensions.\nFor the rest of the post, we'll use the `jev` community extension. To install and load it, run:\n\n```\nINSTALL jev FROM community;\nLOAD jev;\n```\n\nThen set your TypeSafe API key, which you can get from the [TypeSafe console](https://console.typesafe.ai/) after registering and topping up your account:\n\n```\nSET jev_api_key = '...';\n```\n\nThe extension must be built for the exact DuckDB version and platform you run.\n\n### \n[An Example](#an-example)\n\nWarning All of the extensions in this post send row contents to a third-party API. Do not use them on data you are not allowed to share.\n\nLet's start with filtering using the `person` table of the [LDBC SF0.1 dataset](https://ldbcouncil.org/benchmarks/snb/datasets/).\n\n```\n-- Filter: a boolean predicate\nCREATE TABLE person AS\nFROM 'https://blobs.duckdb.org/data/ldbc-sf0.1-person.parquet';\n\nSELECT id, firstName, lastName\nFROM person\nWHERE jev(person, 'the name is European')\nLIMIT 5;\n┌────────────────┬───────────┬──────────┐\n│       id       │ firstName │ lastName │\n│     int64      │  varchar  │ varchar  │\n├────────────────┼───────────┼──────────┤\n│           1129 │ Carmen    │ Lepland  │\n│ 10995116278700 │ Joseph    │ Anderson │\n│ 28587302322727 │ Steve     │ Moore    │\n│ 30786325578904 │ Giuseppe  │ Donati   │\n│  6597069766983 │ A. C.     │ Bos      │\n└────────────────┴───────────┴──────────┘\n```\n\nIn a ticketing system, you could rank, classify or score the tickets as follows:\n\n```\n-- Rank: a probability you can sort on\nSELECT subject, jev_prob(tickets, 'the customer is angry') AS p\nFROM tickets\nORDER BY p DESC\nLIMIT 20;\n\n-- Classify: one of a fixed set of labels\nSELECT\n    jev_choice(tickets, 'which team should handle this?',\n               ['billing', 'technical', 'security', 'sales']) AS team,\n    count(*)\nFROM tickets\nGROUP BY 1;\n\n-- Score: a position on an ordered rubric\nSELECT\n    name,\n    jev_score(products, 'how luxurious is this product?',\n              ['budget', 'mid-range', 'premium', 'luxury']) AS luxury\nFROM products\nORDER BY luxury DESC;\n```\n\nBecause `jev()` returns a boolean, it works with the rest of SQL. If you add a cheaper condition such as `age > 40` in the same `WHERE` clause, it runs first, and rows it rejects are never sent to the API. A `LIMIT` stops the scan early, and `jev_max_rows_per_statement` caps the spend.\n\nThe video [“I Tested Jev with DuckDB. It's 1.8x Faster Than Haiku.”](https://www.youtube.com/watch?v=31VCA2Zlkc8) demonstrates plain-English SQL queries in DuckDB and compares Jev's speed with Claude Haiku. The 1.8× figure is from one test.\n\n## \n[The DuckDB Extensions](#the-duckdb-extensions)\n\nSeveral people built these extensions independently, and they made different choices about batching, caching and output types.\n\n| Extension | Angle | Notable detail | \n|---|---|---|\n| [judoaseeta/duckdb-jev](https://github.com/judoaseeta/duckdb-jev) | Port of pg-jev | Same `jev` ,`jev_prob` ,`jev_choice` ,`jev_score` API, plus a process-wide cache keyed by row content | \n| [recodelabs/duck-jev](https://github.com/recodelabs/duck-jev) | Natural-language `WHERE` clauses | Groups rows by question, judges duplicates once, runs batches across threads and shares a database-scoped cache | \n| [prasanthj/duckdb-jev](https://github.com/prasanthj/duckdb-jev) | Throughput and production controls | Packs up to 1,000 judgments per request, streams across DuckDB chunks, reports usage through `jev_usage()` | \n| [Colliber's duckdb-jev](https://madewithjev.com/builds/duckdb-jev) | Typed results | Adds `jev_choice` ,`jev_score` ,`jev_noul` and`jev_ask` . A choice's options become an`ENUM` column type | \n\nDuckDB passes rows to an extension in chunks of up to 2,048, which suits batched API calls. The [recodelabs extension](https://github.com/recodelabs/duck-jev) groups each chunk by question and options, skips identical rows and sends the rest in batches across `jev_concurrency` threads. It retries 429s and 5xx errors with exponential backoff.\n\nBatching makes a large difference to speed. The [prasanthj extension](https://github.com/prasanthj/duckdb-jev) reports a 0.211 s median for 100 nested JSON rows sent in batches of 25, compared with 16.8 s one row at a time. A 2,049-row run took under a second. The author notes these timings come from one local run on synthetic data. Larger batches may cost accuracy, though: pg-jev's docs report that accuracy drops above roughly 20–25 rows per request, so test batch sizes on your own data.\n\n[Colliber's version](https://madewithjev.com/builds/duckdb-jev) uses Jev's typed output directly. Choice options are defined in advance, so the result can be a DuckDB `ENUM` rather than text that needs parsing. The prasanthj build can evaluate nested JSON, `STRUCT`, `LIST` and `ARRAY` values without exporting them to Python.\n\nSome replies under [Hamilton Ulmer's post](https://x.com/hamiltonulmer/status/2100370557405667768) point out that a fine-tuned ModernBERT is still cheaper once training is amortized, and that treating classification as embedding retrieval can reach about 20,000 rows per second on CPU. Jev makes most sense when you have no labeled data and a new question to ask. For a fixed classification task at high volume, a trained model may be cheaper and faster.\n\n## \n[Conclusion](#conclusion)\n\nJev returns a `BOOLEAN`, an `ENUM` or an ordinal score, and DuckDB can filter, group and sort on all three. With these extensions, you can write a condition in English and use it alongside joins, `GROUP BY` and window functions.\n\nJev is in early access behind a waitlist, the extensions are days old and unsigned, and most performance numbers come from their own authors. Start on a small, non-sensitive sample, watch your usage counters and compare against a baseline before you trust the labels. If you build something with Jev and DuckDB, the extension authors welcome issues and pull requests on their repositories.\n\n## \n[Further Reading](#further-reading)\n\n- [Introducing System One Models & Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) (TypeSafe AI's launch post)\n- [TypeSafe launched Jev because sequential LLMs are “totally useless for computers”](https://thenewstack.io/typesafe-jev-system-one/) (The New Stack)\n- [What Is Jev? A Guide to TypeSafe AI's System One Model](https://www.langchain.com/blog/building-a-harness-with-jev) (LangChain blog)\n- [Jev: TypeSafe AI's First System One Decision Model](https://www.hyperstack.cloud/technical-resources/tutorials/jev-inside-typesafe-ais-first-system-one-decision-model) (Hyperstack)\n- [I Tested Jev with DuckDB. It's 1.8x Faster Than Haiku.](https://www.youtube.com/watch?v=31VCA2Zlkc8) (YouTube)\n- [Calling Jev from SQL](https://www.youtube.com/watch?v=rwNrCHS3BM8) (YouTube)\n- [pg-jev launch post](https://x.com/iam_zachi/status/2100679300756435135) and[live demo](https://pgjev.zachi.dev/) (Zachi)\n- [Hamilton Ulmer's DuckDB extension post](https://x.com/hamiltonulmer/status/2100370557405667768) (X)", "url": "https://wpnews.pro/news/jev-and-duckdb-plain-english-conditions-in-sql", "canonical_source": "https://duckdb.org/2026/09/29/jev.html", "published_at": "2026-09-29 00:00:00+00:00", "updated_at": "2026-09-29 10:48:58.413407+00:00", "lang": "en", "topics": ["artificial-intelligence", "ai-products", "ai-tools", "developer-tools", "ai-agents"], "entities": ["TypeSafe AI", "Jev", "DuckDB", "Diogo Almeida", "Hamilton Ulmer", "Zachi", "pg-jev", "Actian"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/jev-and-duckdb-plain-english-conditions-in-sql", "markdown": "https://wpnews.pro/news/jev-and-duckdb-plain-english-conditions-in-sql.md", "text": "https://wpnews.pro/news/jev-and-duckdb-plain-english-conditions-in-sql.txt", "jsonld": "https://wpnews.pro/news/jev-and-duckdb-plain-english-conditions-in-sql.jsonld"}}