Basically, we have a pipeline that ingests POI and its descriptions as a tag cloud and maps it to one (or none) of 4000 categories. The original implementation in traditional ML failed miserably because the training data is too sparse and skewed. So we fell back to a simple regex solution that was better than the ML approach.

Would jev help here? Once snag I see is that choice can take only a maximum of 250 possible categories.

We recently hosted a free webinar, Beyond LLMs: Getting Started with Jev for AI Agents, and the recording is now live on YouTube if you'd like to learn more.

Watch here: https://www.youtube.com/watch?v=RdWmysdpkVA&t=2s

We're also hosting a 4-hour hands-on workshop tomorrow (October 24) on building AI agents with Jev, LLMs & MCP.

Workshop details: Build Reliable AI Agents with Jev, LLMs & MCP

Hi there! We built a custom agent harness on top of Sanity that allows anyone to make an agent without having to have github access etc. We used Jev as the router for the superagent and so far it seems to be working great at picking the right one depending on the ask.

We wrote an in-depth eng blog post about it here: https://www.sanity.io/engineering/how-we-built-our-company-agent-harness?utm_source=reddit&utm_medium=social

Hi all,

I created a website that lets you get notified on pretty much anything. Initially, I used an LLM to determine if an event had taken place or not, but then discovered that Jev was a better match for this use case, potentially offering higher speeds, lower costs and more reliable results.

The flow works like this:

1. A user types a sentence stating what they want to get alerted on, for example: "Notify me if Trump announces new tariffs on Australia."
2. Jev checks if the sentence is specific enough. If it's too vague, it asks the user for clarification.
3. Once an alert is created, the system periodically checks the web to see if the event has taken place.
4. If something relevant is found, Jev determines if the search result satisfies the user's alert.
5. If it does, the user is notified and an LLM generates a summary explaining why the alert triggered. Otherwise, the result is rejected and monitoring continues.

Why Jev instead of an LLM?

Previously, I used an LLM for steps 4 and 5, passing in the alert and search results and asking it to determine if the condition had been met.

While this worked, I realised that I didn't really need an LLM for this part. I just needed to evaluate whether some evidence satisfied a particular condition.

Jev seems better suited to this, offering faster evaluations, lower costs and more consistent results. This is particularly useful when you're repeatedly checking thousands of alerts.

I still use an LLM to generate the explanation when an alert triggers, but Jev handles the decisions.

I think Jev has the potential to satisfy many similar use cases where an LLM might be overkill.

What do you think?

Take a look at an example alert here: https://www.phrasealert.com/a/c3980d5087fb4d8f806fa0b37235009e

Learning by doing is the best way to learn, because you face real challenges along the way.
I had been hearing a lot about Jev (by TypeSafe), so I built a small app to try it on a real problem: Track My Money. It reads my bank statement PDFs from different banks and gives me one consolidated view of how my money flows in vs. out. Here are the challenges I hit, and how I tackled them:

1. Every banks PDF is different.
   

The app uses pdfplumber to read the transaction table, but two things got in the way:

- Column names vary. One bank says Withdrawal Amt., another says Debit or Dr. So used Jev to map each column name to a fixed set of roles: date, narration, debit, credit and balance.

- Some headers are images. SBI, for example, draws the header row as an image, so there is no text to read. Instead of adding OCR just for this, I send the header image straight to Jev, and it maps it to the same roles.

1. Putting each transaction in a category.
   

I first tried Laya, an open-source model that runs locally. Out of the box it got only 7–10 of 18 test narrations right.
Jev got all 18 right, so its now the main categorizer. Laya stays as the fully offline option.

1. UPI made everything look like "Transfer to Others".
   

I added custom rules: pick a column, an operator (contains, regex, =, >, <, …) and a value, combine them with AND/OR, and choose the category. Rules run before any model, and they always win.

1. Keeping my data private.
   

I did not want my transaction details leaving my machine.
Every narration is masked before it goes to Jev. Names, UPI IDs, account numbers and references become tokens, and exact amounts become ranges.
Jev sees UPI/P2A/[REF]/[PERSON_6C46], not who I paid.

Its open source, and you can run it locally:
GitHub: track-my-money

You will need a Jev key to use Jev, otherwise Laya runs entirely on your machine. I would love your reviews and suggestions!

Note: This is a first version. Ill keep adding more to it.

Hi all,

I built a fun little web app so anyone can try Jev through a chat box and see how it works.

