Ecosystem activity

Located work, separated from proposals.

“Actually built” means a public repository, demo, integration, or direct builder demonstration was located. It does not imply production validation.

Actually built

14 located

HA-Jev

AboveColin

Read the case study Open source

What it is: A Home Assistant custom integration exposing Jev evaluations as sensors and automation actions.
Jev’s role: Repeated state classification and typed automation decisions.
Architecture: Home Assistant state → TypeSafe evaluation → sensor/action result with a local token-budget guard.
Why it matters: Decision models can act as a semantic layer inside an existing event-driven rules engine.

typesafe-mcp

itsmostafa

Read the case study Open source

What it is: An MCP server exposing TypeSafe evaluation to coding agents.
Jev’s role: Machine-readable decisions and probabilities available as agent tools.
Architecture: MCP client → server tool → TypeSafe API → typed response.
Why it matters: The probability-bearing result can be preserved through agent infrastructure instead of flattened to prose.

MAGI System on Jev

hide-G

Read the case study Open source

What it is: An open-source three-sage voting experiment inspired by Neon Genesis Evangelion.
Jev’s role: Independent probabilistic judgments combined through majority voting.
Architecture: Question → three Jev evaluations → deterministic aggregation → decision.
Why it matters: Cheap typed judgments invite ensemble and quorum experiments, though correlated errors still need measurement.

Goblin HR

Kostysh

Read the case study Open source

What it is: A small inspectable demo that evaluates candidates for an impossible mission.
Jev’s role: Scores/selects candidates while deterministic TypeScript assembles the party.
Architecture: Mission state → candidate decisions → deterministic application logic.
Why it matters: Keeping selection probabilistic and execution deterministic makes the boundary easy to inspect.

Axon Work integration

Axon Work author

Read the case study Open source

What it is: The author states that Axon Work uses Jev-style model decisions with a skill/action harness.
Jev’s role: Decision layer feeding an action-delivery harness.
Architecture: Model decision → skill chain → action harness.
Why it matters: A decision model can be invisible infrastructure beneath a workflow product.

ProgressGate

AshutoshVJTI

Read the case study Open source

What it is: An npm package that detects semantic stagnation in agent tool-calling loops, published with tests, a quickstart, and a live demo build.
Jev’s role: One Jev systemOne call per check returns six atomic signals (assumption contradicted, strategy novelty, material progress, and others); Jev never executes or blocks a tool call itself.
Architecture: Agent trajectory → Jev semantic signals → deterministic hysteresis policy in application code → CONTINUE/WARN/REPLAN/HALT decision.
Why it matters: Keeping the halt decision in a deterministic policy layer, with a fail-open default on Jev/network errors, means an API outage cannot itself look like agent stagnation.

chess-jev

gopalanj

Read the case study Open source

What it is: A chess move scorer with a working FastAPI/uvicorn server, browser UI, and test suite; its primary scoring backends are local fine-tuned models, with Jev wired in as one optional hosted backend. The builder also published a companion local model, ChessJev-MiniLM-v1 (huggingface.co/gopalanj/chessjev-minilm-v1): a MiniLM-L6 encoder with an attention head, full-finetuned on Apple M1 MPS against Stockfish 19 teacher labels.
Jev’s role: An optional CHESS_JEV_SCORER=typesafe backend that posts board state and move candidates to TypeSafe's hosted System One API and falls back to a local model on error. The Hugging Face model card itself states plainly it is not TypeSafe Jev and is not Elo-tested.
Architecture: Board state → candidate move generation → scorer router (local MiniLM/byte model, hosted Jev, or heuristic fallback) → ranked move.
Why it matters: The repository explicitly disclaims being 'TypeSafe Jev' or 'OpenJev' — Jev appears only as a pluggable hosted option behind locally trained defaults, not the core of the product.

TypeSafe Agent Skills

TypeSafe (vendor)

Read the case study Open source

What it is: TypeSafe's own published Claude Code plugin and skills.sh package that teaches coding agents to design and wire up Jev workflows.
Jev’s role: The skill's entire purpose is composing typed Jev judgments (Choice, Score, Noul) into agent-written code.
Architecture: Agent skill install (plugin marketplace or skills.sh) → SKILL.md instructions → agent composes TypeSafe API calls in the user's codebase.
Why it matters: Vendor-authored, so it demonstrates TypeSafe's own recommended integration pattern rather than independent adoption evidence.

Jev Playground

Unknown (no linked repo)

Read the case study Open source

