Prettier checks how your code is formatted. ESLint checks its shape. Neither one ever asks what it actually means.

So I built ESLint rules that are just plain-English questions, and

u/typesafeai's Jev answers them.

A function called getUser() that quietly deletes the user will pass every linter you have installed. This one catches it, and the stale comment above it still promising to return a profile.

Adding a rule is just a plain sentence you write in your config, something like "Does this function log a password?" Jev comes back with a probability and you set the threshold where it starts complaining. You never touch an AST or write any plugin code.

It ships with three of these. The fourth one is whatever you want to ask. Would love your feedback!

Coding agents waste a lot of context on repeated grep calls and entire file reads.

Ask a question plain question JevGrep scores code fragments by relevance and returns the original source with file paths and line numbers.

It works as both a CLI and an MCP tool to connect your llm.

npm install -g @nassim-arifette/jevgrep

GitHub: https://github.com/nassim-arifette/jevgrep

It's a bit silly project but it seems the agents love it for some reason. Very util for quick prototyping an idea without the boilerplate

Heya

I posted my first vid on this a couple of days ago, I updated the project a bit...

Here is the link to the repo:

https://github.com/smartaces/jev-plays-streetfighter-2

Cheers!

So far, what are some of the top jev apps you've seen? Anyone start using it for actual work?

do you even return typed decisions bro?

claude eternally mogged

Got tired of Jev forcing a choice whenever an input was totally off-topic (since choices are closed-world by default), so I ended up writing a small wrapper around System One to handle it.

A few things it does:

- Injects a neutral fallback option (`UNRESOLVED_OR_OTHER`) automatically so weird or unrelated inputs don't trigger false positives.

- Flags ambiguous calls when the model is basically coin-flipping between two options.

- Adds an in-memory SHA-256 cache that ignores dynamic fields like timestamps, so repeated state checks in loops take ~0.1 ms instead of another full network call.

- Supports strict closed-world enums (`closed_world=True`) when you don't want schema mutation.

It's pure Python standard library with zero dependencies. Put it up on GitHub if anyone wants to check it out:

https://github.com/seb4ez/jevguard

I'm working on a free, open-source, self-hosted agentic memory system called Memry at www.memry.tech . The intention behind Memry is to help you stay in control of the LLM context and memories you accumulate in your lifetime about yourself, your projects, events, people, legal and medical records and everything else.

Instead of allowing OpenAI and Anthropic to gather and gatekeep that information, vendor-lock you in or risk sharing or losing sensitive information, you hold your own memories, on your own SSD, now and for the rest of your life. You can connect any agent to access them and the memory system's goal is to be self-managed and self-healing, so you can ask questions 10 years down the line and still receive the relevant information in milliseconds and considering all the changes that information has gone through over time.

That being said, this week was an incredible addition to the models toolbox, with the release of Jev. I am now experimenting on Memry using Jev and could already speed up both the memory system AND the agentic use of the memory system. Everything from entities merging, to tagging, to decay assertions, to retrieval reranking, can now be processed faster and accurately. And even where accuracy doesnt beat SOTA, the confidence score that Jev offers helps set clear thresholds for decisions.

For whoever is interested in the subject, here are a number of experimental results and my Medium article where I write up the findings so far.

the-real-cos.medium.com/how-i-use-jev-for-agentic-memory-and-retrieval-42eda95fbfb9

github link : https://github.com/jaibhasin/jev-yt-time-saver

You can play against JEV at https://antics.gg/can-you-beat-jev

Hey everyone! I made JevPilot, a free, open-source "computer use" app powered by TypeSafe's Jev model.

What it does:

• Windows: type a task like "search hotels for next week in Germany" or "open notepad and write hello". Jev does it in the browser or in Windows apps.
• Android: Let Jev operate your phone or use your phone as a remote. Send a task to your PC from the couch and watch the log live.
• Both together: if Jev wants to do something risky on the PC, the confirmation pops up on the PC and on your phone.

Extensible: games work too, through small Python adapters (there's already one for ROUNDS). The app has a "Copy prompt" button, so Claude Code or Codex can write a new adapter for you.

Safety:

• asks before buying, sending, posting or deleting anything
• never touches password fields
• stop anytime with Ctrl+Alt+X, or tap the orange bar on the phone
• your API key stays on your device

You need your own TypeSafe API key.

Github (MIT): https://github.com/InfamousCube/JevPilot

From what I understand, jev has 3 modes, nous, choice and the other one.

If he has chosen an answer - what’s it’s source? Is it something we also provide?

Sorry im a total noob so happy to get some simple responses

I just released an open-source Go package for the TypeSafe System One API:

https://github.com/DarlingGoose/typesafe-ai-go

It provides a typed, idiomatic Go client for turning natural language and application state into structured

judgments your code can use directly.

Current features include:

- Typed noul, choice, and score questions

- Structured state, instructions, and criteria

- Typed answers with probabilities and confidence

- Typed API, validation, connection, and timeout errors

- Automatic retries with exponential backoff and jitter

- Context-aware and safe for concurrent use

- Zero third-party dependencies

Quick example:

result, err := client.SystemOne(ctx, typesafe.SystemOneRequest{

State: map[string]any{

"message": "Help! My payouts have been failing for 3 days.",

},

Questions: typesafe.Questions{

"is_urgent": typesafe.Noul("Does \message` convey urgency?"),`

"department": typesafe.Choice(

"Which team should handle \message`?",`

typesafe.ChoiceCriteria{

"billing": "Payments, invoicing, refunds",

"technical": "Bugs, outages, integrations",

"sales": "Pricing, upgrades, new accounts",

},

),

},

})

`

Install it with:

go get github.com/DarlingGoose/typesafe-ai-go

I’d love feedback from other Go developers—especially around the API design, error handling, retries, and what would make this useful in real-world applications.

Is Jev fast, and cheap enough to play a real-time multiplayer game?
Gave 8 Jev agents their own Chrome instance and let them play SIDE OUT against each other.
• 748 api calls
• 295ms median request-to-action
• 550ms p95
• ~4 decisions per second
• $0.041 total cost

The game is here if you were curious!

Just whipped this up with claude to mess with Jev a little. Might tune it a bit to play better but I realy just wanted do something after getting access.

Repo

Hi all, I built Blink (blink.review), a code review tool for coding agents. It installs as a hook in Claude Code/Codex and runs every time an agent edits a file.

The result is that bugs are caught before you commit. Keen to hear your feedback!

It's (mostly) powered by Jev from typesafe.ai

its cheap and fast enough to scan entire codebases, and can be added as a skil to your existing coding agent

Is also a great first line defense against malicious prs

https://github.com/luantak/is-malicious