Jev Decision Models
System One: replace free-form generation with parallel, typed, calibrated decisions
Suggested reading: about 20 min
Learning goal
Chapter keywords
| Keyword | Explanation | ESP32 engineering analogy |
|---|---|---|
| System One decision | A fast mapping from shared state to finite, predefined typed answers rather than free-form text generation. | A coprocessor with a fixed opcode table: it receives a register snapshot and returns an enum or status code. |
| choice / score / noul | Jev's public answer categories: finite choice, numeric score, and an explicit insufficient-basis result. | A C enum, a measurement with units, and an explicit error code that callers handle differently. |
| Calibration | Testing whether predicted confidence matches observed correctness on labeled examples, then selecting a threshold. | Calibrating an ADC against standards; a precise-looking reading is not automatically accurate. |
| Deterministic safety boundary | A rule layer independent of model advice that enforces schemas, ranges, interlocks, deadlines, and degradation. | Hardware protection, watchdogs, and a state machine before an actuator—not trust in prose. |
Bridge from the previous chapter
Day 9 built the Transformer map and Day 10 separated parallel training from autoregressive generation. Before KV Cache, this chapter introduces another route: when a product needs finite, auditable decisions, should it avoid placing open text generation in the control path?
Historical development
Typed decision systems draw on formal computation, finite-state control, statistical classification, probability calibration, and modern generation. Jev's public material reveals System One serving semantics, not its underlying layer count, weights, or training details.
Formal neurons express threshold decisions as computation
McCulloch and Pitts connected logic and neural activity with formal neurons, early evidence that a learning system may still be described as constrained input-output decisions.
Original McCulloch–Pitts paper ↗AI research frames reasoning and control as distinct problems
The Dartmouth proposal listed learning, language, and abstraction as machine-intelligence research problems, leaving a useful frame for later rule systems, classification, and generation.
Original Dartmouth Proposal ↗The perceptron demonstrates data-driven finite classification
Rosenblatt's perceptron work discusses learnable pattern classification, emphasizing that a model output may be a finite category rather than a paragraph of language.
Original Rosenblatt paper ↗Calibration makes probability forecasts testable
Dawid discussed calibration and testing of probability forecasts, grounding the engineering claim that model confidence can be checked against observed frequency.
Dawid calibration paper ↗The Transformer makes conditional generation a mainstream systems workload
Attention Is All You Need introduced an Attention-centered sequence architecture that later autoregressive systems used for open token generation.
Original Transformer paper ↗Jev publishes a parallel typed System One serving contract
TypeSafe AI's public architecture material names shared state, independent typed questions, choice/score/noul, and parallel non-autoregressive evaluation. Its private model structure is undisclosed, so engineering evaluation must use observable interfaces and real workloads.
Official Jev architecture ↗Illustrated analogy
A parallel diagnostic board behind a safety relay
A controller MCU sends a timestamped sensor snapshot to a diagnostic board. The board concurrently answers whether maintenance is needed, which network route is available, and what alert level applies; every answer writes only a defined register or an explicit no-conclusion code. The safety relay does not care how fluent the board might sound. It accepts only allowlisted commands whose mode, range, and interlocks are currently valid.
Where the analogy stops: Jev is not a published hardware coprocessor, and its internal neural-network layers are not disclosed. The analogy explains only constrained interfaces, parallel questions, and separate deterministic execution authority.
Chapter walkthrough
First classify the task: generate content, or choose from a bounded set?
A decoder-only LLM usually produces text token by token: P(y|x)=∏ₜP(yₜ|x,y₍ₜ₎). The token selected at step t becomes part of the input at step t+1. It resembles sending a variable-length UART frame whose next byte cannot be decided until the preceding byte is fixed. This is useful for explanations, summaries, dialogue, and draft code, but it introduces tokenization, sampling, stopping rules, serial decode, and KV state into the serving path. Jev's public material describes something different: a System One decision-serving contract, not a Transformer-peer architecture with disclosed layers, weights, or training recipe. A caller supplies shared state and several typed questions with finite output spaces; those questions can be evaluated independently rather than by first generating prose and parsing it. Its value is turning “which predefined action or grade should we choose?” into a verifiable interface. Do not turn this into a universal speed claim. Public 40–200× claims apply to constrained System One workloads and must be compared only with matched inputs, outputs, hardware, and quality criteria.
Shared state plus a question map resembles one DMA snapshot consumed by several peripherals
The public Jev architecture describes a shared state together with a map of questions. Each question declares its expected answer type and permitted values. The system does not need to write a natural-language paragraph before another question interprets that paragraph. For an embedded engineer, this resembles publishing one sensor or DMA snapshot into a read-only buffer that several independent peripherals consume: a thermal-risk question, a network-recovery question, and a maintenance-priority question may read the same fields. Parallelism does not remove all dependencies. The sampling instant, schema version, units, missing-field handling, and validity interval must be fixed. If decision B genuinely depends on decision A, make that dependency explicit in host orchestration or a subsequent request; do not pretend both remain independent. This produces better evidence too: each question can carry an input schema, option set, answer, confidence, latency, and version record instead of leaving operators to infer a decision from free-form text.
Treat choice, score, and noul as interface types rather than labels in prose
Jev publicly exposes choice, score, and noul answer categories. A choice selects from a finite set such as {continue sampling, request human review, enter safe mode}. A score is numeric and can support ranking or risk bands, but its units, range, direction, and threshold must be defined. Noul represents a supported “not enough basis” outcome so the system need not fabricate a confident choice. These are analogous to a C enum, a range-bounded measurement, and an explicit error code: callers can validate the shape before deterministic policy consumes it. A typed interface prevents malformed action names, missing JSON fields, and unit confusion. It does not prove semantic correctness. A model may validly return `continue` while misreading an unusual temperature pattern. Schema validation is therefore only one gate; state freshness, physical range, device mode, rate limit, interlocks, and escalation rules remain separate. Noul must not be silently converted into a default action. It should take the conservative path and create an observable event.
Confidence needs calibration: 0.9 is a testable frequency claim, not ninety-percent truth
A decision interface may return a score or confidence, but concentrated scores and a model that sounds certain do not automatically mean correct decisions. Calibration asks whether, on deployment-like examples with real labels, predictions near 0.9 are correct roughly nine times out of ten. It is like calibrating an ADC: a register value of 900 is not a trustworthy physical measurement until it has been checked against standards, temperature, and production variation. Keep a temporally separated validation set for every task; inspect a reliability diagram, coverage, error cost, and false-accept and false-reject rates at each threshold. When erroneous actuation costs far more than human escalation, set the threshold conservatively and allow noul, timeout, and stale state to degrade safely. Calibration drifts after a sensor revision, firmware update, environmental shift, or question-option change. Record model version, question schema, input distribution, and threshold version together so a later audit can reproduce why a command was accepted or rejected.
A speed comparison must match workloads instead of replacing an open conversation with a bounded-decision ledger
Autoregressive LLM latency commonly includes tokenization, prefill, one-token-at-a-time decode, sampling, and streaming; longer answers expose serial dependency and growing KV reads. A parallel finite-decision interface avoids free-text decode, so it may have low latency when several fixed questions inspect the same snapshot. That does not mean it can write an explanation, draft an incident report, handle arbitrary new options, or absorb unbounded context for free. Compare state size, question count, option count, hardware, concurrency, warm-up, p50 and p95 latency, timeout policy, and quality acceptance together. If LLM output must be parsed into an action, include parsing, retries, and rejection costs. In an ESP32 project, the useful measurements are often end-to-end tail latency from sensor timestamp to safe decision, stale-input rate, network-failure rate, and harmful-action risk—not one vendor's isolated multiplier. Those measurements decide whether a task belongs in a local state machine, an Edge Host typed-decision service, or a genuinely generative model.
Responsibility boundary: the Edge Host may advise, while the ESP32 retains deterministic execution authority
Putting Jev on an Edge Host does not diminish the MCU. It assigns work by resource and safety boundary: the ESP32 acquires sensors, owns the real-time state machine, applies local thresholds and interlocks, validates message integrity, and drives actuators. The Edge Host can aggregate richer state, run the constrained decision service, retain audit logs, and update model versions. A cloud path, if present, remains an explicit non-real-time fallback or offline analysis path. The message contract needs a version, monotonic sequence, timestamp, units, integrity check, deadline, and replay rule. After receiving a reply, the MCU still checks schema, choice allowlist, score range, calibrated confidence threshold, state freshness, and the current device mode. Failure of any check enters a tested fail-closed or safe-degraded state. This also frames the next KV Cache chapter: the growing per-token session cache is a cost of choosing autoregressive generation; bounded decisions change the latency and state ledger but do not erase system engineering.
Start with one acceptance-testable workflow instead of delegating control logic to a model
The first version should not directly control a motor, relay, or safety-critical valve. Choose a task that already has human review or an easy rollback: diagnostic-ticket routing, alert-priority grouping, test-report grading, or suggested next inspection. Write the finite answer table, answer meanings, input schema, ground-truth source, and failure action first. Collect normal, boundary, sensor-fault, network-jitter, and unknown-state examples. Beyond offline accuracy, calculate rejection rate, false-pass rate, false-reject rate, and latency percentiles at every threshold. Run an online shadow mode in which the system records recommendations without executing them; compare against rules or human outcomes before exposing low-risk paths. Version and regression-test every change to question wording, options, state fields, model, or threshold exactly as you would a wire protocol. Only then does “faster” become an auditable system property rather than a demo impression.
Interactive process
How a typed decision crosses the ESP32–Edge Host safety chain
The six stages separate state capture, parallel decision, confidence calibration, and final authority so a model recommendation is never confused with an execution permit.
Capture state snapshot · sensors + mode + timestamp
The ESP32 fixes units, sequence, and freshness
The input contract precedes every model call
Loop / return condition: Every new snapshot starts a new cycle; the model never owns MCU execution. When questions depend on one another, make the next state and request explicit rather than hiding it in free text.
View the complete static diagram
ESP32 sensors/state machine ──validated snapshot──► Edge Host
│
shared state ─► typed question map ─► choice / score / noul
│
ESP32 policy + allowlist + range/interlock ◄── typed decision + confidence
│ valid │ timeout / low confidence / invalid
└──────────────► actuator safe degraded state ◄──────────────┘Code or command example
request = { state: validated_snapshot, questions: typed_questions }
reply = jev_decide(request) # choice / score / noul + confidence
if reply.valid && calibrated(reply.confidence) && policy_allows(reply):
esp32_execute(reply.choice)
else:
esp32_enter_safe_degraded_state()Hands-on lab
Lab notes and export
Engineering pitfall
Knowledge check
Answer all three multiple-choice questions, then submit. Answers stay hidden until submission.
Discuss this chapter on GitHub
Sign in with GitHub to ask a question, share measurements, or compare implementations. Comments are stored in this course's GitHub Discussions.
The embedded comments need JavaScript. You can also open the GitHub discussion area directly: Open GitHub Discussions ↗
Further reading
Bridge to the next chapter
Next returns to the engineering cost of autoregressive LLMs: why historical K/V can be reused, how session memory grows linearly with tokens, and how a service reclaims state.
Next: Day 12 · KV Cache