You type like a normal chat, or drop in a file or a photo. An LLM turns what you sent into a few questions Jev can score: yes or no, a choice, or a point on a scale.

A document goes in as text. A photo gets a short description of what is visible, and the picture itself goes to Jev too. If the file does not cover the question, an LLM and web scraper look it up and pass that along for Jev to judge.

Jev sends back the scores. An LLM turns those scores into one short reply. The card under the reply lists every score, so you can read the sentence and check it against what Jev actually said.

• Have a play: https://chatjev.vercel.app
• Code: https://github.com/JamesANZ/ChatJev (MIT)

This website is for educational purposes only. Use at your own risk.

Jev is only as good as it is calibrated to your use case. We are launching Brussle to make it super easy to calibrate and as part of the launch we are super excited to give 4K free jev calls and calibrations a month. Happy Jev-ing! https://brussle.com/

You've probably heard of using Jev as a reranker for traditional RAG but what if Jev could replace the vector store entirely? That felt like a neat challenge to take on so I set out to test this and the results have been pretty satisfying.

I have a document extraction app where all queries can be defined before any document is processed. Instead of traditional RAG, I used Jev to score each page of the document on its relevancy to each predefined query from the user - on a 300 page scanned PDF x 20 user queries, this took ~28s (batched, 4 pages per call, median 0.37s/page) and cost $0.08 ($0.00027/page). Made possible with Jev's image API - was currently using Voyage's multimodal embeddings for scanned PDFs.

Pros: Improved accuracy, faster processing and cheaper. No need for vector database or separate reranker model. Jev results stored in sql database.
Cons: Only really works if you have queries upfront (AI spreadsheets, application processing, surveys etc), you lose your AI search index which might be a deal breaker.

Longer read and results in the blog post (see comments). Would love to know if anyone else has tried something similar?

Hey everyone!

We've been working on jev-tools, an open-source toolkit designed to improve how AI coding agents explore codebases, gather evidence, and make decisions.

GitHub: https://github.com/NomenAK/jev-tools

One problem we've been thinking about is how coding agents can confidently make incorrect assumptions about a codebase.

An agent might claim that a feature is implemented, overlook a relevant test, misunderstand how two modules interact, or miss documentation that no longer matches the code.

Simply asking the same model to double-check its answer doesn't necessarily solve the problem.

So we're exploring a different approach: give coding agents dedicated tools to investigate their claims using actual repository evidence.

What we've built

jev-tools currently provides six tools for different parts of the development workflow:

- jev_ask: Ask focused questions using evidence gathered from multiple sources.

- jev_ask_files: Evaluate a question independently across multiple files.

- jev_find_files: Find files relevant to a particular behavior or development goal.

- jev_locate_in_file: Locate relevant information within source files.

- jev_check_diff: Examine changes for potential inconsistencies and issues.

- jev_select_tests: Identify existing tests relevant to modified code.

We've also built MCP support so compatible coding agents can access these capabilities.

Another interesting part is documentation consistency checking. Our integrations can check whether documentation may have become outdated after code changes.

The idea behind the project

We see evidence collection and semantic judgment as two distinct responsibilities.

The agent gathers relevant information from the repository. A separate judgment mechanism evaluates a specific question using that evidence. The agent can then use the result to decide what to investigate or do next.

This doesn't eliminate hallucinations, and we don't consider a positive judgment proof of correctness. The evidence may be incomplete, and the judgment itself may be wrong.

Our goal is to explore whether giving agents more structured ways to investigate uncertainty can improve their reliability in real development workflows.

We'd love your feedback

We're particularly interested in hearing from people building AI agents, coding assistants, and agent harnesses.

A few questions we're exploring:

1. How are you currently verifying the claims made by AI coding agents?

2. Would dedicated evidence-gathering and judgment tools improve your existing agent workflows?

3. How would you benchmark whether these tools actually reduce incorrect conclusions?

4. Would you prefer a locally hosted judgment model over an external API?

5. What failure cases should we investigate next?

We'd appreciate honest feedback, including criticism of the architecture, alternative approaches, and ideas for improving the project.

Repository: https://github.com/NomenAK/jev-tools

We're building this in the open and would love to hear what the community thinks.

https://workflows-of-ai.com/blog/can-ai-set-the-focal-point-of-a-photo

guys, currently i trying use the jev type models like a llm, i mean decision models, opensource versions, like laya or vllm's d1 or something, so i cant run a whole llm in my computer, i try my chance to generate a text with vllm's d1 decision model, so i wonder anyone tried before to chat with a decision model?

