# Implementing Jev AI in 25 Lines of Python

A minimalist approach to running Jev-style LLM decisions locally

- **Source:** [Hacker News](https://news.ycombinator.com)
- **Published:** 2026-09-23
- **Topic:** [Data & AI](https://brifing.si/c/data-ai)
- **Original article:** <https://www.nobodywho.ai/posts/jev-in-25-lines/>
- **On Brifing:** https://brifing.si/s/d85a091a-4051-494f-bdda-2f9996bac76f

## Jev's minimalist approach

The implementation demonstrates how to run Jev-style decision making with just 25 lines of Python code. It uses a GGUF format model from Hugging Face, specifically Qwen3-0.6B, showing how compact such implementations can be. The example focuses on email classification (Legitimate/Spam/Phishing) while keeping all processing local. This contrasts with cloud-based LLM services that require sending data externally.

## Technical components

The script requires only three Python packages: huggingface-hub for model access, llama-cpp-python for local LLM execution, and numpy for probability calculations. It loads a pre-trained model with specific parameters like 512 token context window. The implementation shows how to tokenize inputs, process them through the model, and extract logits - the raw outputs before final decision probabilities.

## Prompt engineering example

The code demonstrates simple but effective prompt construction for classification tasks. It formats the email content and options clearly, using special tokens like |im_start| to structure the conversation. The system message instructs the model to 'Choose one option', while the user provides the email content and choices. This shows how even basic prompting can yield useful results with local models.

## Probability calculation

After model evaluation, the implementation shows three ways to interpret the outputs: raw logits, log probabilities, and final probabilities. For the example email about password requests, the model assigns highest probability (88.5%) to 'Phishing', demonstrating practical application. The numpy-based calculations illustrate how to convert model outputs into actionable decisions while maintaining transparency.

## Privacy advantages

The implementation emphasizes keeping all processing local, contrasting with cloud-based AI services that require data transmission. By using GGUF models and running everything in Python, it shows how to maintain data privacy while still benefiting from LLM capabilities. This approach aligns with growing concerns about AI data security and regulatory compliance in sensitive applications.

## Model selection flexibility

While using Qwen3-0.6B as an example, the code notes that any GGUF model from Hugging Face could be substituted. This demonstrates the approach's adaptability across different model sizes and capabilities. The implementation remains consistent whether using smaller models for efficiency or larger ones for accuracy, provided they support the GGUF format and required tokenization.

## Practical limitations

The example acknowledges tradeoffs in this minimalist approach. The 512-token context window limits input size compared to cloud offerings. The Q8 quantization (8-bit) balances size and accuracy but may sacrifice some precision. These constraints reflect practical considerations when deploying local LLMs versus using API-based services with greater resources.

## Open-source ecosystem

The implementation connects to broader open-source AI efforts, referencing alternative Jev implementations like OpenJev and openjev-sglang. It highlights how such projects build on each other, with this example serving as an educational entry point. The emphasis on GitHub stars reflects how community support sustains open-source AI development beyond corporate funding.

## Sources covering this story

- https://www.nobodywho.ai/posts/jev-in-25-lines/ — 

---

_Summary written by Brifing from the original reporting. Copyright in the original article belongs to its publisher; read the full piece at the link above._