Running Jev locally

You can't download Jev itself — TypeSafe ships it as a hosted, closed-weight API. But the open ecosystem has caught up: independent, Jev-like decision models now run fully on your own machine. Pick your hardware below and get the shortest path to a working local setup.

python3.11 -m venv .venv && source .venv/bin/activate
pip install laya-mlx

hf download aac6fef/laya-mlx

import laya_mlx as laya

agent = laya.load("aac6fef/laya-mlx")
result = agent.predict(
    "I was billed twice. Please refund the duplicate.",
    {
        "department": {
            "type": "choice",
            "instructions": "Who should handle this?",
            "criteria": ["billing", "technical", "sales"],
        }
    },
)
print(result["answers"]["department"])

If you searched run Jev locally, install Jev, or Jev self-host, here is the honest split. The official Jev model has no public weights and no offline build, so there is no literal Jev local install. What changed is that a small ecosystem of open, Jev-like decision models appeared — same primitives (a typed choice, an ordered score, a calibrated yes/no), open weights, running on your laptop or GPU. The generator above writes the exact commands; this page is the map.

Choose a local model

These are independent, community Jev-like models — not official Jev. Pick the one that fits your hardware, then follow its deploy guide:

The local routes at a glance

Run Jev locally on a Mac (Laya-MLX)

The lightest route is Laya-MLX on Apple Silicon: a ~420M-parameter model that loads in-process and returns a short typed decision in roughly 7–14 ms (community-reported), with no GPU and no server. Install is one line, the model auto-downloads on first run, and you call it straight from Python — the generator above has the copy-paste script, and the full Laya guide covers Node/ONNX too.

pip install laya-mlx
# then, in Python:
#   import laya_mlx as laya
#   agent = laya.load("aac6fef/laya-mlx")
#   agent.predict(state, questions)

Self-host a Jev-compatible API with Docker (OpenJev)

If you want a network endpoint that speaks the same request shape as Jev, OpenJev is the closest thing to a self-hosted Jev server. One Docker command brings up vLLM plus a Jev-compatible API on 127.0.0.1:8080; it needs an NVIDIA GPU with at least 24 GB of VRAM. After it loads you POST a state and typed questions and get back calibrated answers, exactly like the hosted contract.

git clone https://github.com/razorback16/openjev && cd openjev
docker compose up -d
curl localhost:8080/v1/models

No 24 GB GPU? Ollama / LM Studio (GGUF)

You can run a Jev-like model in Ollama or LM Studio too: the APUS-OpenJev GGUF builds (4B or 9B, Q8_0) run on macOS (Metal), Windows and Linux, driven as a decision model by the OpenJev harness. It's the easiest cross-platform route — full commands are in the OpenJev guide (/jev/local/openjev).

The 0.6B replica with a full pipeline (NanoJev)

If you want to see how a Jev-style model is actually built, NanoJev is a 0.6B, MIT-licensed replica on Qwen3 that ships its whole training pipeline and dataset and serves decisions on a single GPU at POST :8765/api/evaluate. It's a research replica trained on toy tasks — great for learning and prototyping, not production. Full steps: /jev/local/nanojev.

These are not the official Jev weights

Important: Laya, OpenJev and NanoJev are independent, community projects, not TypeSafe's Jev — their own READMEs say so. They rebuild the typed-decision idea on open weights, which means the calibration and quality are their own, and an open build is only as trustworthy as its training. NanoJev's authors, for instance, openly caution that its good one-step scores don't establish real task success. Calibration is not a given either: some third-party checkpoints ship with out-of-range temperatures, so the confidence numbers they return can be uncalibrated (the Laya-MLX runtime prints a warning when it detects this). Before you wire a production threshold like "escalate if p > 0.8" to a local model, validate it on your own labelled data — the same discipline Jev asks for, but now fully on you. Treat the table above as a snapshot of a fast-moving space, not an endorsement.

If you'd rather not self-host

Local means no network hop and no per-call cost, but you own the ops and the validation. If you want pinned, calibrated decisions with none of that, the hosted path stays the practical default: POST https://jevtypesafeai.com/api/v1/decide with a jv_live_ key (instant, self-serve), or the official POST https://api.typesafe.ai/v1/systemone. Same typed answers, ~70–500 ms, about $0.001 a decision — no GPU to provision.

See also: Deploy Laya · Deploy NanoJev · Deploy OpenJev · Deploy DiffusionGemma · Local Setup Generator · Laya vs Jev · Is Jev open source? · Get a hosted key

Related: Jev vs Laya · Jev open source · Jev API key