C_W

◄ Notes04 / 05

Jev, tiny models and strange new interfaces

Small, fast models that pick one option from a fixed set don’t chat. They decide, and that invites interfaces that don’t look like chat at all.

Topic
Experiments
Reading
2 min

Most of what people call AI today looks like a conversation. You type, it types back. That shape made sense for the first generation of large models, but it isn’t the only one, and it may not be the most useful.

A different kind of model

Jev, from TypeSafe, is a good example of another shape. Instead of writing free text, you give it structured state and a fixed set of options, and it returns one choice with a confidence attached. No prose, no conversation. A decision.

That sounds like a limitation. In practice it’s the point. A model that can only choose from valid options can’t hallucinate an invalid one. Its answer is typed, so the software around it can trust the format and act on it immediately.

Diagram
flowchart TB
  S["Structured state"] --> J(("Jev"))
  O["A fixed set of options"] --> J
  J --> C["One choice<br/>with a confidence"]:::lit
  C --> X["The software acts on it"]

Why small matters

When a model only has to decide, it can be small and fast. That changes what you can build with it:

  • Decisions in a loop. Many small choices per second instead of one long answer.
  • Cost you can ignore. Cheap enough to call for every step, not just the important ones.
  • Predictable behaviour. The set of possible outputs is known in advance, which makes it testable.

It’s closer to a game engine’s logic than to a chatbot, and that’s where it gets interesting.

Interfaces without chat

If the model decides instead of talks, the interface doesn’t need a text box. It can be a character moving through a world, a system choosing its next step, an old piece of software driven by something that has never seen a keyboard.

Those experiments look strange next to today’s assistants, and that’s why I like them. Every new kind of model has made new interfaces possible, and the first ones always look like toys.

Two to try

I built two of those strange interfaces on this site, as experiments.

  • Chess with Jev. Code works out every legal move’s facts: exchanges, mates, threats. Jev picks one move from that list each turn and shows how sure it is. Play it, or watch it play itself.
  • 1 Million Emojis. A shared canvas of a million emoji cells, live for everyone. After each stroke you paint, Jev chooses a square next to it and what goes there.

Open questions

  • Which everyday software is really a long series of small, typed decisions?
  • How do you show someone what a decision-making model is doing, without a transcript to read?
  • When does a choice from a fixed set stop being enough?