Jev GitHub Projects: 363 Repos, SDKs & Skills

The README says you give one goal, Jev picks an operation and an element, and a small LLM writes text only when the operation is TYPE_TEXT. Listed operations are CLICK, TYPE_TEXT, SELECT, SCROLL_UP, SCROLL_DOWN, WAIT, DONE, and BLOCKED. It reports a Zürich to London Google Flights run in 7.1 seconds, including generated text and loading waits, and says two target decisions share one network round trip.

The README describes an open-source stack for turning ideas into Python strategies, backtests, paper trading, live execution, and monitoring. With the AI decision filter on, it sends the order, strategy context, exposure, positions, and budget to Jev and receives typed Choice results, probabilities, and confidence. Exits bypass that filter; if no AI provider is available the order is allowed and the fail-open result is logged.

The README says the API matches TypeSafe's System One, so their Python SDK can point at a local Kev server. One request can ask noul, choice, and score questions, and each checkpoint ships with a temperature fitted on held-out data. It lists four sizes, from a 0.8B that runs on a laptop to a 27B, and says you can use the pretrained weights or train your own.

The README says the Android app is Kotlin and does not hook, repackage, or call the chat app's API or account; it uses the system accessibility service to read the conversation on screen. QQ and X are described as tested on device, and Feishu/Lark falls back to OCR because message text is not in the accessibility tree. Windows and macOS builds are linked from sibling repositories.

The README says every tool call and result is scored in one request, stale ones are dropped or truncated, and everything kept stays verbatim. It does not rewrite user or assistant text into a summary. The state sent to Jev is the conversation so far, with tool results replaced by short notes and fitted into a token budget.

The README says SemIf was formerly called OpenJev. It reproduces the interface pattern of typed decisions with open models and states that it does not reproduce Jev's undisclosed model or training. It says the project is independent and not affiliated with Jev or TypeSafe, and that it reads option probabilities directly, without an answer sentence or a decoding loop.

The README says jg returns relevant files, reading leads, and verbatim source excerpts on stdout. In its ten-task SWE-bench comparison it completed the same 8 of 10 tasks as the baseline, at lower cost, and the headline says about 30% lower cost. It requires Node.js 22 or newer, macOS or Linux, and a key for Vercel AI Gateway, TypeSafe, OpenRouter, or OpenCode Zen.

The README says a TypeSafe Jev model can watch the book and answer buy or sell about every 300 ms, then the bot posts a post-only limit one tick inside the touch. With no private key it dry-runs on the real book. The default model is a mock momentum heuristic; MODEL=jev and TYPESAFE_AI_API_KEY switch it to Jev.

The README describes a typesafe-ai skill you can install as a Claude Code plugin or with npx skills add. It is for designing TypeSafe workflows, finding current docs and cookbooks, and composing typed judgments in code. The listed license is MIT.

The README calls it a nano replica of Jev and says one shared checkpoint handles ViZDoom tasks plus Maze and Snake. For ViZDoom Basic it reports 128/128 test successes for NanoJev and 56/128 for the Jev run in that comparison. The repository includes an English README and a Simplified Chinese README.

The README says Jev takes unstructured state plus a typed question and returns a choice, a score, or a boolean, each with a confidence. It warns that a listing is not an endorsement: inclusion asks for a public, citable use of Jev for a typed decision, and the list does not review code quality, security, or whether a project runs. The README is generated from category files.

The README says you ask a choice, yes/no, or score question and get a decision with a probability. Its banner reports an order-flip rate from 0.230 to 0.073 with zero labels. It also says vLLM can serve every level, including L2, by reading a hidden state from a pooling server.

The README presents ollaya (Apache-2.0, ollaya.dev) as a local daemon that pulls open decision models (Winnow, Laya, and others) and serves them behind TypeSafe’s /v1/systemone wire format so the TypeSafe SDK works unchanged when pointed at Ollaya. Includes CLI, desktop, Docker, MCP, and a public bench. Not a competitor model itself.

The README says a Jev-like model takes a piece of text and N text options and does not write the answer word by word. It states that TypeSafe has not published Jev's design and that this repository is an independent starter with the same input and output shape. The included demos score Doom controller buttons from image patches and walk a chess controller.

The README says that since 3.2.0, reticle_verify can explore a page with driver jev, choosing among candidates enumerated from the DOM so the model selects and does not compose. Using Jev to route verification flows inside Reticle is described as a roadmap item that does not ship yet. SDK and adapters are Apache-2.0; the server is FSL.

The README describes Jev as TypeSafe's decision model: it returns a calibrated confidence and does not write text. Eleven skills ship as SKILL.md files, and the installer looks for Hermes, Claude Code, and Codex. The Hermes plugin uses public plugin seams so a Hermes update does not require patching Hermes core.

The README says jev() is a boolean SQL function, jev_prob returns a probability, jev_choice picks a label, and jev_score ranks ordered levels. Rows are packed at jev.batch_size (20) into one shared state. It links docs.typesafe.ai and pgjev.com. The license badge says PostgreSQL.

The README says Jev handles navigation, clicks, toggles, and scrolling, while Codex keeps text input, images, and the final check. Jev receives accessibility text, not screenshots. Install with npx skills add wy-coliney/jev-browser-use, using a TypeSafe key (TYPESAFE_API_KEY) or an OpenRouter key. It needs Node.js 22+ and Codex Computer Use. It reports about 5–10× faster browser operations in EZCollegeApp workflows, and lists Jev 1.13 input at $0.042 per million tokens with free output. MIT licensed, and described as an independent integration, not an official OpenAI or TypeSafe product.

The README says the catalog is community-maintained and not affiliated with or endorsed by TypeSafe AI. It says every entry names the concrete decision Jev makes and links to the strongest public evidence the maintainers found. The same README is offered in several languages and links to jevbest.com.

The README says TypeSafe's Jev answers 14 typed questions in one call, including which card to show and signals such as a video call or urgency. Dates, amounts, units, and math stay in deterministic code. It works fully offline by default with a keyword classifier; a TypeSafe key is optional and is read only on the server.

README: POST /v1/systemone on 127.0.0.1:8017, one binary, no Python. Release jevos-v5 (OpenVINO int8) plus GGUF on Hugging Face feder-cr/jev. Context 8,192 tokens. On a Core Ultra 7 255H it reports short/long median latency 30/132 ms. Scores are marked early. MIT.

README: serves Open-Jev, Valen, Laya, Tiny-Jev, Clef and more via `vllm-jev serve`; multimodal text/image/video demos; Apache-2.0. Not archived.

The README sits beside a chat window. Offline OCR reads the conversation, Jev judges intent and tension, and three reply candidates can be filled into the input. It never sends. Judgment uses OpenRouter typesafe/jev-1.13 or TypeSafe direct jev-latest; drafting is a separate model, default DeepSeek. Each analysis is seven Jev questions, a draft, then a Jev ranking. The judgment core comes from the Android jev-chat-JARVIS project. The project's own code is MIT; the Windows zip bundles PySide6-Fluent-Widgets, which the README says is GPLv3.

The README describes a local Bun server that translates state plus typed questions into a classification prompt and returns Jev-shaped choice/score/noul with confidence. It is wire-compatible with TypeSafe’s System One API (not logit-equivalent to OpenJev) and works with the TypeSafe SDK via TYPESAFE_BASE_URL. License MIT.

README: Node/pnpm app with PostgreSQL + SpiceDB; TypeSafe API key required for hierarchical beam search and passage usefulness scoring; no keyword/embedding fallback. Deploy to Render supported.

README: Claude Code skill or CLI; standard mode needs TYPESAFE_API_KEY (~1¢ Jev/site); optional --full DataForSEO. MIT. Jev judges page/site/keyword questions; code scores fixes.

The README says Jev is not a chat model. It takes unstructured state plus a typed question and returns a choice, a score, or a boolean, with a confidence. The homepage is generated from category files; the listed coverage includes 20 classification and routing entries, 30 agent-decision entries, and 37 infra, SDK, and integration entries. Inclusion is not an endorsement, a security audit, or proof that a project runs.

README: System-1 agent architecture radar. Submissions are GitHub Issues only; pull requests are closed. It lists TypeSafe Jev at 50–100ms with typed Choice, Score, and Noul. Live site at logicrw.github.io. MIT.

The README keeps orchestration in code and uses Jev for a Noul risk matrix, then Choice and Score file profiles, evidence selection, mechanism classification, severity, and conditional reviewer routing. Commands review a Git diff or a whole codebase and open a dashboard on 127.0.0.1:4317. It needs Node.js 24+, Git, and a TypeSafe API key. It calls the project an experiment: findings are review prompts, not proof of a defect, and it does not yet integrate compiler diagnostics or static analyzers. License MIT.

README: demos, workflows, and skills for coding agents. 14 recorded input/output pairs. Listed projects are not installed or tested by the repo, and alternatives are not official Jev. English and 简体中文. MIT.

The README says jev-claude and jev-codex launch the real upstream CLIs and keep their interface, tools, sessions, permissions, and authentication. Jev sends simpler work to a fast tier and harder work to a strong tier. In Claude Code, choosing another model pauses routing until Jev Router is selected again.

