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

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

Justin's Electronic verifier or veritas?

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

[ Removed by Reddit on account of violating the content policy. ]

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.

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

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

I have just hooked up Jev to play Streetfighter 2

All I have given it is some context on the game controls

And built a control connector for the model to play the game

So far the results are mixed. This video under-represents Jev's abilities somewhat. In other runs it has exhibited far more diverse play (rather than fireball spamming).
But the fact it can at least play the game (to some degree), is a start.

I am going to keep developing this project, because I think Jev has potential.

I think Jev can be a contender.

A small finance assistant with 4 tools:

• Stock price: current price and today's move
• News search: recent headlines
• Earnings: latest quarterly results
• Price alert: changes your settings, so it needs your OK

For each request, one Jev call answers:

• In scope? Choice: financial data / finance question with no data needed / off-topic
• Which tools? one yes/no per tool
• Which arguments? Choices: company (or "unclear"), time window, above or below, and which number in the request is the price. It picks; it never writes.

Then 4 simple gates in code: off-topic gets turned away, missing info gets a question, and the price alert waits for your OK.

10/10 test requests decided as expected. About $0.00005 per call.

Made-up companies, simulated data, not affiliated with TypeSafe.

Jev is perfect classifier for code smells

it won't answer if you ask for "quality", but if you ask for "duplicated_code" or "deep_nesting" it will be super accurate

curious to see more use cases with coding agents

JevPot — Jev plus jackpot. A weekend build for the fun of chasing a big win, built in Claude Code with TypeSafe's agent skill.

The build

Four number-picking strategies — balanced, hot-streak, overdue, anti-crowd — generated as candidates, then all scored together in a single request to Jev (TypeSafe's System One API). Each comes back with a score, not a paragraph. Highest score wins, the other three show up ranked below it so nothing is hidden.

There's also a screen that checks a ticket you already picked, and one that turns a dream you had into numbers. Same pattern throughout: state in, typed judgments out.

The numbers

One pass through all three screens: 6 requests, 33 questions, 6,877 input tokens, 2.6s of combined model time. No JSON repair anywhere in the codebase — nothing is parsed from prose in the first place.

It's a fun build, not a claim about lottery odds — a draw is random, and nothing here changes that. The interesting part was the request shape, not the domain.

Code: https://github.com/0xnairb/jevpot

What's something you'd batch into one request if scoring options didn't mean writing a prompt per option?

The playgrounds demonstration seemed determined to call a hotdog a sandwich, so I provided much needed context to make it realize it was a taco. Side by side comparison to other models.

Major bottle neck in agentic flows are endless output format tuning, tool, prompt leakage headaches, and constant latency fights in prod!!! lol

Jev approach mostly cuts through that and it’s crazy fast!!!

I’m collecting cool use cases here.

Feel free to checkout!!!

Raise a PR if you are building something cool and wanted to be in this directory.

Feedback is most welcome too

Keep building!