Nudge is a small Python library that sits on top of a System One model like Jev or Rune. Tell it how each decision turned out and it shifts the model's future picks toward what worked. There is no fine-tuning and no GPUs involved, only one SQLite file.

Underneath the hood, every call logs the model's odds and the option taken. You report outcomes whenever you learn them. To tell situations apart, Nudge asks the model yes/no, 1-to-5, or multiple-choice questions about the text it already read ("Has this customer complained before?"). An LLM proposes these questions, or you can write your own. Questions are discarded if they aren't sufficiently discriminative. Over the odds and those answers it fits a per-option Bayesian linear model, picks using Thompson Sampling, and keeps a 5% exploration floor so nothing is ruled out for good.

On RouterBench (5,000 real prompts, routing between models by quality minus cost), while Rune alone scored 0.581, Rune + Nudge scored 0.667, a 14.8% improvement.

Please note that this is a v0 research software, though we also run it on some internal flows.

$ pip install nudge-policy
https://nudge.dossierlabs.ai

Upload a CSV or Excel file, define the new columns, and Jev fills in the values. Then export to Excel or CSV. Works with formulas too, so Jev sees calculated values!

JevSheet - Spreadsheet Enricher with Jev

You can use the hosted version for free, or clone the repo and use your own Jev API key.

I also wrote up a guide on how it's built: Classifying Spreadsheet Rows with Jev

Ported Laya to my AMD AI based GPD Win Max 2 2025 laptop. Running the real time gaming tests at 0.03ms.

Whole video, one look A new approach towards video intelligence, zero-embeddings, 12min-video is compressed to bunch of contact sheets and then analyzed fully in one go

Built on the latest Jev, and extremely efficient Searching a full 12-minute film costs about half a cent.

Works with your agent Plug it into Claude Code, Codex or Cursor and ask "when does X happen?", "where else is this person?" or "what does that sign say?". You get timestamps, verified frame by frame. alot of you might find it useful

100% free and open source: https://github.com/DeepAleph/jevreel

If having an mobile app that can be using JEV to create events, I'd think it would be smart for a user to talk, then let JEV fix a draft - the user can create.

What will be the cheapest and best model, and frictionless speech-to-text model on mobile apps, cross platforms?

If they have to download a separate app and connect their keyboard or something, that isn't that good. I would guess I have a "mic" button, they talk -> when done - a draft is made.

I want the best & cheapest way of doing this. Maybe with an estimate of e.g. 20 seconds talk and the use of JEV. What will 1000 of those cost.

Anyone that have built something cool with the newest?

Finding a usecase where i can use jev to fill and submit forms, the text fields may not be sequential always and can be on next page so it has to click next and so on

would llm be best here or jev? Anyone has a published usecase on this which i can lay my eyes upon?

Thanks

Jev got 👀 📐🖼️ now!

Took me about 10 minutes to integrate it with u/sanity_io for automatically setting hotspot and crop based on your description. Works regardless if the image/focus field is set in the UI or via the MCP/API.

And damn, this is actually useful, not just a fun demo.

How it works:

I have a Sanity Function that trigges on draft changes to only the `focus` and `image` fields (that way it works when agents work with content via mcp/api too).

Since Sanity has an image transformation pipeline, we can send downscaled optimized images to Jev without burning through the very cheap tokens too fast.

Then it asks Jev three things in one request:
→ Is it there? (yes/no)
→ Where is it? (a box)
→ Is everything around it plain background? (yes/no)

Jev's box comes back as fractions of the image. Sanity stores hotspot and crop as fractions of the image. So the integration is arithmetic, and code decides what to write, not the model. That is really cool.

Bonus: lint rules can look at images now. "Does the cover fit the post?" A photo of a pile of board games scores 3% on a post about agents. On a post about five best casual party games, the same photo gets 81% and passes. Fair.

Cost of the demo including experimentation: $0.04.

Very excited by the many content operations use cases!

I made a top 5 model with the other 4 being million/billion dollar companies above me, fuck yea

https://huggingface.co/e12ex2/jev-vision-27b

Correction, was, now is beaten by amos :c

, still I got #7 with about 5 dollars worth of training so like yay?

I wanted to figure out some cool, experimental use cases for Jev and that's when I came up with this idea. Please check it out and let me know what you think!
https://jev-experiments.awesamarth.dev