The README says you send shared context and a set of questions. The server reads the model's next-token logits and builds JSON for choices, rubric scores, or truth and support judgments; the model does not generate a JSON completion. A public demo API requires no login, limits context to 2k tokens, and is rate limited to 2 requests per second.

The README hands the next-click decision to Jev (TypeSafe System One). Jev picks an element, action, completion, and risk from text candidates. Codex Computer Use reads the interface and executes. Screenshots are not sent. npm run install-skill copies the skill to ~/.codex/skills/jev-cu. It uses TYPESAFE_API_KEY. The default is dry-run; delete, send, pay, authorize, upload, captcha, install, and system settings stop at confirm. The app allowlist is in scripts/policy.mjs. npm test stays offline; npm run p0 calls Jev. License MIT.

The README's opening line is that Jev gives software a typed judgment and the calling code stays in charge. It points readers to one documented call, live projects, a starter to copy, and independent tests. The page links a GitHub Pages directory for browsing the listings.

README presents awesome-jev as a Decision Atlas: saved HTTP 2xx link records and call-site citations, EN/中文 UI, JSON schema, and pattern/compatibility docs. It states counts are records, not independently tested performance.

README: eleven chapters, a translated doc site, and a 500+ file knowledge base. Offline examples run without an API key. Chapter 10 fine-tunes Laya with RLCD into a local Jev-compatible service. Python 3.10 or newer. README license is CC BY-NC-SA 4.0; GitHub license is NOASSERTION.

The README says Jev takes program state plus typed questions and returns constrained answers with probabilities. It favors public source code, concrete Jev usage, clear limitations, and reproducible evidence. A review dated September 20, 2026 added 20 source-reviewed items and put the community catalog at 155.

README covers uploading DiffusionGemma NVFP4 weights to GCS and deploying a prebuilt ghcr.io/taeold/djev-run image (or raw vLLM nightly) on NVIDIA RTX PRO 6000, with demo apps inspired by community Laya/Jev games.

The README says mu gives routine decisions to a judge so the big model keeps the work. Jev answers yes/no, choice, and score questions. A local judge (Laya) or any LLM can take a decision point instead. With no key set, the free Jev on OpenCode Zen answers. Hosted Jev is reached through TypeSafe, OpenRouter, the Vercel AI Gateway, OpenCode Zen, Cloudflare Workers AI, or any service that speaks the same protocol. In the repository's replay, goal-aware test-log selection by Jev cut 40.2% on 29 tuned goals and 46.4% on 9 held-out goals, and lost none of the required lines. The agent packages are MIT; the desktop app is Apache-2.0.

The README lists eleven tools: verify, screen, noul, find, rerank, classify, decide, compare, extract, review, and gate. It says each judgment comes back typed, with probabilities and, for most tools, a confidence score, in roughly 150 to 500 ms. Examples include checking claims against cited sources and screening a fetched page before it enters context.

The README says you get links and snippets with visible relevance scores, not generated answers. Google, DuckDuckGo, Yandex, and several vertical engines run concurrently. It says this is an independent project built by Search1API, not an official TypeSafe product, and that Jev Search does not store queries or result clicks.

README: Claude/Codex skill; Pokémon example improved Eval win rate 25%→75% after reflection; median decision 568ms. Uses typesafe-ai/jev via Vercel or TypeSafe. Python 3.11+.

The README says you give the Python library, CLI, or local app a PDF, DOCX, or PPTX and natural-language category rules. LiteParse extracts complete page text locally; Jev predicts one category, or the boundaries between component documents. Optional LlamaParse tiers add cloud OCR. On a 40-document pilot both engines classified 40/40 originals correctly; Jev split 7/8 packets exactly, with median decision times of 138.6 ms for classification and 209.6 ms for splitting. A TypeSafe API key is required, and local OCR does not make inference offline.

The README lists 170+ graded entries across System One & Jev, open source, built-with-Jev, benchmarks, commentary, and lineage, with a site at omnijev.github.io/awesome-jev-gallery/. CC BY 4.0 style badges; PRs welcome.

README frames an unofficial, CC0 list sponsored by AY Automate: top demos with author/likes/reach cards linking to original X posts, plus docs for metrics. Distinct from generic awesome-jev name lists by focusing on use-case cards.

README: prefill-only logits for Choice, Score, and Noul; Box emits normalized boxes (v0.2.0). Backends are SGLang, Transformers, and MLX. POST /v1/systemone. Python 3.12+. Independent of TypeSafe. Apache-2.0.

README: models, subagents, skills, MCP tools, CLIs, and plugins share one contract. Decision-only by default. Node.js 20+. On 10 Toolathlon tasks, Jev serial hit 38% at 1.58s and about $0.0058 per 10 tasks; DeepSeek V4.1 Flash hit 24%. MIT.

README: no ADB. Recorded Uber task is about 21 seconds for 9 actions; a completed booking is not shown. Studio at 127.0.0.1:3040. API keys stay on the server. Needs Mobilerun and TypeSafe keys. MIT.

The README presents Open-Jev as an independent implementation inspired by TypeSafe's Jev: you supply context, questions, and candidates and get typed probabilities without autoregressive answer generation. It ships Open-Jev-2B, Open-Jev-9B, and Open-Jev-27B-v1.1 (LoRA adapters + decision head over pinned Qwen bases), public datasets, a text/CSV workbench, game demos, Docker, and benchmark docs. It reports 197/231 on public JevBench for 27B v1.1 (Hard 80/111) and states it does not reproduce proprietary RLCD, private weights, or TypeSafe's advertised speedups.

README: one Jev request (jev-1.13.0) per partial transcript, about 250–350 ms, with typed questions for intent, target, and whether to act. Jev does not write the typed text; code copies a span it picked. Node 20 or newer. About $0.0002 a call. Listens on 127.0.0.1. MIT.

README: open-source packages including agentrun-dsl, agentrun-jev, pi-vision, pi-browser; support demo uses Jev to check answers before return/escalate. Node 22.19+; packages on npm @beta.

The README says it is for comparing TypeSafe with an LLM on cost, speed, and intelligence. Optional extras install OpenAI-compatible, Anthropic, or Gemini providers. Each call names a provider and model, and the client can request structured outputs plus a probabilities or discrete answer mode.

