Syllabus — Jev by TypeSafe AI: System One Models & Open-Source Alternatives

This is a practitioner course on System One models. These are fast, calibrated decision models. You give one unstructured state plus a set of typed questions, and it returns typed, probabilistic answers that your code can use directly, without parsing generated text. The spine of the course is TypeSafe AI's Jev, which launched in early access on 2026-09-15. TypeSafe describes it as "unstructured state in, typed probabilistic decisions out", and its documentation defines three question primitives: Choice, Score and Noul. Within days the open-source community had answers. Laya, from Convai Innovations, is a 421M-parameter ModernBERT-large decision model under Apache-2.0, released 2026-09-19. Von is an Apache-2.0 server that describes itself as fully compatible with TypeSafe's /v1/systemone specification. We also study the vendor's own thesis, from CEO Diogo Almeida's Latent Space interview on 2026-09-21. A warning up front: this topic is less than two weeks old. Every speed, cost and calibration number in this course, from TypeSafe and from the open-source projects alike, is vendor-reported and not independently replicated. We treat those numbers as claims to test, not facts to memorise.

What you'll be able to do

By the end of the course you should be able to:

• Explain what separates a System One model from a chat or reasoning LLM. It evaluates questions in parallel and in isolation against one state and returns typed values with probabilities (Jev docs). You should also be able to say why calibration, meaning probabilities you can trust, is the property that matters most.
• Call Jev's POST /v1/systemone endpoint with curl, Python and JavaScript, and design a state plus a set of atomic Choice / Score / Noul questions that your code composes.
• Route on confidence. Act automatically when the model is confident, and escalate to a human or a bigger model when it isn't.
• Critically assess the CEO's "Prod, not God" argument (Latent Space): which parts are supported, and where it pulls against itself.
• Run Laya locally and point a client at a self-hosted Von server, then compare both with the hosted API.
• Choose between Jev, Laya, Von and a general LLM with structured outputs for a given workload, using accuracy, calibration (ECE), latency and cost.
• Ship a pipeline whose backend can be swapped (the capstone).

Prerequisites

This course assumes you have shipped at least one LLM feature (classification, routing or extraction are ideal) and can read and write basic Python and JavaScript. You do not need to have trained a model.

Recommended background from other public LearnOS courses. Each one is listed on Discover. Review a lesson first if the idea is new to you:

• AI Engineering → "Capabilities, Limits, and Scaling", section Weak calibration — confidence is not correctness. It covers why an LLM's stated confidence can't be taken at face value, which is the problem System One models claim to solve (Module 01).
• AI Engineering → "Structured Output" and "Tool Calling". They cover constrained decoding and function calling, the LLM-side baseline that Jev's typed answers are compared against (Modules 02 and 05).
• AI Engineering → "Agent Design Patterns", section Routing. Confidence-gated routing in Module 02 specialises this pattern.
• AI Engineering → "Evaluating LLMs and Agents". It covers task-specific eval sets and metrics, which you'll need for the capstone.
• AI Engineering → "The Tooling Landscape", section Guardrails, safety, and validation. It gives context for the guardrail and injection cookbooks in Module 02.
• RAG → "Reranking — cross-encoders & late interaction". It covers two-stage retrieval, which the re-ranking and RAG-passage cookbooks build on.

None of these are hard gates, and the course reintroduces each idea where it is used.

Some familiarity with basic probability (what a probability distribution is, and what "70% confident" should mean over many predictions) helps. Lesson 01 teaches the calibration maths from scratch.

The roadmap

