Jev vs Laya vs JevLang vs Semantic Python

The short answer

Hosted model and API

Jev

TypeSafe's System One model accepts state plus typed questions and returns probabilistic, structured decisions through a hosted API.

Open-weights decision engine

Laya

A local decision engine for choice, score, and yes/no noul questions, with Python, CLI, and service interfaces.

Python value layer

Semantic Python

A standard-Python library that makes selected values semantic and preserves each Boolean judgment as an inspectable Decision.

JevLang is a fourth piece: a Python source extension that introduces ~ and jev/case syntax and rewrites .jev files to calls against Jev. It is included below because it is the closest syntax-level comparison to Semantic Python.

Complete comparison

Dimension	Jev	Laya	JevLang	Semantic Python
What it is	A hosted System One decision model and HTTP API from TypeSafe.	An open-weights, non-autoregressive decision engine.	A Python source extension and client layer built around Jev.	An opt-in Python value and decision layer.
Primary job	Answer typed questions about supplied state.	Run typed decisions on local or self-hosted model checkpoints.	Express Jev-backed questions and branches with compact syntax.	Use semantic judgments inside ordinary Python control flow while retaining metadata.
Primary abstraction	State plus a collection of typed questions.	State plus `choice`, `score`, or `noul` questions.	`x ~ question` and `jev/case` blocks.	`Semantic(value)` compared with a proposition.
Syntax	HTTP/JSON API.	Python API, CLI, HTTP service, and related SDKs.	Python-derived syntax that is rewritten before execution.	Valid, unmodified Python syntax.
Source files	Language-independent API.	Ordinary client code.	Uses `.jev` modules and an import hook.	Uses ordinary `.py` modules; no compiler or import hook.
Semantic boundary	The explicit API request.	The explicit prediction call.	The `~` expression or `jev` block.	Only an explicitly wrapped `Semantic(...)` value.
Inference provider	TypeSafe's Jev service.	Laya checkpoints selected directly or through its router.	TypeSafe Jev.	Selectable: Laya, OpenAI, or deterministic `FakeBackend`.
Execution location	Hosted.	Local or self-hosted.	Hosted inference through Jev.	Local, hosted, or offline depending on the configured backend.
Current decision types	Yes/no, choice, and rating questions through the System One API.	`noul`, `choice`, and `score`.	Yes/no probability, scale, and choice.	Boolean proposition evaluation for the v0.1 equality MVP; choice and score remain forward-compatible protocol shapes.
Return shape	Typed answers plus model and usage information.	Typed answers, probabilities/confidence, usage, and optional routing metadata.	Number- and string-like results carrying additional probability metadata.	A bool-coercible `Decision` retaining value, probability, backend, model, proposition, state digest, and provenance.
Branching	The caller interprets returned values.	The caller interprets returned values.	Direct `if x ~ ...` and `jev/case` constructs.	Ordinary `if` and `while` consume a `Decision`.
Default Boolean policy	Caller-defined from returned probabilities.	Caller-defined; Laya also exposes confidence-gating options.	A yes/no probability is truthy at its documented default threshold.	True at or above 0.85, false at or below 0.15, otherwise raise by default.
Uncertainty	Probabilities and confidence are returned for application policy.	Probabilities/confidence are returned; low-confidence results can be marked.	Probability and confidence are available for explicit guards.	An uncertainty band is part of configuration; ambiguous truth testing raises unless another policy is explicitly selected.
Negation behavior	Expressed in the question or caller logic.	Expressed in the question or caller logic.	A separate source expression can issue another query.	`!=` negates the same cached judgment instead of rewording and reinferring.
Caching	Not a language-layer feature; callers manage it.	Lifecycle and prediction hooks exist; application policy remains explicit.	No caching layer of its own is documented.	Stable decision caching is built in and preserves metadata.
Replay	Caller responsibility.	Caller responsibility or integration-level tooling.	Offline stubs support syntax and workflow tests, not model replay.	Offline record/replay primitives preserve decision provenance without plaintext state.
Offline tests	Require application fixtures or mocks.	Can run locally after model setup; deterministic application tests still need fixtures.	Includes a substring-based fake mode for tests without a key.	`FakeBackend` provides exact deterministic fixtures with no network or model download.
Network and data	State is sent to a hosted API.	Inference can remain local, but first use may download checkpoints.	The value on the left of `~` is sent to Jev.	No transfer on import or wrapping. A comparison follows the selected backend: Laya local, OpenAI remote, fake offline.
Install	Use the hosted API and credentials.	`pip install laya`	`pip install jevlang`	`pip install semantic-python`, with optional `[laya]` or `[openai]`.
Language change	None; it is an API.	None; it is an engine/API.	Adds new source forms and a `.jev` toolchain.	None; operator behavior changes only on the explicit wrapper type.
Best fit	Hosted, typed probabilistic decisions through a direct service API.	Local or self-hosted typed decision inference.	Teams that want dedicated semantic syntax backed specifically by Jev.	Teams that want valid Python syntax, backend choice, inspectable Boolean decisions, and deterministic application tests.

Using Laya through Semantic Python

Laya supplies local inference; Semantic Python supplies the value boundary, Python operator behavior, decision policy, caching, provenance, and replay.

python -m pip install "semantic-python[laya]"

from semantic_python import LayaBackend, Semantic, configure

configure(
    backend=LayaBackend(),
    true_threshold=0.85,
    false_threshold=0.15,
    uncertainty="raise",
)

ticket = Semantic("I was charged twice and need a refund")
decision = ticket == "the customer has a billing problem"

if decision:
    route_to_billing()

print(decision.probability, decision.backend, decision.model)

The first Laya prediction may download a checkpoint and initialize a substantial local model stack. Validate quality, latency, memory, and negation behavior on representative data before production use.

Which should you choose?

Choose Jev when

You want TypeSafe's hosted System One model and will build directly against its typed HTTP API.

Choose Laya when

You want an open-weights decision engine on local or self-hosted infrastructure and are comfortable managing its model runtime.

Choose Semantic Python when

You want explicit semantic values in standard Python, backend choice, inspectable uncertainty, caching, replay, and deterministic offline application tests.

Frequently asked questions

Is Semantic Python a Jev replacement?

No. Jev is a model/API; Semantic Python is a Python value layer. A future Jev adapter is roadmap research, not a current integration.

Does Semantic Python replace Laya?

No. Laya can provide the inference behind Semantic Python. The two projects operate at different layers and can be used together.

What is the closest JevLang equivalent?

x ~ "question" in JevLang is closest in intent to Semantic(x) == "proposition", but Semantic Python uses ordinary .py syntax, an explicit wrapper, and a backend-neutral decision protocol.

Does Semantic Python change normal string equality?

No. "done" == "the user wants to stop" remains ordinary deterministic Python. Only Semantic("done") crosses the model-backed boundary.

Can Semantic Python work without a network?

Yes. FakeBackend is entirely offline, and Laya inference can run locally after its model artifacts are available. The OpenAI backend sends the complete wrapped state and proposition to a hosted service.

Are model probabilities facts?

No. They are estimates that require evaluation on the intended domain. Consequential actions need conservative thresholds and an explicit review or fallback path.

Primary sources and scope

Comparison checked on October 7, 2026. Product APIs and model behavior can change. Vendor performance and calibration claims are not reproduced here as independent benchmark results.