What it is: A live, interactive hosted demo with three preset use cases (Support Router, Compare & Choose, Content Triage) that runs real text through Jev and renders the typed judgments and computed routing.
Jev’s role: Every threshold, route, and explanation shown is computed by the demo's own application code from Jev's Choice/Score/Noul judgments, not by Jev directly.
Architecture: Free-text customer request → Jev typed judgment call → client-side thresholding and routing display.
Why it matters: The page has no visible link to a GitHub repository or builder identity, so it reads as a demo of the interface pattern rather than an attributable third-party build.

jev-router

gargpratyush

Read the case study Open source

What it is: An npm-published CLI wrapper that launches Claude Code or OpenAI Codex through a loopback proxy, with a documented test suite covering shared policy, both request formats, and decision display.
Jev’s role: One Jev call per fresh user turn returns task-complexity signals that pick an abstract model tier (fast/balanced/strong/long); an explicit local policy layer (explicit overrides, fail-open on error, no downgrade at low confidence) turns that into the concrete model.
Architecture: User turn → loopback proxy → Jev tier recommendation → src/policy.mjs deterministic rules → concrete Claude/Codex model → forwarded request.
Why it matters: Routing is explicitly fail-open and confidence-aware in the policy code, not in Jev itself — the README states Jev failure never blocks the CLI and low confidence never triggers a downgrade.

SemIf (formerly OpenJev)

TheoLeeCJ

Read the case study Open source

What it is: An independent open-weights reproduction of Jev's runtime-defined typed-decision interface, running a locally hosted 4B model (e.g. Qwen3.5-4B) on a consumer GPU with a browser WebGPU demo, committed benchmark runs, and row-level output data.
Jev’s role: None — this project does not call TypeSafe's Jev API. It reproduces the interface pattern (typed options read as native logits instead of generated text) with an open model the builder controls, and its own site benchmarks against Jev only as a published external reference point.
Architecture: Runtime state + criteria + typed options → local open model forward pass → option logits read directly (no sampled answer token) → probabilities.
Why it matters: Both the GitHub README and the openjev.com site state plainly, unprompted, that the project is independent and not affiliated with or endorsed by TypeSafe — it was renamed from OpenJev to SemIf, evidence the interface pattern itself, not TypeSafe's model or brand, is what's being reproduced.

J3vRoute

Unknown (no linked repo)

Read the case study Open source

What it is: A live, working single-page paper-trading demo: it simulates a virtual USDG portfolio traded across three markets on "Robinhood Chain," with fills clearly labelled as simulated (no swap is signed or broadcast).
Jev’s role: TypeSafe Jev selects buy, sell, or hold for all three markets in one request, then sizes each trade with a Score across five levels that sets position size (0.5-5% of gross portfolio value).
Architecture: 3Route finds prices/routes on-chain → Jev decision (buy/sell/hold + sizing Score) per market → simulated fill applied to a virtual portfolio.
Why it matters: Pairs Jev's decision output directly with a routing protocol (3Route) rather than a coding agent or classifier pipeline — the trade-execution boundary (dry-run only, explicitly labelled) is kept separate from the decision boundary.

system-one-router

npm publisher (unverified identity)

Read the case study Open source

What it is: A published npm extension (v0.4.5) for the Pi coding agent that adds a per-turn model router; its README states it is based on and retains attribution to an existing router, yeliu84/pi-model-router.
Jev’s role: An optional LLM-intent-classifier mode calls TypeSafe's System One API (model jev-latest) to categorize task intent, overriding the package's own keyword/heuristic router when configured.
Architecture: User turn → optional Jev classifier call or local heuristics → high/medium/low tier → mapped to a configured concrete model per tier.
Why it matters: Jev is one swappable classifier backend behind a router that works without it (heuristics are the default) — a lower-commitment integration pattern than jev-router's Jev-only design.

is-odd-jev

npm publisher (unverified identity)

Read the case study Open source

What it is: A published npm package (v1.1.0, zero dependencies) that answers whether a number is odd by calling a Jev Noul primitive and returning its calibrated probability instead of a bare boolean.
Jev’s role: The entire package: one Noul call per invocation, against api.typesafe.ai or the Vercel AI Gateway's typesafe-ai/jev model, returns { odd, p, ms, output_tokens }.
Architecture: Integer input → single Noul question ("Is n odd?") → probability read from the model's own distribution, not narrated.
Why it matters: This is a joke package in the lineage of is-odd/is-odd-ai (its README says as much), but it is not a fake integration: it genuinely calls Jev's API and correctly demonstrates that Noul returns a probability rather than a confidence field bolted onto a boolean.

Proposed

Architectures still looking for proof.

Confidence-gated agent control loops

Use Jev repeatedly to route, verify, and decide whether an agent should continue or escalate.