There are five content modules after this orientation. Module 01 gives you the vocabulary. From there the course splits into two tracks: the hosted track (Jev in practice, then the CEO's thesis) and the open-source track. Both feed the final module, where you choose and ship.

Time commitment

Plan on about 5 hours in total across 10 lessons, including this one. Most content lessons take 25–35 minutes. The capstone takes longer, roughly an hour, because you build and evaluate it rather than read it. A comfortable pace is one module per sitting over a week. Modules 03 and 04 don't depend on each other, so you can take them in either order once Module 01 is done. Module 04 is the one to start with if you have no Jev early-access key yet.

API demos that need a key or network access are shown as static code. The runnable exercises (calibration, gating and cost calculators) are stdlib-only Python simulations that run in the browser, so you can do every hands-on exercise before you have a key.

How to study in LearnOS

Reading alone makes you feel you've learned more than you have. Retrieval builds retention. Roediger and Karpicke found that students who took recall tests retained substantially more on delayed tests than students who restudied the same material, even though the restudy group felt more confident (Roediger & Karpicke, 2006). The irony suits this course: the restudy group's confidence was badly calibrated. Use the LearnOS tools to build retrieval into your routine:

• Active recall first. Before you open a lesson's body, try to answer its ## Practice prompts from memory. Answer them again afterwards.
• Chat-with-lesson. Ask the lesson chat to quiz you, to argue the other side ("steelman using an LLM with structured outputs instead"), or to explain one section differently. Answers cite the section headings, so you can jump back to the source.
• Flashcards and spaced repetition. Turn key definitions (ECE, confidence vs probability, act/escalate) into flashcards and let the scheduler space your reviews.
• Notes. Record your own workload's numbers as you go: expected volume, latency budget and acceptable error rate. The decision guide in Module 05 asks for them.
• Module reviews. At the end of each module, use the review to see which ideas haven't stuck before you move on.
• Build the capstone. Start it early. Each module adds a piece.

The capstone

The final lesson has you build a swappable ticket-triage pipeline. Support tickets come in, and each is labelled with a category and a priority, or escalated.

• One interface, several backends. The same application code runs against the hosted Jev API and against a local backend: Laya in-process, or a Von server exposing the /v1/systemone protocol (Von README). Swapping backends changes configuration, not code.
• A labelled eval set. You assemble a small set of labelled tickets and keep it fixed across backends so the comparison is fair.
• Accuracy and ECE side by side. For each backend you report accuracy and expected calibration error. You then compare your measurements against the vendor-reported figures and note where they disagree.
• Confidence-gated escalation. Tickets below a confidence threshold go to a human queue. You pick the threshold from your eval data and report how much automation it buys at what error rate.

The deliverable is the code plus a one-page write-up recommending a backend for your workload.

What this course omits

To keep the course to about five hours, several adjacent topics are deliberately left out:

• Training your own System One model from scratch. We show Laya's fine-tuning entry point but not pre-training or the RL-against-scoring-rules recipe in depth.
• Deep ModernBERT internals. We treat the encoder backbone as a component, not a subject.
• System Two / reasoning models. They appear only as the contrast case and the escalation target.
• TypeSafe pricing negotiation and enterprise terms. We use public per-call economics only. Contracts, SLAs and volume deals are out of scope.
• Other community reproductions. Projects beyond Laya and Von get a brief mention in Module 04 and are not covered in depth.

Sources

• TypeSafe AI — Introducing System One Models and Jev (2026-09-15)
• TypeSafe AI — Jev documentation: Introduction
• Convai Innovations — Laya model card (Hugging Face)
• AI Weekly — Convai ships Laya, a 421M ModernBERT decision model, Apache 2.0
• wfzyx — Von (GitHub)
• Latent Space — Jev: System One Models for Prod, not God (2026-09-21)
• Roediger, H. L. & Karpicke, J. D. (2006). Test-Enhanced Learning: Taking Memory Tests Improves Long-Term Retention. Psychological Science, 17(3).

Practice

1. Without scrolling up, name Jev's three question primitives, and say in one sentence what makes a System One model's output different from an LLM's text output.
2. Laya and Von both ship self-hosted /v1/systemone servers. Name one reason to pick each one, and one thing you would test before trusting either as a drop-in replacement for Jev.
3. Why does this course label every benchmark number as "vendor-reported"? Name one measurement your capstone will produce that lets you check such a claim yourself.