Jev is everywhere right now. Every timeline I opened last week had it. Half the posts were demos, half were dunking on the hype. And somewhere in the noise, Pi users were quietly building the most useful stuff I've seen.
Pi is the minimalist coding agent. Badlogic's open-source one. It doesn't try to be Claude Code. It stays out of your way. That makes it a weirdly good host for a model like Jev.
Here's what actually works, based on what people are shipping in the wild.
Jev is not an LLM #
Start there. If you treat it like a tiny Claude, you'll be disappointed.
Jev is TypeSafe's "System One" model. You give it state, a fixed set of choices, and it returns one answer you can branch on. Choice, noul, score. That's it. It can't write a paragraph. It can't invent a function name. It decides.
Latency sits around 150 to 250 milliseconds. Cost is almost nothing. That combination is what makes it interesting for agents.
The pitch from Diogo Almeida is simple: stop paying frontier models to answer yes or no.
Start with the guard, not the brain #
The most useful Pi integration I found is also the least glamorous.
It's a tool-call guard.
Pi tries to run a shell command. Before it runs, something asks Jev a few typed questions. Is this irreversible? Does it match what the agent just said it was doing? Will the effect leave the working tree?
pi-warden does exactly this. It's a second pair of eyes that talks to the agent, not to you. Reads the prompt, the agent's last words, and the call it's about to make. Answers in a quarter second.
specpi-jev-guard takes the same idea and puts it in front of bash, powershell, write, and edit. Local rules block the obvious stuff instantly. Jev handles the messy middle where the command looks fine but the intent drifted.
This is the pattern that should ship first.
Why? Because the worst failure mode of an agent in your terminal isn't a bad refactor. It's an rm you didn't mean, or a curl | shell you trusted. Jev's strength is exactly a bounded yes/no under time pressure.
And when Jev is slow or down, the system still works. Local rules still fire. That's the difference between a useful guard and a fragile one.
Then route the money #
Once the guard is stable, add the model router.
Someone built one for Pi. Jev reads the task, picks which model handles the next turn, and sets thinking effort. Routine work goes to the cheap model. Hard problems get the expensive one. You can pin a model when you disagree with the router.
This is where the cost argument stops being theory. If your agent spends most turns doing boring classification and file edits, you don't need the big model for those turns.
A confidence gate that routes tasks to the cheapest capable model is the same idea at harness scale. Grist is building this on OpenCode v2. Pi users are doing it as extensions. Same shape.
Don't hard-wire Jev #
This is the lesson that actually aged well.
A couple of weeks ago, pi-system-one shipped. It gives Pi a single system_one tool for bounded decisions. Choice, noul, score. Built on a provider-neutral SDK.
The author originally hard-wired Jev. Then people pointed at Laya, von, Reflex. Once multiple providers showed up, binding to one name stopped making sense.
OpenAI's Decisions API landed about two weeks after Jev's launch. Same idea, fenced into an existing model instead of trained from scratch. The moat isn't the model. It's the integration layer and the evals people trust.
So expose one tool. Swap the backend. Keep the interface boring.
What not to do #
A few things that keep biting people.
Don't use Jev as the main reasoner. It can't generate text. Asking it to write a migration is a category error.
Don't put the guard inside the agent. The fence can't live inside the agent. If the model can rewrite its own permission layer, you don't have a permission layer.
Don't send raw secrets to Jev for ranking. One of the search-rerank projects redacts common secrets before sending the task and candidate passages. That should be the default.
Don't chase every use case. Terminal log collapse is nice. Semantic search reranking is nice. Instant context compaction is nice. None of those matter if the agent can still brick your machine on a bad command.
The stack that makes sense #
If I were wiring this into Pi tomorrow, I'd do it in this order.
- A thin pre-exec hook on bash and edit. Local rules first. Jev second. Typed questions only.
- A provider-neutral
system_onetool. One interface. Multiple backends. - Model routing with an easy pin.
- Optional pre-filters for logs, search hits, and compaction. Select, don't summarize.
Progressive disclosure matters here. Load only what the task needs. A guard that eats your context window to protect your context window isn't helping.
Bottom line #
Jev isn't magic. It's a very fast classifier with a good product shape for agents.
The people getting value from it in Pi aren't replacing the agent. They're putting a cheap decision layer in front of the expensive one. Guard the actions. Route the money. Keep the backend swappable.
The rest is demos.