At 2:13 AM, a production alert fires. The first problem is not “why did this happen?” It is “what should we do now?”
That means making a few bounded decisions:
- Which team owns this?
- Does this require an immediate on-call response?
- Is there enough confidence to act automatically?
- Should an incident agent begin investigating?
Operational teams have traditionally handled these decisions with humans or deterministic rules. More recently, general-purpose LLMs have become a third option.
| Approach | Strength | Limitation |
|---|---|---|
| Human | Flexible, context-aware, and good at handling edge cases | Slow, expensive, and difficult to scale |
| Deterministic rules | Fast, cheap, predictable | Brittle when context and exceptions multiply |
| General-purpose LLM | Flexible and able to return schema-constrained output | A general autoregressive generator is doing a narrow decision task |
Many teams are now exploring LLMs for these decisions, but that introduces another problem: Cost and Speed.
At scale, cost hits the budget and latency hits the SLA. Frontier-model inference can become expensive at scale, while reasoning overhead and autoregressive decoding can add latency.
When we integrate an LLM into an operational workflow, model latency becomes part of the system’s latency budget. Under high alert volume, slow decisions can also create queues and delay time-sensitive actions.
The remaining question is whether every routing decision really needs a model designed to generate text, code, explanations, and plans.
That is the gap Jev is designed to fill.
A Model for Bounded Decisions
Diogo Almeida, founder of TypeSafe AI, introduced Jev as the company’s first System One Model. TypeSafe says Jev gives up string generation in favor of fast, typed probabilistic decisions that software can consume directly.1
Its core interface is simple: state plus questions produces typed decisions plus probabilities. The documented state can be a string, JSON object, or array.2 3
Jev takes state and bounded questions, then returns typed decisions with probabilities.
A useful mental model
Jev behaves somewhat like a classifier, but with the broad semantic understanding we normally associate with large language models.
It is an analogy, not a claim that Jev is a conventional classifier.
TypeSafe exposes three decision primitives:3
| Type | What it returns | Example |
|---|---|---|
| Noul | A 0–1 probability that the answer is yes | “Does this incident need an immediate response?” |
| Choice | A predefined option plus its probability distribution | platform, checkout, database, unknown |
| Score | A position and distribution across an ordered rubric | Severity 0–3 |
Noul is intentionally spelled that way. It is TypeSafe’s primitive for a truth probability between zero and one. Score can also fall between defined levels.3
Why this is different
Jev is designed around bounded questions. TypeSafe says all questions see the same state and are evaluated independently and in parallel. (State documentation · Parallel Questions cookbook )
For an incident, those questions might be:
- Who owns it?
- How severe is it?
- Should the system page now?
- Is it customer-impacting?
- Should an incident agent start investigating?
Jev is not being asked to write a five-part incident analysis. It is evaluating five bounded judgments against the same state. That is an important part of the performance story: the model is not generating text that software later converts into decisions. The decisions are the output.
Why “System One” Matters
According to TypeSafe’s announcement, the name comes from Daniel Kahneman’s Thinking, Fast and Slow:
- System 1 is fast, automatic, and intuitive.
- System 2 is slower and deliberate.
TypeSafe applies a similar split to AI systems. Jev is for narrow, fast decisions. Larger reasoning models remain better suited to investigation, planning, coding, and explanation.1
Consider an incident:
| Decision layer | Reasoning layer |
|---|---|
| Which team owns this? | Why is the service failing? |
| Is it urgent or customer-impacting? | What changed before the incident? |
| Should the system escalate? | How should we fix it? |
Those are different jobs. The first determines what should happen next. The second determines how to solve the problem.
The Cost and Speed
TypeSafe reports input pricing of $0.042 per million tokens, effectively free outputs, and roughly 70–500 ms end-to-end response times. In its own System One workflow evaluations, the company reports Jev as up to 193.6× faster and 444.6× cheaper than the compared LLM workflows.1
TypeSafe itself cautions that its 193.6× speed and 444.6× cost improvements are likely toward the high end of real-world gains, so these figures should be read as vendor benchmark results rather than universal Jev-vs-LLM ratios.1
How Jev Fits Into an Incident Workflow
Take a CloudWatch alarm for checkout 5xx responses. Normalized production telemetry can provide Jev with relevant context for routing and urgency decisions:
{
"event_type": "cloudwatch_alarm",
"environment": "production",
"service": "checkout-api",
"region": "ap-southeast-1",
"alarm": {
"name": "prod-checkout-high-5xx",
"state": "ALARM",
"metric": "HTTPCode_Target_5XX_Count",
"namespace": "AWS/ApplicationELB",
"threshold": 50,
"current_value": 137,
"period_seconds": 60,
"evaluation_periods": 2,
"breaching_periods": 2
},
"resource": {
"load_balancer": "prod-checkout",
"target_group": "checkout-api"
},
"service_health": {
"request_rate_per_minute": 1840,
"http_5xx_rate_percent": 7.4,
"p95_latency_ms": 2180
},
"recent_change": {
"deployment": true,
"service": "checkout-api",
"version": "2026.09.17-rc3",
"minutes_ago": 11
}
}
Rather than ask a model for an incident narrative, ask bounded questions:
{
"owner": {
"type": "choice",
"instructions": "Select the team that should own the initial investigation of this production incident.",
"criteria": {
"checkout": "The evidence primarily points to the checkout application, API, or a recent checkout deployment.",
"platform": "The evidence primarily points to shared infrastructure, Kubernetes, load balancers, or platform services.",
"database": "The evidence primarily points to database availability, connectivity, capacity, or query performance.",
"network": "The evidence primarily points to DNS, network connectivity, routing, or transport failures.",
"unknown": "The available evidence is insufficient to assign ownership confidently."
}
},
"page_now": {
"type": "noul",
"instructions": "Does the available evidence justify paging the on-call engineer immediately rather than waiting for normal triage?"
},
"severity": {
"type": "score",
"instructions": "Rate the current production impact based on customer impact, error rate, latency, and duration.",
"criteria": [
"Informational: abnormal signal with no demonstrated customer impact.",
"Minor: limited degradation with low customer impact.",
"Major: significant production degradation requiring prompt engineering response.",
"Critical: severe customer impact, widespread outage, or immediate business risk."
]
}
}
Jev Output
The following values are illustrative, not results from an actual Jev request. They demonstrate how the documented decision primitives could drive this workflow.
{
"owner": {
"choice": "checkout",
"probabilities": {
"checkout": 0.76,
"platform": 0.17,
"database": 0.03,
"network": 0.01,
"unknown": 0.03
},
"confidence": 0.76
},
"page_now": {
"noul": 0.95
},
"severity": {
"score": 2,
"legend": {
"0": "Informational",
"1": "Minor",
"2": "Major",
"3": "Critical"
},
"probabilities": {
"0": 0.01,
"1": 0.05,
"2": 0.81,
"3": 0.13
},
"confidence": 0.81
}
}
The application keeps control of the workflow by setting the action thresholds; TypeSafe documents confidence-gated routing as a pattern for deciding whether to act or escalate.4
We can use this structured output to drive the next step:
# Page the on-call engineer if the alert is very likely to need immediate attention.
if response["page_now"]["noul"] >= 0.90:
page_on_call_engineer()
owner = response["owner"]
# Auto-assign the incident only when Jev is confident enough about ownership.
if owner["confidence"] >= 0.80:
assign_incident(owner["choice"])
else:
# Otherwise, ask a human to confirm the owning team.
request_human_triage()
severity = response["severity"]
# For major or critical incidents, open an incident and start the investigation agent.
if severity["score"] >= 2:
open_incident()
start_incident_agent()
With the owner confidence of 0.76, the system would page the on-call engineer, open an incident, and start an investigation, but request human confirmation before assigning ownership. Jev does not merely select checkout; it gives the workflow enough uncertainty information to decide which actions can be automated and which decisions should escalate.
Only then does the system invoke the expensive intelligence.
Jev can route a compact CloudWatch alert into an incident workflow before an agent begins the investigation.
Decisions First, Agents Second
Jev is not a replacement for LLMs. LLMs remain excellent for generation, reasoning, coding, planning, investigation, and conversation.
A Jev-based decision layer can support classification, routing, scoring, verification, branching, and fast probabilistic decisions.
This proposed SRE architecture places Jev before an agent, where it can decide whether an event can be ignored, needs a human, or should start an investigation. The same decision layer can also operate inside an agentic system.
Model Routing
An agentic system continuously makes small routing decisions: which model should handle a task, whether a result needs verification, and whether the confidence is high enough to continue. Today, the main LLM, or another LLM acting as a sub-agent, often makes those decisions.
That can mean using a reasoning model to decide which reasoning model to use. A dedicated decision layer provides another option.
A simple task does not necessarily need the most expensive model available. A difficult or high-risk task might. TypeSafe documents intent routing to deterministic logic, a specialist LLM, or a human; routing to a smaller or frontier reasoning model is a natural extension of that pattern.5
A decision layer can route work to the least expensive appropriate next step, then escalate complex or uncertain cases.
The same pattern applies to tool routing and verification. An agent may need to choose between querying logs, inspecting a deployment, searching documentation, or paging an engineer. It may also need to decide whether an output is safe, relevant, or ready to continue. These are bounded judgments that can escalate uncertain cases to a stronger model or a human.
The Hybrid Architecture
A decision-first architecture routes routine events away from a reasoning model and escalates only complex cases.
Traditional software is deterministic and predictable, but it is limited when decisions depend on ambiguous context. Agents are flexible and powerful, but they introduce probabilistic behavior and higher inference cost. Jev can potentially sit between those worlds: it adds learned semantic decisions where hard-coded rules are not enough, without requiring a full generative reasoning model for every branch.
Jev does not replace the LLM. It gives production software a decision layer that can decide when an LLM is actually necessary.