I made an LLM using 521 Jev models

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.