simple-jev and jev-skill: The Lightweight End of the Ecosystem

Most of the projects covered so far in this series assume you're calling TypeSafe's hosted Jev. Three projects in this batch make a different assumption, or serve a narrower job entirely. simple-jev doesn't call TypeSafe at all — it turns your own model server into something that looks like Jev. jev-skill is less a tool than a curriculum, 60-plus demo projects and five installable agent skills built around Jev usage patterns. And jev-shell-history is the narrowest of the three: it just wants to guess your next terminal command.

They share a category — Development & Code Tools — and a low profile in stars relative to their usefulness, but they're solving genuinely different problems. Worth knowing which one you actually need before you install any of them.

Key Takeaways

• simple-jev is a from-scratch classifier, not a Jev client. It reads next-token logits off an open model (Hugging Face Transformers + PyTorch today) to fake Jev's typed-JSON output, with no separate classifier head to train.
• simple-jev has real, stated limits. Text-only, no streaming, serial request processing, and a 1,024-token-per-question cap on its Laya encoder backend.
• jev-skill is a scenario library, not a single tool. 60+ demo projects, five installable skills (jev, jev-triage, jev-documents, jev-eval, jev-act), and 108 documented scenarios, installed by handing a coding agent one setup prompt.
• jev-skill is explicit about simulation vs. real calls. Its "Mode B" uses the calling agent itself instead of Jev, and labels those runs agent_simulation with jev_called: false so you don't mistake a stand-in for a verified result.
• jev-shell-history has a measured latency cost. The author reports 0.7–0.9 seconds per keystroke-triggered API call — noticeable in an interactive shell, and the README says so.

simple-jev: making any model act like Jev

simple-jev (Apache-2.0, 491 stars as of September 2026 — comfortably the most-starred project in this article) is an adapter, not a Jev client. The idea: instead of sending a question to TypeSafe's hosted model, you point simple-jev at your own open-weight model server and it produces Jev-shaped output from that model's own token probabilities.

Mechanically, it works by building a shared prompt with one scoring branch per question, then reading the next-token logits for the allowed answer labels directly — rather than letting the model generate free text and parsing it afterward. When several questions share the same evidence, it evaluates the common token prefix once and reuses that prefix's KV cache across the batch of question suffixes, which is where the speed argument comes from. Today it supports Hugging Face Transformers on PyTorch as the primary backend, plus a specialized encoder backend called Laya Typed Decisions; there's no vLLM integration yet, despite that being a natural next step for anyone running this at scale.

The limitations are worth taking at face value rather than assuming they'll be worked around later: text-only (no images, audio or video), no completion sampling or streaming, KV cache reuse scoped to a single request rather than shared across requests, and serial rather than parallel model request processing. Laya's default cap is 1,024 tokens per question. Install with Python 3.12+ via git clone and pip install -e './hf-server'. If your interest in Jev is "I want the typed-decision pattern but I don't want to send data to TypeSafe," this is the project to evaluate first — see /skills/simple-jev-featherless-ai.

jev-skill: a scenario library, not a tool

jev-skill (MIT, 455 stars) is structured differently from almost everything else in this series. Rather than one integration, it's a collection: 60+ example projects (browser automation, a Tetris demo, music composition, a code-review dashboard, social-media interactions), five installable agent skills, and 108 documented scenarios, plus a "stdlib-only" Python decision wrapper for teams that don't want a dependency on the official SDK covered in TypeSafe's official JS and Python SDKs.

The five skills are narrow and named for what they do: jev (design questions, run batch semantic decisions), jev-triage (sort and label records in bulk), jev-documents (find evidence, verify claims in sources), jev-eval (check outputs against rubrics), and jev-act (choose from a constrained set of legal actions). Installation is unusual too — you give a coding agent (Codex, Claude Code, OpenCode) a single natural-language prompt pointing at the docs, and the agent handles environment checks and key setup itself, with either OpenRouter or TypeSafe's own API as the provider.

What sets this project apart is candor about what's actually been verified. Its "Mode B" runs use the calling agent to simulate a Jev call rather than making a real one, and every such run is labeled agent_simulation with jev_called: false — an explicit guard against mistaking a stand-in for a verified result. The README also flags that repeated judging isn't the same as validating correctness (agreement between runs proves stability, not accuracy) and that batches larger than roughly 20 rows showed quality drops in one internal study — a real number, but from a single source study, not a controlled benchmark. On aiskill.market: /skills/jev-skill-wuyoscar.

jev-shell-history: the narrowest use case in the ecosystem

jev-shell-history (107 stars, no stated license in the dataset) does one thing: Fish-shell-style command autosuggestion for zsh, powered by Jev instead of static prefix matching. As you type, it sends your last 100 distinct commands plus your current input to Jev, which judges two things — which command you're likely completing, and whether any candidate actually completes what you've typed — across separate prefix and fuzzy matching modes with gating logic to avoid noisy suggestions. Accept a suggestion with the right arrow or End key, same as Fish's native behavior.

The tradeoff is latency: the author reports 0.7–0.9 seconds per request, which is slow for something firing on keystrokes. In-flight requests are discarded if the buffer changes before they return, so a lag doesn't block your prompt — but it does mean the suggestion can visibly lag behind fast typists. Requirements are zsh 5.9+, Node 22+, and a TypeSafe API key; install by cloning to ~/.zsh/jev-shell-history, running npm install, and sourcing it after exporting your key. This is a genuinely small, personal tool — treat the 107 stars as curiosity, not adoption at scale. On aiskill.market: /skills/jev-shell-history-mrnugget.

What to do next

1. If you can't or won't send data to TypeSafe's hosted API, start with simple-jev and its stated backend and token limits — know before you deploy that it's text-only and serial.
2. If you're learning what Jev-shaped workflows look like in practice, jev-skill's scenarios are a faster way in than writing your own from scratch — but read the agent_simulation labels before trusting any given demo's numbers.
3. If you just want a nicer terminal, jev-shell-history is a fun, low-stakes install — accept the latency cost or skip it.
4. Check licenses before you ship anything on top of these. simple-jev is Apache-2.0, jev-skill is MIT, and jev-shell-history's license isn't stated in our data — confirm directly on GitHub before redistributing.
5. See the rest of the field at the Awesome Jev projects radar, and read how to evaluate Jev projects honestly before taking any project's claims — including these three's — at face value.