The README says Unclutter is a WXT extension for Chrome, Chromium, and Firefox. Jev classifies nonessential elements through Vercel AI Gateway or TypeSafe AI directly (jev-latest on POST https://api.typesafe.ai/v1/systemone). Choices are keep, ad, promotion, newsletter, social, cookie, or uncertain. Page text is untrusted evidence. Where TypeSafe returns it, selected-choice probability and confidence must both be at least 0.9 or the element stays visible. The extension stores and reapplies local hiding rules by page template, and saved templates work offline. License MIT.

README: the 2026-10-28 live note lists 801 entries and 26 implementation languages; the badge says 20 languages. Picks are ranked by evidence grade and stars, and the README calls that a ranking, not an endorsement. README badge says MIT; GitHub license is NOASSERTION.

The README describes fast, cheap browser use with TypeSafe's Jev. It drives a real headless browser through an MCP server, the CLI, or the npm package @jkudish/jev-browser. Jev picks one action per step from the page's clickable, typeable, and selectable elements, and scores how likely the goal is met or the run is stuck. Code owns budgets, recovery, and stop gates. One reported run navigated Wikipedia from the Coffee article to Espresso in about 4 seconds for $0.0016. It requires Node.js 22 or newer. The license is MIT.

README: a website for stock research, an expert roundtable, strategy screening, and paper trading. Research covers mainland China, Hong Kong, the US, Taiwan, Japan, Korea, the UK, Canada, Australia, India, Germany, and France. Paper simulation supports the first six. Optional Jev: a separate TypeSafe key under Settings, Models and runtime, then JEV Decisions only on a new strategy. Jev returns buy, sell, or hold, plus probabilities and confidence, and does not write the research report. Chat and stock-scope selection still need an LLM. Setup notes are in docs/jev-trading-decisions.md. MIT.

The README installs it with npm install -g @lakeday/perch, then perch login and perch scan. Scan output includes severity, confidence, and a problem label. It says decisions are cached, the first $5 on Perch Cloud is free, and unchanged code is free to rescan. perch setup writes skills for Claude Code, Codex, Pi, and Cursor. Any System One endpoint works; the table also lists other Jev-compatible endpoints.

The README describes EmbodiedJev (行知): MuJoCo + Franka Panda tasks (transfer, stack, obstacle) with observe→decide→execute loops. Model slots include TypeSafe Jev via the official System One API, Claude, OpenAI-compatible APIs, and local MiniCPM5-2B; Jev receives structured text, not camera images. There is a live demo site, comparison runs, and MIT license (Panda assets Apache-2.0 upstream).

README: boards at benchmarkheaven.com/jev-models, independent of TypeSafe. Published release v1.6.1 (2026-10-06). Capability Score averages Intelligence and Calibration inside a cost cap of $0.0646 per 1,000 decisions and a 1.23s latency cap. Not the metamorphic benchmark at jevbench.github.io. MIT.

README: wrappers jev-codex, jev-claude, jev-opencode, jev-kilo, jev-gemini, and jev-devin. Node.js 22.15+. Jev via TypeSafe, OpenRouter, Vercel AI Gateway, or OpenCode. If Jev fails, the request goes straight to the LLM. Listens on 127.0.0.1. Independent of TypeSafe. MIT.

README: experimental CLI from Sutro. New runs default to TypeSafe Jev 1.14 with TYPESAFE_API_KEY. Other backends are Vercel, Cloudflare Clef, Perplexity, OpenAI Decisions, Liquid, and OpenRouter. Each round measures uncertainty, asks you to label ambiguous rows plus a random audit sample, runs GEPA, and shows a diff you accept, reject, rewind, or resume. A higher training score never accepts a proposal automatically. Task types are binary, multiclass, multilabel, and an ordered score. Commands include jeva and jev-align. Saved functions can capture production examples and publish to ai-functions.dev. Squash mode is a label-free uncertainty demo that cannot be published. Sutro is not affiliated with TypeSafe AI. Python 3.11+. Apache-2.0.

The README installs it with uv add typesafe-sdk and shows a synchronous TypeSafeClient used as a context manager, calling system_one with a Choice question. An optional http2 extra enables HTTP/2. It points to the TypeSafe docs and the Python SDK docs.

The README says to install @typesafe-ai/sdk on Node.js 20 or newer, set TYPESAFE_API_KEY, and call client.systemOne with helpers such as choice. Answer types are inferred from the questions you pass. The package includes ESM, CommonJS, and TypeScript declarations.

The README describes a self-hosted, versioned skills library (React, Bun, Hono, PostgreSQL, MIT). It offers an editor, profiles, revocable client keys, HTTP MCP, and a stdio bridge. Optional task-aware Jev recommendations use your own OpenRouter, TypeSafe AI, or Vercel AI Gateway key. TypeSafe calls POST https://api.typesafe.ai/v1/systemone with model jev-latest. OpenRouter uses POST https://openrouter.ai/api/alpha/decisions with model typesafe/jev-1.13. Without a saved key, or on failure, recommendations fall back to deterministic search. Skillbox does not execute uploaded skill code.

The README says you send TypeSafe's System One model a state and typed questions and get typed answers with probabilities in about 300 ms. It arranges thirty concrete uses into ten levels. Levels 1 to 5 call Jev from plain code: a noul gate, choice, composite score, confidence gating, and routing. Levels 6 to 10 put Jev inside the pi coding agent, first as hooks the agent never sees, then as tools the agent chooses, until the agent writes the questions. It says a million yes-or-no calls cost $3,500 on an expensive SOTA model and $16.80 on Jev. The offline suite is 201 tests on a deterministic mock; levels 1 to 5 still run without a key.

The README frames Jev as TypeSafe's System One model for probability-based yes/no, choices, and scores. Sections cover getting started, demos with creator X links, SDKs and skills, browser and desktop tools, agent tools, apps, games, and independent models. It warns that listing is not a security audit or runtime endorsement, and points to contribution and curation docs.

README: agents, skills, rules, and MCP tools for Claude Code, Codex, Copilot, Cursor, and others. Install with npm i -g aiwg, then setup, review, and apply. Optional Jev decision offload needs an explicit opt-in. Optional Cockpit uses a Docker or KVM sandbox you host. MIT.

The README presents Jeva by Qi Li and Xinchao Wang (NUS) as a system one model like Jev with native design: independent language encoding of state and options, a compact decision stack, permutation symmetry, variable candidate sets, null awareness, and two-level reuse. It links Hugging Face LIQIIIII/Jeva-4B, local inference examples with Choice/Noul/Score, and Apache-2.0 licensing.

The README describes calibrated typed answers in one forward pass, serving via PyTorch or llama.cpp, a TypeSafe-compatible API shape, and documented training data plus Hugging Face checkpoints. License Apache-2.0.

The README describes awesomejev.com with 1,500+ entries across official, SDKs, integrations, agent tooling, apps, games, demos, and benchmarks. Stars refresh daily; not affiliated with TypeSafe. CC0-1.0.

The README lists twelve features off by default, a separate Jev endpoint/key, Cordis/DSH extension points, and positions the project as a community extension for DSH 0.1.7-rc.2. License MIT.

The README says Jev chooses each next operation — search, open a particular post or profile, read comments, an explicitly requested TikTok media download, or finish — and the local socai CLI executes that command in your real Chrome. Targets come from captured results or explicit URLs; unsupported and low-confidence decisions do not run. A recorded Instagram loop captured four records in 63.969 seconds after two searches and one post-detail read. It needs Node 20 or newer. OpenRouter is the default decision provider; a configured Kev or Simple Jev endpoint keeps decision requests on loopback.

README presents Awesome Jev: typed decisions from System One, installable as `npx skills add valentynkit/awesome-jev-typesafe`, with projects.json and a Vercel site. License CC0-1.0.

README: beta Python package (3.13 or 3.14). Local or cloud browser. Recorded local Chrome demo: 13 steps, 20.9s, $0.0034. Head-to-head on 46 tasks times 3: 99.2% versus hosted Browser Use 97.8%, median 16.3s versus 16.1s, $0.0256 versus $0.2840. Those C1 figures await maintainer approval. MIT.

The README says the skill covers Choice, Score, and Noul question design, state structure, composing answers in code, confidence thresholds, and diagnosing questions that answer wrong or with low confidence. Install it as a Claude Code plugin, with npx skills add dbreunig/building-with-jev-skill, or by copying skills/jev. It says the guidance draws on the TypeSafe docs.

README (Apache-2.0, Python): asks “which page answers this?” via Jev Choice; hierarchical descent for documents that outgrow one context window. Links TypeSafe docs and PageIndex.

The README presents NeuroLink (@juspay/neurolink, MIT) as Juspay’s pipe layer connecting providers for generate, stream, and decide. decide() uses TypeSafe Jev for boolean/choice/score (~400ms). MCP-native; powers internal products. Many provider backends.

The README presents an unofficial skill (SKILL.md, patterns, prior-art shapes) installable for Claude Code, Codex, Muse, and similar tools. It cites published evals scoring about 0.96 versus 0.77 for the official skill and states it is not endorsed by TypeSafe. License MIT.

README (MIT): In Anthropic’s Claude plugin directory and on the MCP Registry. Needs a TypeSafe API key; optional OpenAI/Anthropic writer. Async Stop hook so a slow Jev call does not block.

The README calls this an unofficial operator-level companion for TypeSafe Jev: System One, not a chatbot. It surfaces Choice, Score, and Noul, plus parallel fan-out (many questions, one state, one call) and the docs-only details that change how you build. Local surfaces include a smart-home demo and an operator lab on 127.0.0.1:7872, with fixtures by default. packages/js is a TypeScript harness CLI (npx jev route, npx jev guard) for agent loops. It says this is not an official TypeSafe product and does not replace typesafe-sdk. The license is MIT.

README: `uv tool install jev-grep` (the command is jgrep). Each line is a yes/no sent to TypeSafe, OpenRouter, or a System One gateway. It works in pipes and on `tail -f`. The README measures 994 Hacker News titles. License MIT.

The README says the model prefills a context once, expands that KV cache across the option batch, and scores every option in a single forward pass, with no decoding. The score is the log-probability of the option tokens; a softmax gives a probability per option. POST /v1/systemone takes a state plus choice, score, and noul questions. The Doom demo runs ViZDoom headless, describes each frame as a line of text, and ranks the action menu with one /score call or one System One choice. On the docs' quick-start request, Gemma 3 4B zero-shot picked the same department as the published Jev numbers but scored frustration at 2.00 where Jev scored 1.04, and returned an urgency noul of 0.005 where Jev returned 0.999.

README: one API takes state, question and options and returns a choice with probabilities. Covers data prep, SFT/RLCR training, serving, and agent-harness demos. Released models include JevAny-Qwen3.8-27B; Apache-2.0 code.

README (GPL-2.0): 16,150 decisions, median ~0.4s, no scripts/cheats; landing at jev-pokemon.vercel.app. You need your own legally obtained ROM.

README: Claude (via MCP) states outcomes; Playwright acts after ~300ms Jev rounds (element/action/value/done/error/irreversible). 40/42 live-site tasks correct in latest run; median ~5× less page tokens vs Playwright-MCP-style loops. Unofficial; MIT.

README (MIT): `jevlint init` writes jevlint.json, `doctor` checks credentials, `check .` runs. Needs TYPESAFE_API_KEY. Prebuilt binaries for linux/macos/windows or `go install`.

README: deterministic eligibility rules run before semantic ranking; routing always calls TypeSafe; local-first config; supports agent/claude/codex/opencode CLIs.

The README describes a py2app Mac app where one Jev call asks every action question at once (category, compound intent, app, volume, etc.), then runs AppleScript/shell. Whisper (local faster-whisper) transcribes; Fish Audio S2.1 Pro speaks scripted replies with emotion tags; an LLM via OpenRouter answers only when Jev says the utterance is a question. Dictation can optionally leave the Mac via OpenRouter/OpenAI. Requires TypeSafe, Fish Audio, and OpenRouter keys; Accessibility/Microphone permissions; Sequoia/Tahoe.

README explains structured reads on a diffusion canvas (seed/pin/read-only), question types, depends_on/ask_if, and a Jev-compatible /v1/systemone API built from vLLM PR #57250. Apache-2.0.

README describes single-pass choice/noul/score, ECE calibration fixes in v1.4, Hugging Face weights heman10x/rlcd-modernbert-151m, and an in-browser ONNX/WebGPU demo. Inspired by TypeSafe Jev; reports gaps vs hosted Jev on external evals.

README: independent list. Beta UI at jevlist.ai. The skill installs with npx skills add AppitStudio/awesome-jev --skill awesome-jev-guide on Node.js 22+. Offline examples need no API key. GitHub license is NOASSERTION.

README: pip install jevals; works with TypeSafe/Vercel/OpenRouter Jev and local Kev/Laya; eight checks per request example (~$0.00006, 0.33s); MIT; not archived; ~105 stars at intake.

README: install the scoped package @nassim-arifette/jevgrep. The unscoped jevgrep name on npm is a different project. The command is still jevgrep. A question such as where session expiry is handled returns verbatim excerpts as path:start-end. The MCP tool is semantic_search_code, for Claude Code, Codex, and other clients. Nothing is sent until you authorize the repository. On 55 questions over six repositories, the README reports R@5 of 0.877 on Python and 0.827 on Go/Rust, at about $0.005 and 4 seconds, against a whole-repository model that costs more. With the judge swapped on 65 searches, Jev 1.13/1.14 is the only one that passed both the no-answer and false-premise checks in that write-up. Those two checks rest on 6 and 14 questions, and the README says to treat small gaps as noise. Providers are TypeSafe with jev-1.13.0 pinned, Vercel AI Gateway, and OpenRouter. Node.js 24. MIT.

README: three packages. jevcore holds the decisions and imports nothing from DeepSeek Harness or Cordis. jevcore-dsh is the harness plugin: one service, three tools, two opt-in gates. jevcore-mcp exposes the same three tools over stdio. The default provider is an offline mock. A live call needs provider: live and a resolved credential. Startup logs name egress per feature: jev_ask, jev_rank, jev_check, plus opt-in safety and context gates. Redaction is best-effort and can miss an unrecognized secret. If the judge cannot answer, gates default to ask rather than allow. The context gate fails open. No tool lets the model change gate config. Core and MCP need Node >=20. The DSH package tracks the harness and needs Node ^22.19.0 or >=24. Tests need no network. Part of a PerryLink DeepSeek Harness plugin family whose roster is 95. Apache-2.0.

The README says it keeps the original post, author, engagement counts, a Chinese reference, quote relationships, and external links, and that it lists 202 community cases with search, filters, and several sort orders. The stack is Astro for static pages and React for the wall. It states the project is unofficial and not affiliated with JEV or TypeSafe.

The README says it replaces Open-Jev's model forward pass with hand-written CUDA kernels (including Gated DeltaNet and tree attention), a prefix tree that computes shared prompt text once, tuned matmuls, and CUDA Graphs, while keeping the same request format as `python -m jev.server`. On one B300 in bf16 it reports example-request forward+head latency of 17.3 ms vs 103.7 ms for Open-Jev+FLA (about 6×) and JevBench mean per-task latency 42.0 ms vs 258 ms, with accuracy essentially unchanged (197/231 vs 198/231). Scope notes: specialized for Open-Jev-27B-v1.1, tested only on B300, ~98 GiB GPU memory, bf16 only.

README: Jev does not generate text; typed questions return in 70–500ms with a confidence. Input is $0.042 / MTok; output is not billed. It flags the 193× faster figure as TypeSafe’s own upper bound, and an independent phishing check at 62.6% versus 91.8% for two regex rules. Unofficial. CC0-1.0.

The README turns TypeSafe Jev answers into Home Assistant entities you can automate on. Questions become sensors: a probability, one of your options with its distribution, or a number on a scale. Automations can call jev.noul, jev.choice, jev.score, jev.ask, and jev.box; camera or image entities and snapshots can go in beside the state, and jev.box finds where something is in a picture. A conversation agent routes Assist commands through the same model. It is added as a HACS custom repository and requires Home Assistant 2026.9 or newer. Documentation is at jev.cdevries.dev. The README says it is not affiliated with TypeSafe. The license badge is MIT.

The README describes Mica (Apache-2.0, HF sky7350/Mica-v0.5-4B) as a 4B decision model serving noul/choice/score over long inputs via an HTTP server (INT8/GGUF). Includes JDI/JevBench-style charts. No chat generation.

README documents typesafe_noul/classify/score/ask and *_many batching, API-key file handling, mock_response for offline tests, and a NYC 311 demo. Supports PG 15–18; MIT; not affiliated with TypeSafe.

README: needs TYPESAFE_API_KEY; crawl/scrape/map tools; Jev decides scores and does not write text; Apache-2.0; not archived; ~52 stars at intake.

The README says you write the decision once and run it on TypeSafe Jev, local Reflex, any compatible /v1/systemone endpoint, or a custom SystemOneProvider. The core owns typed builders, HTTP for that endpoint, fail-closed protocol validation, and deterministic mock providers. It does not own routing, confidence thresholds, retries, or fallback. A Pi integration is included.

The README describes Jevstiller (Apache-2.0) as a proxy that trains from Jev probability traffic so repeated classifications run locally in ~15 ms; uncertain cases and audit stay on Jev. Banking77-style benchmarks are documented in the README.

README: criteria types include boolean, numeric range, enumerated tag, structural path, and reference expression. The citation ledger stores the location and the observed value. Dry-run, side-by-side diff, and preset packs. Page at chuloontop4-code.github.io/jev-instance-review/.

The README presents burnigtm/jev-mcp (MIT) as an MCP server with tools such as jev_step, review, verify, gate, screen, and rank for coding agents. Distinct from the already-listed jkudish/jev-mcp.

README: an open-source paper-trading research app with TypeSafe Jev decisions, a 3D command center, model pets, and an offline demo that needs no API key. In the author's unreleased paper test from 2026-10-20 to 2026-10-30, Jev picked one candidate or waited across 1,604 simulated trades held about 3 minutes: win rate 11.6%, profit factor 0.11, average return before costs +0.005% per trade, and a loss after about 0.14% in fees and slippage. Confidence did not track outcomes. This open-source build uses the same kind of choice between a trade plan and WAIT. Trades go through an in-app PaperBroker; there is no private exchange order path. Python 3.11+. MIT. The README says it is not a TypeSafe product and not to use it for real-money trading.

The README compares Jev 1.13, GPT-6 Astra, and GPT-4.1 mini driving an xArm7 with shared Cartesian increments and physical feedback. One seed-0 trial per controller is published with trajectories, costs, and a local replay app; Jev placed the apple with far lower API cost and wall time than GPT-6 in that recording. No API key is required to replay the published runs.

README: a fork of browser-use/jev-ultrafast used as a test harness. Jev Choice is validated against the observed candidate elements (`validate_choice`). Allure reports include probabilities. Natural-language cases run under pytest. License MIT.

README: drop-in proxy for Codex, pi, mini-swe-agent, DeepSeek Harness; Terminal-Bench results claim similar success with 28–64% lower LLM cost using Jev as the decision model. MIT.

The README describes RoboJEV as a small robotics lab: JEV gets structured simulator state (not images), picks an immediate intent, then XYZ directions and a gripper command; a Cartesian controller executes with real MuJoCo contacts and independent physical success checks. Demos cover pick & place, push, stack, peg insertion, and gate pick & place, with evaluation docs and an interactive showcase. License Apache-2.0.

README covers typesafe-java-sdk, typesafe-spring-ai (JevJudge, advisors, document filter/reranker, JevToolIndex), Boot starter, BOM, and offline tests. Apache-2.0; Java 17+.

README says Lichen serves the same typed answers so existing Jev clients work unchanged; reports 204–207/231 JevBench vs 200 for Jev 1.13 and ~56 ms median on one 24 GB laptop GPU via vLLM. MIT.

README: point a hashed YAML recipe at an OpenAI-compatible server that returns logprobs (vLLM, llama.cpp, or a raw prompt when the server only gives prompt_logprobs) or at a small in-process model. One state, then typed choice, score, and yes/no questions. No generation and no parsing. jevify serve speaks TypeSafe's Jev API so the unmodified typesafe-sdk can call it. It binds 127.0.0.1 unless you pass a host, and a non-local host needs JEVIFY_API_KEY. Each answer adds an x_jevify block with the readout method, cached tokens, latency, and recipe hash. The CLI also probes the deployment and writes eval scorecards. It owns no weights and trains nothing. The README says its frozen suites rank models and do not measure calibration, which is why calibrate refused to write a table for them. Python 3.12+. MIT.

The README presents hermes-nerve (MIT) as a supervisory plugin for Hermes agents: ranking, verification, token-aware oversight, and an opt-in tool gate powered by TypeSafe Jev or open Laya/OpenJev backends. Dev notes cover shadow modes and completion gates.

The README describes jev-axi (npm, MIT) as a CLI for pick/rate/check/rank/triage/guard plus `jev-axi hook pre-tool-use` for Claude Code or Codex Bash safety. Routine commands can be decided locally; risky ones call Jev (~400ms).

The README reads the turn transcript locally. It spends one Jev call, four questions, only when files changed and no check has passed. If the closing message is an unverified done, the turn does not end. Error paths let the turn end. It reports AUROC 0.976 on 100 labeled stops, against 0.777 for wording alone, a median of 346 ms, model jev-1.13.0, and about $0.00005 per call at $0.042 per million input tokens. Install with the Claude Code plugin marketplace command for valentynkit/jev-belay. A turn with no file edits never reaches the question. License MIT.

TypeSafeAI community repo (not official product SDK). Research-stage contract: nothing applies patches or grants permission. Offline verify/bench fixtures; optional Next.js demo. MIT; TypeScript; Node 22+/pnpm.

README describes the most rigorously verified independent tracker of the Jev ecosystem, with graded registry data, casebook, and docs. Last scan noted 2026-10-25.

Created 2026-10-08. README: Stage1 Jev scores templates 0–4; Stage2 runs Nuclei in that order; prioritisation not filtering.

The README describes skimmer as the chunk filter from webctl, using Jev to ask whether each ~2,000-character chunk helps with a goal and dropping the rest to save tokens. Install paths include Homebrew, apt, Scoop, go install, and release binaries; auth stores a TypeSafe key under ~/.config/skimmer. License is MIT.

README (MIT, created 2026-10-03): allow when the call serves the request (≥50%) and every risk check ≤10%; deny when risky and unrequested; else defer. Shell-aware blocklist in front of Jev. Claims ~2× faster than the built-in classifier on decided calls.

README documents @xstate/jev pattern: Jev never writes actions, only chooses among machine-accepted events. Matching site case @DavidKPiano already exists; repo was not featured.

The README presents Jev-Engineering/cookbook (MIT) as ~50 of 100 planned Jupyter recipes for Choice, Noul, and Score, offline-first with optional live API runs. Python 3.10+; provenance notes for synthetic vs recorded metrics.

README says this is not an official TypeSafe product. Five sections: language and data, agents, governance, simulations, and an arcade. Next.js on Node.js 22.3+; controls labeled Live Jev need TYPESAFE_API_KEY. MIT, extending nickthompson480's examples playground.

README asks 14 questions per review: a Noul mention probability and a Score rating for Camera, Battery, Display, Design, Performance, Build Quality, and Value for Money. A topic is kept only when mention probability is at least 0.5. The sample CSV has 50 synthetic reviews. Requires TYPESAFE_API_KEY.

README: checkpoints Qev-0.8B, 2B, 4B, and 9B on Hugging Face under AustinFu, plus training data. Python 3.12, PyTorch 2.8.0. scripts/smoke.py runs on CPU with a tiny random Qwen and no download. Apache-2.0. Badge says built on Qwen3.5.

The README says you can ask for a drawing, a sound, a report, a data study, a proof, or software. Jev answers structured questions: it helps choose an agent or recipe, approve intermediate plans and results when the evidence permits, and avoid learning equivalent recipes twice. The run's models still plan, write code, and explain refusals. Uncertain or unavailable answers go back to those models, and final delivery acceptance stays independent of Jev. Jev is on for every organisation when the host has TYPESAFE_API_KEY, unless ATOMA_JEV=0. Decision context, including task text and evidence excerpts, is sent to TypeSafe. The hosted app is atoma.run. License AGPL-3.0. The README says it is under active development and has not been independently audited.

The README presents Flide (Apache-2.0, flide.org, PyPI) as an inference server for decision models: a request holds a state and typed questions; Flide forks the state into every question in one forward pass and returns probabilities over /v1/systemone. Serves chat models, OneJev, and Open-Jev adapters.

The README installs Python 3.13+ with uv, sets TYPESAFE_API_KEY, and runs workflows against the default model typesafe:jev-1.13.0. The workflows are invoice processing (150 cases), customer service (204), agent-trace observability (111), and security incidents (240). Scores use exact_actions and primary_action. Inputs and labels come from the Hugging Face WorkflowEvals collection. The code is Apache-2.0; datasets are licensed separately.

The 29 October README compares rerankers on 1,044 XQuAD-TR questions and 240 passages with frozen candidate text and order. It distinguishes batch from pointwise scoring, records per-question artifacts and costs, and compares answer models on identical evidence. The small, reused corpus limits general conclusions.

README: seven selectable pipelines (BM25+Jev default, agentic lexical, embedding hybrid, multi-round agentic hybrid, taxonomy-routed, Jev Passage Gate, hierarchical Line Search). Cited answers; benchmarks/site. MIT; Python 3.9+.

README: personas such as Bekasi mothers, ojol drivers, students, buzzers, and news accounts are judged by TypeSafe Jev on whether they stop scrolling, what they do, and where they stand. Results are compared with real comments from cases such as Tapera, the 12% VAT, UKT tuition, and free school meals. The flow retrieves nearby cases in data/library, Jev judges the first-circle audience, then two rounds simulate the post and the influencers' takes across niche, busy, and viral reach. A post can be text or an image judged directly by Jev. Characters are weighted representatives, not a tunable headcount. Python 3.11+ with uv; the page uses a key the visitor types and sample runs need no key. A backtest on 16 YouTube cases reports a mean sentiment-mix gap around 0.15. MIT. Demo at moddestlab.com/netizen.

The README installs jev-opus and runs Claude Code on claude-opus-5-5. The TypeSafe Jev reflex picks the effort level when a prompt arrives and again after every tool batch. A failing check raises the next step; a passing check steps it down. Effort is a per-message statement, so the prompt cache stays intact. It accepts a TypeSafe key (apikey_…) or an OpenRouter key (sk-or-…); without a key it uses local heuristics. The default range is low to high. It says it is not affiliated with Anthropic, TypeSafe, or Astra-Ares. License MIT.

The README says Jev answers in roughly 70 to 500 ms with a typed answer and a confidence score, through OpenRouter's alpha Decisions API. It is not an LLM. One shared decision contract covers OpenCode, Claude Code, Hermes, and pi, so each harness gets the same answers. OpenCode install is bunx jev-for-all install, which asks for an OpenRouter key. The README reports skill routing on 64 real requests against a 22-skill roster: 0 wrong picks, an 85.9% hit rate, about $0.005 for a full run, and about $0.0001 per decision. License MIT.

The README covers go install and GitHub Action setup, piping state into noul/choice/score, and an example PR-risk workflow. It is unofficial. License MIT.

README: a local loopback gateway for Codex, Claude Code, OpenCode, Kilo, Gemini CLI, and Devin. Jev selects one tool and can fill closed-set arguments such as enums and booleans; the session model fills open-ended arguments and writes the final answer. If confidence is low, Jev fails, or the request is unsupported, the gateway normally forwards the request unchanged. An optional advisor receives a read-only request without tools and cannot call tools or change the response chain. The default failure policy is fail-open. It listens on 127.0.0.1. Hosted Jev needs an API key; the README says the project is independent and not affiliated with TypeSafe. Node.js 22.15 or newer. MIT.

The README describes an experimental v0.1.0 vision front-end that uses the official typesafe-sdk with Florence-2 and tracking, demos multi-object risk in one call, and is MIT licensed.

README: a curated list of the TypeSafe Jev / System One ecosystem. It covers official SDKs, agent skills, browser and computer-use demos, MCP connectors, routers, and community awesome-lists. Independent open-source typed-decision alternatives are listed separately and are not presented as official or drop-in compatible. The site at awesomejev.cc groups GitHub projects by primary use and presents Jev news separately. Project data is data/github.json and news is data/news.json. The README badge shows 3056 projects. Sections named in the contents include agents and automation, browser and computer use, SDKs and integrations, developer tools, research and evaluation, learning, project directories, apps and demos, and open-source alternatives.

The README documents npm package @hazymoon/jevwright on Playwright: Jev finds controls once; code decides pass/fail; AI runs can use OpenRouter or Vercel AI Gateway. License MIT.

The README says each step is one decision by TypeSafe Jev over the page's controls, and that there is no LLM in the loop by default. Each step is a single Jev choice, about 300 ms, with no text generated and no screenshot sent. On the e-shop demo, 20 actions take about 12 seconds with Jev deciding every step; a saved scenario replays the same 20 actions in about 4 seconds with no step decisions. The caption on the demo lists 9 actions in 6.7 seconds, with Jev's cost for that run, review included, at $0.00054. It needs Node.js 22 or newer, Google Chrome, and a TypeSafe API key. The listed license is Elastic License 2.0.

The README says you write browser tests in plain English and keep TypeScript and Playwright for the rest. Each ai(...) sentence is one step with no selectors. Sedum uses a decision model for bounded tasks such as finding the element a sentence refers to and judging whether a claim holds. TypeSafe Jev is the default; Cloudflare Clef is an opt-in text provider. Both return probabilities, not free text. Clicking, typing, waiting, verdicts, and exit codes stay on Playwright. It needs Node.js 20.19+ and TYPESAFE_API_KEY. Status is pre-alpha (sedum-cli on npm). License MIT.

KAUST paper and code (arXiv 2610.18272). README TL;DR: single-LLM research agents spend the same heavy compute on every step; JevGPT uses TypeSafe Jev as a fast System One to inspect sources in parallel while a slower System Two plans. Ships runtime, frozen configs, evaluation scripts, and Hugging Face run trajectories. Apache-2.0.

README: two fresh Survival Normal runs killed the Ender Dragon (about 107.2 hours with 81 deaths, and 150.1 hours with 95 deaths). About 25,700 Jev calls on the way to the first of those wins, about 0.2s each, about $4.30. Code lists up to fifteen options; Jev only picks. MIT.

The README package is @typesafe-ai/n8n-nodes-typesafe-ai. Evaluate adds Choice, Score, or Noul answers to each item. Route sends an item out from one question, including a confidence fallback for Choice. The example routes a support ticket to billing, tech support, or sales. The API key comes from the TypeSafe console. Jev is described as the flagship System One model. Tested with n8n 2.40.

The README frames question design as the prompt engineering of typed decisions for TypeSafe Jev (Choice, Score, Noul). It collects working patterns and anti-patterns across nine categories including embodied and multimodal notes, with a full Chinese translation. License badge shows CC0.

README: unofficial Java 17+ client (Jackson only) with Noul, Choice, and Score Asks in one systemOne call, plus a Spring Boot starter. Maven Central 0.6.0; default model jev-latest; MIT; not affiliated with TypeSafe.

README: bilingual scored runs across Jev, Clef/Clef-flash, Laya, Kev, Eikos, Jebadiah, Mapika Decider, Simple-Jev and GLiNER; reports accuracy, cost and latency with archived raw responses. Not an official vendor benchmark.

README: given an image, JSON state, and a typed question (noul, choice, or score), it returns a probability for every allowed answer in one forward pass. Apache-2.0 weights on Hugging Face. On 2,360 held-out questions it reports 80.6 versus Imajev-4B, H2O-Lightning-4B, and Jev-Vision.

README: optional router over existing Codex login; classifies fresh instructions once; falls back when TypeSafe is down. MIT; JavaScript; Node 24+.

README: reads stdin, asks a Jev-style classifier a yes/no question, and prints the text only if P(yes) clears a threshold (default 0.5). Put a command after -- to run it only when the gate passes. Providers: systemone, cloudflare, openai. Needs JEV_API_KEY from TypeSafe. Cargo install from the repo.

The README says tinycomputer is a Rust TinyBus module. It drives desktop apps and a real Chrome browser. Every choice about what to press comes from Jev, which answers small closed questions (yes/no, scale, or which option) with a probability and does not write text or plan. The harness reads the screen as named controls, acts, checks what changed, and can undo a worse click. Safety rules are code: page text is data, not instructions, and it stops at payment. Without a jev config, only the primitives work. License GPL-3.0.

The README presents jev-layer as an npm-installable MCP/CLI layer for Hermes, OMP, Codex, and generic hosts. Jev never executes capabilities; optional surfaces cover supervision, model routing, shadow compaction, browser fast-path, and Jev 1.14 vision/computer-use with fail-open defaults. License is MIT.

The README describes jev-devtools (npm 0.4.1, MIT, experimental) as a React drawer plus server adapter that captures Jev calls through its own client. Works with React 18/19 and Next.js App Router; API keys stay on the server; capture is opt-in and off by default. Requires Node 22.12+ and @typesafe-ai/sdk.

README: zero-dependency plugin. Jev answers questions such as whether a command is destructive or the request is fully done; also automatic effort, subagent routing, and a false-claim detector. About 400 ms per check; six days of daily use cost the author US$0.07. MIT; not affiliated with TypeSafe or Anthropic.

README documents crates.io package typesafe-ai-rs targeting official Python/JS SDK 0.6.0 parity, with retries, cancellation, and HTTP metadata. License MIT.

The README says PageGrade grades readable page sections with TypeSafe AI Jev through Vercel AI Gateway. Each section gets ten rubric scores (clarity, concision, specificity, explanation, usefulness, readability, flow, claim support, writing quality, search intent). Jev answers typed score questions on a 0–4 scale, normalized to 0–100 by multiplying by 25. It does not generate rewrites or free-form advice. The page can show an A–E grade. Bring your own Gateway key. License MIT.

README collects tests, calibration audits, and failure-mode studies of TypeSafe System One. License CC0-1.0.

README: a drop-in CPU-only proxy for System One lead models such as Jev, Rune, and Clef. It forwards each request to the lead and trains small CPU models, called understudents, on the lead's answers. When one reaches near-parity it graduates and Understudy answers that question itself, while sampled audits can demote it. It targets narrow repeated decisions such as yes/no gates, classification, routing, triage, and moderation, not broad single-question decisions over large state spaces. Question types are noul, choice, and score. A local answer happens only when every question in the request qualifies. The TypeSafe SDK can point at it with TYPESAFE_BASE_URL and no code change. The README says you do not need it when System One volume is small. Rust. MIT.

README: `run` hands a browser sub-task to Jev (operation + target in one request, ~300–550 ms via OpenRouter); `batch` runs known primitives without mid-step snapshots. Primitives cover Playwright-like surface (iframes, shadow DOM, dialogs, downloads). Claude marketplace plugin; OpenRouter key for `run`.

README: stdio or HTTP MCP; @typesafe-ai/sdk; optional Cloudflare Workers AI provider. Apache-2.0; JavaScript.

README lists ElBruno.AI.Decisions.Jev package as native TypeSafe adapter; early-access NuGet 0.6.1.

README: code, suffixes, and result files for the FlipJev preprint. A typed decision model returns yes/no, a named choice, or a level without writing text. Jev is the representative model, via the OpenRouter Decisions API as typesafe/jev-1.13. Headline in the README: common prompt injections changed no correct email answer in 10,240 paired tests; one suffix found on arXiv papers flipped 90–100% of five other datasets. Python 3.9 or newer. Regenerating the tables reads released results and does not call the API. Research-only license.

README describes a WordPress plugin/connector so PHP can branch on Jev answers. License GPL-2.0.

README: adapter for Choice/Score/Noul/Box (pixel_box); no capture/navigation itself; part of cto-legends. MIT; Python 3.11+.

README: pipe text, ask a question, scriptable exits for shell-safety gates; Homebrew/Go install; Claude Code plugin. MIT; Go.

Created 2026-10-09. README covers npm/local install, TypeSafe connect via OpenCode /connect, CI badge.

README: open harness for Jev protocol or OpenAI Decisions API. Reports Jev 1.13 among models; notes 255-option limit and option-order bias. CI and lab-integration docs. Python.

Built on the official TypeSafe JavaScript SDK, jod binds a state schema and typed questions. Invalid state fails locally without a request; valid questions travel together. Answers project into domain values while preserving confidence and probabilities in sidecars.

README (MIT): Hardfought NetHack50 build, web dashboard for live decisions/probabilities/spend; status 2026-10-02 — 570 games, deepest Dlvl 11, no ascension yet. Needs JEV_API_KEY.

README: environment or timeout failures re-run; a flaky assertion re-runs and files a P3; regressions and API contract mismatches get a ticket. Confidence under 0.5 is labeled needs-triage and is not automatic. Needs a TYPESAFE_API_KEY secret and JUnit XML.

README: no selectors or step definitions. Each step is executed by Jev, which does not write text. It picks among elements, actions, and check kinds Decisium lists and returns a probability for each. Code, not the model, decides pass or fail. npm package decisium. MIT.

The README describes Jev as a System One model: text or JSON state plus typed questions returns constrained answers and probabilities, and the calling code keeps control flow and side effects. It says the collection is independent and not an official TypeSafe repository. It notes a snapshot reviewed on September 19, 2026.

README: marketplace-facing wrapper; implementation lives in CMaintz/jev-tools packages/triage. On issue opened, labels with Jev API key; low confidence goes to a human or optional LLM. Pin `@v1` or a release tag.

README: splits the page into passages and scores them with Jev, eight per request, starting on screen. Matches are highlighted; non-answers stay unmarked. Measured 0.4–0.9 seconds and $0.0005–$0.007 per search. The API key stays in the browser. MIT.

README: native Pi extension (not a Skimmer CLI wrapper). Keeps relevant text chunks or JSON records; optional field projection for Jev. Session consent (`/skim enable`), recovery files, request/spend caps. Needs Pi 1.2+, TypeSafe SDK; optional pi-typesafe for `/typesafe login`.

README describes webular as search, scrape, crawl, and answer with sources from your machine, with one optional key: Jev. License Apache-2.0.

README pitches Tetris vs TypeSafe decision model with B2B chains and prefetch. Language JavaScript.

README: an entry system for the BuildArena S02 challenge. An isolated Autopilot run (Claude Code) builds in Besiege through the official BuildArena MCP. jev_orbita scores gates from telemetry. JevRouter calls a local Jev v4 router and rejects non-live provenance. PerformanceScore is Payload plus Efficiency plus Recovery plus Landing, then times 1.25 for Autopilot. The README says 14 unit tests passed. Status dated 28 October: Besiege was not installed, and no valid mission, telemetry, game score, or final submission is claimed. MIT.

README: the agent supplies evidence and named noul, choice, or score questions. The launcher binds only to 127.0.0.1. Go 1.25+, Python 3.9+, and Hermes with stateless MCP. Paid calls use your OpenRouter account. MIT.

README (Chinese): local-first semantic filter, not keywords; rules in plain language; timeline and comment threads; hidden items stay recoverable. Fail-open if the API errors. Load the v1.0.3 zip or build with Node.js 20+. MIT. Regions that receive HTTP 451 stay unfiltered.

README: lib/jev.mjs and a stdio MCP server expose jev_check (noul), jev_route (choice), jev_score, and jev_evaluate, with no vendor SDK and no runtime dependencies (Node 20+). jev_check maps probability to yes, no, or unsure using default thresholds 0.7 and 0.4. Every call sends state to api.typesafe.ai. Tests mock HTTP and do not use the network. MIT.

README: each item gets a confidence score, in under a second. A plan-mode hook can send the plan back when Jev is sure something is missing or contradicted. The review command shows the table and does not edit the plan. MIT.

README: sits behind nginx or Cloudflare. Fixed rules block obvious attacks; a decision model handles the rest. Early development, not validated on real traffic; run new sites in shadow mode first. Rust, MIT, with Linux binaries and a Docker image.

The SvelteKit app labels Telegram channel and chat exports by intent, quality, sentiment and tone. Settings expose the model, questions, concurrency and retries; TypeSafe and Vercel AI Gateway keys are supported. Token and cost meters accompany the results.

README describes greenlight for Pi agents powered by TypeSafe Jev, Mercury Decision, or Cloudflare Clef. License MIT.

README: questions cover intended use, personal data, oversight, and completeness. Fifteen synthetic examples or your own text. Human judgments stay separate from the model's answers. Live demo at jev-evaluation-lab-lovat.vercel.app.

README describes confidence-aware content moderation for any Eloquent model with per-category thresholds. License MIT.

README: the model reads the track and picks a lane and a move; a panel shows odds and latency. Host it with vLLM or llama.cpp on Linux, Windows, or macOS, from a 4 GB GPU or on CPU. Node.js 22+ and Python 3.10+. MIT.

README: concurrent resumable scoring, per-request cost, CSV/JSONL export, agreement metrics when both providers run. Python 3.11–3.14 via uv; progress bars on stderr. Docs cover CLI and an ESMO full-corpus run guide.

README: typesafe/jev-1.13 via OpenRouter, raw rows in data/measured.json, whole run under one cent. Twelve use cases landed at $0.000015–$0.000030 per decision. Section 8 adds twelve other decision models. MIT.

README presents an independent Go client for the TypeSafe API. License MIT.

README: the server rolls a d20 with crypto/rand and sends the name, profession, and that roll to Jev as one choice over the twelve core D&D 5e classes. The highest probability wins. Up to two runners-up appear when their displayed probability rounds to at least 1%. A local d6 then picks one of six original quirks and does not call Jev. The page is embedded in the binary. Without a key, the page and /health still serve, and /api/class returns 503 without contacting TypeSafe. Go, a scratch Docker image, and GitHub Actions. MIT. The README calls it an unaffiliated fan toy.

README: each of 200 catalog emojis is one Noul question (“would this be a natural, fitting reply?”), sent together in a single POST /v1/systemone. It uses the jev-latest alias; the README says that was Jev 1.14 (jev-1.14.0) as of October 2026. Up to four reactions at 50% or higher, and a fifth only at 75%. Go binary, Docker, or Cloud Run. MIT.

README: a Choice question labels Insight, News, Bait, Promo, Meme, or Opinion after a post stays in view for 350 ms. A badge sits by the author handle. Selected categories dim to 0.25 opacity. Needs a TypeSafe API key.

README: chess.js rules, per-side engine choice, and move probabilities when Jev plays. A pictured Haiku versus Jev game cost $0.0065. Node.js 22.9+. MOCK=1 plays without keys. MIT.

README: give it the task, the visible work, and the final answer. One Jev read returns the probability the answer is right, about $0.00015 per run, and risk is 1 minus that probability. On pairs where two runs agree, that read still ranked failures higher: AUROC 0.64 to 0.72 on GPT-5.5, GPT-5.6 Luna, Claude Opus 4.6, and Claude Opus 5.5, where a disagreement check sits at 0.50. Commands are tva ingest and tva score. TYPESAFE_API_KEY. Hidden reasoning is dropped. MIT.

README: Jev cannot write text, so it only chooses among options built from pane context (agent, title, command, folder, recent request, last 40 lines). A tab with several panes gets one label that sums them up.

README: a local CPU decision core, or TypeSafe Cloud Jev when TYPESAFE_API_KEY is set. Tools named jev_guardrail, jev_choice, and jev_score. The README claims the local core is under 5 ms. MIT.

The guide builds a local report over the last two weeks of Gmail, with categories such as reply needed, waiting on them, open issue, check, and possible phishing. The README says Windows with Gmail and Claude Code was tested; Mac instructions are written but untested.

README: an independent, zero-dependency Node 20+ experiment with TypeSafe's Jev. Each cell is a noul. A question set is 200 yes/no questions in eight categories of 25, sent in one parallel call; the README measures about 150–300 ms for 200 questions. server.js keeps TYPESAFE_API_KEY on the server and does not send the key back to the browser. The hosted GitHub Pages copy replays recorded answers and needs no key. Seven sets ship in the repo. MIT. DOI 10.5281/zenodo.23874577. The README says it is not affiliated with TypeSafe.

README: Command Labs agents share a configuration and differ by LLM. They run on one LangSmith dataset, Jev grades each answer against the reference, and each agent becomes one experiment. Scores run from 0 to 4 (Poor, Bad, Somewhat correct, Okay, Great). jev_judge_score is probability-weighted, so it can fall between levels; the README's example is 3.6. The comment stores confidence and the probability of each level. Env: LANGSMITH_API_KEY, CMDLABS_API_KEY, TYPESAFE_API_KEY, and CMDLABS_AGENT_ID. Install with uv sync. The README does not name a license.

README: say "Jarvis, …" to open apps, play music, set reminders, check the calendar, draft email, write Obsidian notes, and take selfies. Teach an app with jarvis add. Patterns handle exact command shapes offline. Jev, TypeSafe's System One model, decides natural phrasing and can answer unknown for questions and small talk. An LLM fills details and writes text, and never writes code that runs on its own. Across 69 measured commands, patterns decided 54% in under 1 ms and Jev decided the other 46% at a median of 116 ms, with every answer above the 0.6 threshold. All 8 questions and comments came back unknown, so nothing ran. Natural phrasing needs a Jev key. macOS only, Python 3.11+, described as an early experiment by one person. The case study is at craigraphics.com/blog/jarvis. MIT.

README: Jev reads the meaning instead of exact words, with a default 80% threshold. Answers can be recorded and replayed so CI runs with no key and no network. Unsure answers fail on purpose. MIT.

README: unpacked extension, not a Chrome Web Store listing. Titles, URLs, and visit metadata stay in extension IndexedDB (up to 50,000 Chrome history entries); page bodies are not captured. Jev ranking is opt-in with your own key and sends the query plus up to 32 shortlisted titles and sanitized URLs to TypeSafe. A downloadable demo uses 31 synthetic records and makes no model calls. App source is MIT.

README: Phase 0 judged 2,000 complaint narratives with jev-1.13.0 for about $0.30. It reports over-confident scores (9-way ECE 0.089), 4.8% of rows changing answer across three identical runs, and about 16.5% changing when re-batched. Apache-2.0.

README: each decision is a target tilt and a throttle level, held for one second. The game waits for every answer, so latency and cost are shown and never change the score. The name comes from Apollo low gate. Twenty courses of eight levels per lane, ranked by landing rate. Jev on the TypeSafe API landed 156/160 (98%), landing quality 46.7, median answer 203 ms. A scripted autopilot landed 159/160. Other lanes include Kev 27B, 9B, 4B, and 0.8B, Laya, Clef-flash, and Gemma 4 12B. The engine is deterministic TypeScript, version descent-3, with a seeded PRNG and fixed 60 Hz physics. Recordings replay bit for bit. The site at lowgate.erenterakye.com is static and needs no server or key. MIT.

README: on each utterance, about 37 yes/no-style questions go to Jev (TypeSafe System One) in one request and return in under a second. The screen shows close probability, call stage, one of 15 plays, an open objection, and live signals. Jev does not write the text; the math is in copilot/engine.py. An optional small LLM rewrites the suggested line, and Jev checks that it invented no fact. Based on moritzkremb/jev-sales-copilot, in Portuguese, via OpenRouter by default (also BeatAPI, jevmodel.org, or TYPESAFE_API_KEY). A 30-minute call is under $0.05 on Jev through OpenRouter. Jev sees the last 12 turns plus confirmed facts, not the whole call. The README does not name a license.

README: Oracle CLAIMS, 1,782 claims, 12 repeats of 5-fold cross-validation. ROC-AUC is 0.798 for XGBoost, 0.796 with Jev, and 0.805 with Grayson. Jupyter notebook.

The README describes missions from links or uploaded files, live judgment progress and cost meters, and sortable, filterable, exportable results. Jev uses Noul, Choice and Score to select among candidates supplied by code. Claude can optionally draft plans and review uncertain items.

README: talk to / recruit monsters; server holds TypeSafe API key. `npm run crawler`, tests, scenario scripts. itch.io build mentioned in crawler README.

The README describes log tailing or embedded middleware, deterministic filtering, and per-IP behavior windows. Jev evaluates suspicious windows with Noul and Choice; HTTP and operating-system firewall bouncers apply bans. It also describes gRPC fleet synchronization.

README: you type one order as the queen; eight ants on a board choose a next step from a decision model. The model is TypeSafe Jev (a key from console.typesafe.ai) or local Ollama 0.35+ with no key. An eight-step tutorial in English and German builds the game. Python 3.12+, uv, and Streamlit. MIT. It is a port of rust-bevy-jev-ants.

The Angular and Phaser demo sends Choice for flap versus glide and Noul for imminent danger through OpenRouter Decisions. Jev’s action drives the bird without a heuristic override; the danger answer is logged. Simulated outcomes of both actions are included in state.

README reports ~79 ms and ~2e-5 USD per text, tying a strong single-question baseline; one added sentence lifted a missed attack family from 40.8% to 70.4% with no retraining. License MIT.

README: jev-latest through @typesafe-ai/sdk. Ask one hotel a yes/no question, or ask which hotels match. Needs Node.js 22, a TypeSafe API key, the workshop Neo4j dump, and Docker or a Mac fallback.

README: Phase 1 preview for Apple Silicon and macOS 15+. Talk to Jev, saved tasks, Chrome or Mac control, optional Orgo computer and Composio tools. Bring your own OpenAI, LiveKit, and TypeSafe keys. MIT.

README: an idiomatic Rust SDK for TypeSafe's System One model, Jev. The sample builds one question set with noul, choice, and score macros and asks them together, then branches in ordinary Rust. The roadmap marks Noul, Choice, Score, enums, question sets, a global client, retries, a concurrency limit, and a cache as done. Bbox, images, and a crates.io 0.1 release are still open. The README licenses the crate as MIT OR Apache-2.0.

The README describes four Claude Code hooks: session instruction scanning, pre-tool checks, post-tool prompt-injection scanning, and a completion review. The pre-tool request asks Jev several typed risk and policy questions while excluding the main model’s reasoning transcript.

README: you approve categories and nothing moves until you confirm. On 101 ungrouped sessions it reports 7.9 seconds and $0.003 total: 72 moved, 23 flagged for review, 6 left alone. MIT.

README: cd playground, then bun install and bun run start. Add Question inserts Noul, Score, or Choice. A version keeps state, questions, runs, and a note so edits can be compared. The API key comes from the page box (not written to disk) or TYPESAFE_API_KEY in playground/.env. Save and Open need a Chromium file picker. AGPL-3.0.

README: status experimental; interfaces may change. This optional package exposes Jev decisions through an Amplifier hook module. It has no chat models and never enters the ordinary chat fallback chain. No decision call occurs until both the account and a consumer explicitly enable it. Unless an HTTPS account base URL or decision endpoint is set, it uses https://api.typesafe.ai/v1/systemone. Endpoints with credentials, fragments, or query strings are rejected. The shared contract normalizes predicate, fixed choice, and ordinal score answers. Images and Box execution are disabled. Requests have bounded time and body size, with no automatic retries or redirects. Install with uv from the git URL. MIT.

README: .NET 10. Install with dotnet add package Jevelin. AskAsync takes a state plus named Noul, Choice, or Score questions. AskYesNoAsync is the yes/no shortcut. Default model is jev-latest and the base address is https://api.typesafe.ai/. The key comes from TYPESAFE_API_KEY or the constructor. The README says Jevelin is unofficial and not affiliated with TypeSafe. MIT.

README: FastAPI plus one HTML/JS page, Python 3.11 or newer. Tabs cover a support ticket, a suspicious message, and a comment; a scam filter on 22 fictional SMS and emails with two thresholds; a fake-number question; ticket routing; and a duel on errors, latency, cost per 1,000 decisions, format errors, and calibration. An empty TYPESAFE_API_KEY means simulated mode. JEV_MODEL defaults to jev-latest. The README says the Jev API is hosted in the United States, and that the project is not affiliated with TypeSafe. MIT.

README (Chinese): three recipes, rank-candidates, verify-claims, and triage-failure. Jev returns the judgment and probabilities; local code sorts, applies thresholds, handles errors, and stores SQLite metadata. Dry-run needs no key. Node.js 22.16+.

README: Beginner/Pro/Legendary difficulties; standard rules; procedural Staunton pieces; mobile-first controls; session You-vs-Jev score. Links TypeSafe System One intro blog.

The PHP 8.3+ provider maps portable predicates to Noul and choices and scores to TypeSafe criteria. It preserves probabilities, confidence, usage and raw responses. The initial adapter supports text and JSON evidence and rejects images before HTTP.

README: classifies task kind, complexity, deserved capability, deep-reasoning need; maps to quick/standard/high/premium tiers. Modes shadow/auto/notify/confirm. Uses `~typesafe/jev-latest` under OPENROUTER_API_KEY. Hermes 0.21.4+.

README: fortune teller, magic 8-ball, stack ranker, option scorer, roast, Convince the Bouncer, Jev's Secret, and tic-tac-toe. Each result can be asked five times. Live at jev-oracle-ten.vercel.app. TYPESAFE_API_KEY, or JEV_PROVIDER=mock.

README: Python 3.10+ CLI with no dependencies, for Jev, Drex, Kev, and Mercury Decide. howsure run calls a System One endpoint on labeled JSONL. fit writes a policy and an HTML report. Temperature scaling is used for choice and score, Platt scaling for noul. About 25% of the labels, between 30 and 300, fit the calibration, and the rest evaluate it. The split is by example content so every model gets the same one. --max-error picks the most coverage whose held-out error stays at or under that target. --safe uses exact binomial tests in a fixed sequence (Learn-then-Test), with --sure defaulting to 0.95. serve proxies the upstream and adds a howsure block that marks each answer auto or review. If a question's wording or options changed since fitting, it goes to review. howsure demo uses synthetic data and needs no model. The README says it is not affiliated with TypeSafe, Nace.AI, Inception, OpenRouter, or Kev. MIT.

README: modes are auto, advise, or off. It moves up when Jev is at least 45% sure, and down only at 70% or more when the chat is still small or the cache went cold. Subagents are left alone. Bring your own TypeSafe key.

README: checks eight kinds of clauses and marks Caution when the probability it is abusive is 70% or higher. Click a result to highlight that clause. The page is read only when you click. Not legal advice. English or Japanese UI. MIT.

README: both boards share a seeded 7-bag. Your TypeSafe key is sent only as the auth header to https://api.typesafe.ai/v1/systemone. Python 3.10+, no package install. The server binds to loopback. MIT.

README (Japanese) describes a Python engine/CLI linking TypeSafe Jev with sqlglot for high-trust deterministic SQL from natural language (<0.5 ms). License Apache-2.0.

README: Mac + Proton Bridge + TypeSafe API key; records answers by default; optional move to Jev Review; never deletes. MIT. Not archived.

README: UCanLabs-style architecture — System-1 JEV screens bulk work cheaply, then System-2 LLM for the rest. Pins typesafe-sdk; Python 3.10+. Korean-first packaging as an agent skill.

README: before each model call, Jev answers noul questions about which MCP servers, tools, and skills the prompt needs. Defaults are 0.55 to keep a tool or skill and 0.35 to keep a server. The plugin only rewrites that request's context. The tool registry stays; a model can still call a pruned tool by name. The README says noul is about 100 ms and that choice and score are not used in V1. Key: JEV_API_KEY. MIT.

README: every two minutes it polls new Hacker News stories, skips ones already seen, and evaluates the rest with one or more decision trees stored in SQLite, using Jev. A story that matches at least one tree goes to Telegram. Required env: JEV_API_KEY, TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID. At least one tree must exist. Go 1.27 or the Docker image uint4096/hndelegate. Default cap is 20 posts per round. GPL-3.0.

README: an independent harness on five public human-labeled datasets (300 eval items each) with arms for TypeSafe Jev, Claude Haiku 5.5, Claude Sonnet 5.5, and a local TF-IDF logistic regression. It says the harness is complete, but every number for the jev, haiku, and sonnet arms comes from --dry-run synthetic generators and is not a measurement of those models. Only the logreg baseline numbers are real. Real runs still need API keys. Python 3.11+. MIT.

README (Russian): for each home, search, subscription, or sidebar card it sends title, channel, duration, and description when present, then asks Jev three questions in one request: clickbait (Noul), hype (Noul), and substance (Score 0–3). Code hides the video if any answer crosses the soft, normal, or strict threshold, and it removes Shorts. Answers are cached by video id. The README says one video is about 700 input tokens, about 3 cents per 1,000 videos. Plain Manifest V3 JavaScript; the key stays in chrome.storage.local. MIT.

README: a plain-English guide to the 20 jobs in the 21 official cookbooks as of October 28, 2026, plus images, tested with the authors' own examples. It reports 307 examples, with 155 of 163 core and 132 of 144 edge marked right, 1,463 requests, and the model pinned to jev-1.14.0. Replaying the cache needs no API key. The README calls these illustrations on small hand-written samples, not benchmarks. Code is MIT; the article, figures, and video are CC BY 4.0.

README: static page classifies an image as hotdog or not with Jev. Live on GitHub Pages and a GEOMAR Pages mirror. Inspired by Risky Business RB854.

The static app evolves populations of ten block drawings. Jev chooses the panel matching an object and scores the chosen drawing with Noul; crossover and mutation create the next generation. It includes alphabet replays, word rendering and an explore page for arbitrary objects.

README: JEV (jev-1.13) primary engine with Gemini API fallback. Screenshots and badges point at TypeSafe System One. MIT.