This page was machine-translated from Portuguese and may contain mistakes. Read the original
Hi, everyone!
I’m going to teach a Jev course in a few weeks, and I thought it would be nice for us to have some foundational material to start with. I decided to write this article as the conceptual part of the course. We’ll start with this, and as I always say in my training sessions: the foundation of all learning is the system’s official documentation.
Today, with artificial intelligence, we can use it to our advantage and create learning formats that are more effective for our individual learning styles. In other words, if I learn better through audio, I’ll probably listen to an audiobook instead of reading a book. If I learn better through visuals, I’ll probably create a mind map of a book, which will help me understand it better than if I just listened to the audiobook.
So, use all these AI tools, but make sure you’re using the official documentation.
To kick off this article and the lesson, we’ll open the TypeSafe website—the company that developed the first System One, a model called Jev.
On the company’s homepage, we’ll see some very interesting information, including performance and cost comparisons.
We’ll then move on to the page with information about Jev’s launch, which provides some additional details about the model.
https://typesafe.ai/blog/introducing-system-one-models-and-jev
As we can see on this page, there’s more information about Jev, including a link to the official documentation—important: we’re using version 1.13.0 in this article.
https://docs.typesafe.ai/introduction (v1.13.0)
Great! Based on these sites, here’s what we have:
The mental model: Kahneman’s two systems
TypeSafe called Jev a “System One” model for a reason. Opus and Astra are both System Two.
Daniel Kahneman’s book *Thinking, Fast and Slow* describes two cognitive systems:
System One: Fast, automatic, intuitive. Recognizes a face, selects a ball, classifies a shape. No deliberation—just high-speed pattern recognition. This is Jev.
System Two: Slow, deliberate, analytical. Solves a math problem, writes an essay, reasons through a complex scenario. Powerful, but costly. These are Opus & Astra.
Architecture at a Glance v1.13.0
Different training, different sampling, different output contracts.
Jev System One
Claude Opus 5.5 LLM
GPT-6 Astra LLM
RLCD vs. RLHF: How Each Learns
The way the model is trained defines how it behaves. Jev and LLMs learn in completely different ways.
RLCD
Trained to make the right decisions and know when it’s uncertain. In many predictions, outcomes with a probability of 0.8 should occur about 80% of the time. This describes the group, not a single response. “confidence” is a dispersion score, not that probability.
The reward during training comes from making the right decision, not from “sounding right” to a human.
Your code uses these probabilities to decide when to trust the answer and when to escalate to a human.
RLHF Opus 5.5 & Astra
Trained to provide responses that humans consider good. During training, humans evaluate various responses and choose the best one. The model learns to generate text that “sounds” useful, correct, and reliable.
Example: If you ask “classify this ticket,” the LLM might respond, “Based on an analysis of the content, I would classify it as high priority because…”—great for humans to read, but your code needs to parse that string to extract the value “high.”
Result: incredible reasoning, fluent writing, natural conversation—but the output is always text that needs to be interpreted.
Jev’s three primitives (v1.13.0)
Instead of a prompt→text API, Jev exposes atomic and composable operations. All of them run in parallel. Important: there’s one more type, but we won’t consider it in this article since it’s an advanced model.
- Classifying a bug: critical / high / medium / low
- Route a PR to the right team: frontend / backend / infrastructure / docs
- Categorizing a failed test: flaky / actual bug / environment
- Detect error type in a log: timeout / auth / validation / network
score is the expected value, not the level index.- Score the quality of a PR description (0–4)
- Assess the severity of a security alert
- Measuring the semantic coverage of a test case
- Ranking the relevance of log search results
- Does this commit introduce a breaking change?
- Is this error message user-friendly?
- Does this test cover the scenario described in the ticket?
- Does this log contain sensitive data (PII)?
Same task, three paradigms
Three common tasks using Jev’s three primitives. See how each model handles them.
English is Jev’s primary training language, and where accuracy is best. Other languages work, but not quite as well. Test them on your content before relying on them. The instructions for the examples are in English.
Choice: Classify test failure
import { TypeSafeClient } from '@typesafe-ai/sdk'; const client = new TypeSafeClient(); const result = await client.systemOne({ model: 'jev-latest', state: { test: failure.test, error: failure.error, history: failure.history }, questions: { category: { type: 'choice', instructions: 'Root cause?', criteria: { product_bug: 'A real bug in product code', test_bug: 'Bug in the test itself', environment: 'Infra or env issue', flaky: 'Non-deterministic pass/fail' } } } }); // result.answers.category.choice → "flaky" // result.answers.category.confidence → 0.65 // result.answers.category.probabilities // → { flaky: 0.74, test_bug: 0.12, // environment: 0.11, // product_bug: 0.03 } // ~150ms
const res = await anthropic .messages.create({ model: "claude-opus-5-5", max_tokens: 256, messages: [{ role: "user", content: `Classify this test failure. Test: ${failure.test} Error: ${failure.error} History: ${failure.history} Reply: product_bug, test_bug, environment, or flaky` }] }); // res.content[0].text: // "Based on the intermittent pass/ // fail pattern (PFPPFP), this is // likely **flaky**. The timeout in // the error suggests a race // condition in the async setup." // Sem probabilidades. Precisa de parsing. // ~4s
const res = await openai .chat.completions.create({ model: "gpt-6-astra", max_completion_tokens: 256, response_format: { type: "json_object" }, messages: [{ role: "user", content: `Classify this test failure. Test: ${failure.test} Error: ${failure.error} History: ${failure.history} Options: product_bug, test_bug, environment, or flaky JSON: { "category": "..." }` }] }); // res.choices[0].message.content: // '{ "category": "flaky", // "reasoning": "The PFPPFP // pattern indicates..." }' // Estruturado, mas sem // probabilidades calibradas. // ~3s
Score: Impact on the release
import { TypeSafeClient } from '@typesafe-ai/sdk'; const client = new TypeSafeClient(); const result = await client.systemOne({ model: 'jev-latest', state: { test: failure.test, error: failure.error, history: failure.history }, questions: { releaseImpact: { type: 'score', instructions: 'Release impact?', criteria: [ 'No user impact', 'Minor, easy workaround', 'Feature degraded', 'Critical journey broken' ] } } }); // result.answers.releaseImpact.score // → 2.86 (valor esperado, 0-3) // result.answers.releaseImpact.confidence // → 0.84 // ~120ms
const res = await anthropic .messages.create({ model: "claude-opus-5-5", max_tokens: 256, messages: [{ role: "user", content: `Rate the release impact of this failure 0-3. 0=No user impact 1=Minor, easy workaround 2=Feature degraded 3=Critical journey broken Test: ${failure.test} Error: ${failure.error} Reply with just the number.` }] }); // res.content[0].text: // "I'd rate this a 3 - the checkout // flow is a critical user journey // and the failure blocks payment // processing entirely." // Sem confidence. Precisa de parsing. // ~5s
const res = await openai .chat.completions.create({ model: "gpt-6-astra", max_completion_tokens: 256, response_format: { type: "json_object" }, messages: [{ role: "user", content: `Rate the release impact of this failure 0-3. 0=No user impact 1=Minor, easy workaround 2=Feature degraded 3=Critical journey broken Test: ${failure.test} Error: ${failure.error} JSON: { "score": N }` }] }); // res.choices[0].message.content: // '{ "score": 3, "rationale": // "Blocks checkout flow" }' // Estruturado, mas sem // confidence calibrado. // ~4s
Noul: Will the retry go through?
import { TypeSafeClient } from '@typesafe-ai/sdk'; const client = new TypeSafeClient(); const result = await client.systemOne({ model: 'jev-latest', state: { test: failure.test, error: failure.error, history: failure.history }, questions: { retryWillPass: { type: 'noul', instructions: 'Would re-running this test, with no code changes, most likely make it pass?' } } }); // result.answers.retryWillPass.noul → 0.91 // sem campo confidence separado // ~100ms const { noul } = result.answers.retryWillPass; if (noul > 0.7) autoRetry();
const res = await anthropic .messages.create({ model: "claude-opus-5-5", max_tokens: 256, messages: [{ role: "user", content: `Would re-running this test, with no code changes, most likely make it pass? YES or NO. Test: ${failure.test} Error: ${failure.error} History: ${failure.history}` }] }); // res.content[0].text: // "YES - Based on the intermittent // pass/fail pattern (PFPPFP), this // appears to be a flaky test. A // retry would very likely pass." // Sem probabilidade. Precisa de parsing. // ~4s
const res = await openai .chat.completions.create({ model: "gpt-6-astra", max_completion_tokens: 256, response_format: { type: "json_object" }, messages: [{ role: "user", content: `Would re-running this test, with no code changes, most likely make it pass? Test: ${failure.test} Error: ${failure.error} History: ${failure.history} JSON: { "retry": true/false }` }] }); // res.choices[0].message.content: // '{ "retry": true, "reasoning": // "Intermittent pattern suggests // flaky test" }' // Estruturado, mas sem // probabilidade calibrada. // ~3s
Performance Profile (v1.13.0)
TypeSafe reports that Jev is 193.6x faster and 444.6x cheaper than LLMs in System One workflows. A separate comparison shows the entry-level price to be 238x lower than Claude Fable 5.1.
Prices may vary from day to day. Check each provider’s pricing page for current rates. The bars are illustrative and not to scale.
Feature Comparison (v.1.13.0)
| Capacity | Jev | Opus 5.5 | Astra |
|---|---|---|---|
| Output Predictability | Guaranteed schema | Schema with structured outputs | Schema with structured outputs |
| Confidence scores | Choice and Score | – | – |
| Text generation | – | Boundary | Boundary |
| Depth of Reasoning | – | Extended Thinking | 5 levels of reasoning |
| Use of tools / agents | – | MCP, computer use | Functions, computer use |
| Classification / Routing | Designed for this (255) | Via prompting | Via prompting |
| Risk of hallucination | No new label | Mitigated | Mitigated |
| Maximum output | Choice / score / new | 128K tokens | 128K tokens |
Examples of Jev Responses
Each primitive returns structured JSON. “Choice” and “Score” include a confidence score for the response itself. “Noul” returns only the probability of “yes.” Jev does not invent labels outside the defined criteria.
Note: “output_tokens” in these examples refers to usage counts, not charges. The output is free. You only pay for input_tokens.
Note: These JSONs follow the API format and the published confidence formulas. They are illustrations, not a live response.
{
"model": "jev-1.13.0",
"answers": {
"category": {
"type": "choice",
"choice": "flaky",
"confidence": 0.65,
"probabilities": {
"flaky": 0.74,
"test_bug": 0.12,
"environment": 0.11,
"product_bug": 0.03
}
}
},
"usage": {
"input_tokens": 342,
"output_tokens": 34
}
}
{
"model": "jev-1.13.0",
"answers": {
"releaseImpact": {
"type": "score",
"score": 2.86,
"confidence": 0.84,
"legend": {
"0": "No user impact",
"1": "Minor, easy workaround",
"2": "Feature degraded",
"3": "Critical journey broken"
},
"probabilities": {
"0": 0.00,
"1": 0.02,
"2": 0.10,
"3": 0.88
}
}
},
"usage": {
"input_tokens": 289,
"output_tokens": 18
}
}
{
"model": "jev-1.13.0",
"answers": {
"retryWillPass": {
"type": "noul",
"noul": 0.91
}
},
"usage": {
"input_tokens": 356,
"output_tokens": 20
}
}
// Jev ainda devolve a opção mais provável. // Não inventa um rótulo fora do criteria. // confidence 0.04 = quase um empate: { "model": "jev-1.13.0", "answers": { "category": { "type": "choice", "choice": "environment", "confidence": 0.04, "probabilities": { "environment": 0.28, "product_bug": 0.26, "test_bug": 0.24, "flaky": 0.22 } } }, "usage": { "input_tokens": 342, "output_tokens": 34 } } // confidence 0.04 = não aja com base na escolha // Seu código: // if (confidence < 0.6) // escalateToHuman()
When to use each one
They aren’t competitors. They are different tools for different tasks.
Jev excels at
- Structured classification & routing
- Real-time decisions (sub-500 ms)
- Scoring and verification gates
- Probability-based guardrails
- High-volume, low-cost automation
- Replace fragile if/else trees
Opus 5.5 excels at
- Extended reasoning & analysis
- Code generation & agent-based workflows
- Understanding documents with long-term context
- Tool orchestration via MCP
- Nuanced and security-aligned generation
- Summarization & Creative Writing
Astra excels in
- Multi-step reasoning (5 levels)
- Complex programming & use of tools
- Multimodal tasks (text + vision)
- Integration with web & file search
- Generation of large outputs (128K)
- Computer use & automation
The actual architecture: combine the three
The most powerful systems use each component where it excels. Jev as the fast screening layer—classifying, scoring, filtering—deciding what actually requires an LLM. Opus 5.5 or Astra for heavy reasoning, generation, and agent-based tasks that require deep thinking. Then Jev again to validate, score, and route the LLM’s output. System One handles the 90% that are routine in 200 ms and at near-zero cost. System Two handles the 10% that require deep thinking. The best balance between cost and quality comes from the pipeline, not from a single model.
Version 1.14.0
On October 14, 2026, TypeSafe released version 1.14.0—it is not covered in this article. For more information, see the official documentation: https://typesafe.ai/blog/jev-1-14
