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

17 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.

jev-ultrafast

Browser Use (third party, not TypeSafe)

Read the case study Open source

What it is: A browser-automation runtime from Browser Use with a published performance report (docs/performance.md). The report documents a 7.07 s Google Flights run made with 17 Jev requests; that timing excludes browser setup and post-run verification, and the run finds flight results rather than booking anything.
Jev’s role: Jev picks the next action and its target from a list of page controls rebuilt at every step; a small LLM is used only to fill text inputs, and the outcome is verified separately after the run reports DONE.
Architecture: Page → control list rebuilt each step → Jev action + target choice → small LLM for text entry only → action → DONE → separate outcome verification.
Why it matters: The report attributes its gains to runtime changes rather than model changes: with the same models, median browser protocol calls fell from 1,092 to 101 and median task time fell 25%. The per-run cost figure circulating with this project appears only in the author's X post, not in the report, so it is not carried here.

1k Papers

Hassan El Mghari

Read the case study Open source

What it is: A live site that classifies 1,018 AI papers against 24 topics, with Jev doing the classification after an LLM has summarised each paper.
Jev’s role: One typed classification per paper against a fixed 24-topic taxonomy; the LLM summary is Jev's input, not the classifier.
Architecture: Paper → LLM summary → Jev classification against 24 topics → browsable topic index.
Why it matters: A bulk-classification shape rather than an agent loop: the corpus is fixed, the taxonomy is fixed, and the interesting cost question is per-item. The build's cost and latency numbers are self-reported by the author and are not repeated here; only the published corpus size and topic count are.

Inbox triage demo

Riley Brown

Read the case study Open source

What it is: An inbox triage demonstration attributed to Riley Brown. Confirmed at second hand only: it appears in the madewithjev.com directory of Jev builds, and the demo itself was not opened for this record.
Jev’s role: Typed triage judgments over incoming mail, as the directory describes it; the mechanics were not verified directly.
Architecture: Incoming message → Jev triage judgment → application-side sorting, as listed rather than as inspected.
Why it matters: A directory listing is secondary evidence: it establishes that the build was claimed, not that it works as described. This entry should be upgraded on a first-hand look at the demo, or dropped if none is available.

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.