# I made an LLM using 521 Jev models

> Source: <https://jevs.chat/>
> Published: 2026-09-21 13:29:15+00:00

# What’s on your mind today?

## There is no language model in here

Every word on this site is chosen by a network of small, bounded decisions. Nothing in the system can generate text.

Jev is a decision model. You hand it some state and a set of questions, and it answers all of them at once with calibrated probabilities. It has exactly three kinds of question, and a reply is assembled out of nothing else:

#### Choice

Pick one of up to 255 labelled options. Returns a probability for every one.```
"cat" 0.31
"dog" 0.18
"the" 0.07
```
#### Score

Place something on a scale you define, two to ten levels.```
how long should
the reply be?
→ 1.0 of 2
```
#### Noul

One statement, one probability that it holds.```
"'cat' keeps this
grammatical"
→ 0.88
```
A word is produced by sampling from a Choice over candidate words. Everything else in the architecture exists to make that one Choice a good one.

## What happens when it writes one word

Each box is a batch of questions sent in a single request, so a
          253-unit step is still only three to six round trips. The documented
          saving for batching rather than asking one at a time is about
          **12× cheaper and 10× faster**.

Only the decoder picks a word. Everything upstream is deciding
          *what kind of word* should go there, and what the reply already
          means.

## The versions

Each one is the same engine with more units, more state and more second-guessing. Nothing is trained — Jev is frozen. What changes between V0 and V5 is only the architecture around it. Every diagram below is live: the dots are the actual units that version runs, firing in the order it really fires them.

## The word limit, and what it costs

The **max words** control next to the version picker is a ceiling,
          not a target. It is the point at which generation is cut off; the reply
          usually ends before reaching it, in one of two ways:

#### The decoder stops

Every candidate list includes an`<end>`
            option. When that wins, the reply is finished — the network
            decided it was done, nothing told it to stop.
#### The plan asks for less

From V1 up, a Score unit decides at the start whether this deserves a short phrase, one sentence or two. Whichever is smaller — your ceiling or its answer — wins.
It matters because **a word is not a token,
          it is a whole round of the network**. Every word costs two to six
          requests and anywhere from ten to several hundred answered questions,
          depending on the version. Eight words on V2 is about twenty requests;
          eight words on V5 also writes three complete drafts, judges them and
          repairs the winner. The first word is always produced, so no setting
          can give you an empty reply.

## How a word is actually chosen

The decoder gets 255 slots and fills them in priority order:

#### 1 · what fits

Words matching the role and inflection the syntax units settled on.
#### 2 · what was said

Words copied from your message and the reply so far. With a small vocabulary this is most of what keeps an answer on topic.
#### 3 · everything else

Frequent words, filling whatever budget is left, so a wrong guess upstream is still recoverable.
#### 4 · `<end>`

So the decoder
            can decide the reply is finished instead of being told.
Each option is described by naming it —
          *"The next English word is 'cat' (noun, singular)"*. Describing
          them by part of speech instead makes every noun in the list read
          identically, and the decision becomes impossible.

## Measuring it

Forty forced-choice tasks in five categories — grammar, agreement, memory, reasoning and long-range dependency. Each runs the full stack over a passage and then restricts the decoder to the listed options, so every version is scored the same way.

The sharp one is long-range: *"The keys on the table in the kitchen
          ___ mine"* punishes any network that agrees with the nearest noun
          instead of the head noun. Run it from a terminal:

```
python -m chatjevs bench --arch v2
python -m chatjevs compare --archs v0,v1,v2,v3 --limit 2
```
## Who made this

ChatJEVs is an independent experiment by **Alex**, built on TypeSafe's
          Jev decision API. It is not affiliated with, endorsed by, or produced by
          OpenAI or TypeSafe. The source is public — the engine, the unit
          tables and the benchmark are all a few hundred lines of Python.