Jev Cobanov

LangChain is the agent engineering platform: an MIT-licensed Python framework from the LangChain team for building agents and LLM applications by chaining interoperable components with third-party model, tool, and vector-store integrations.

Composio is an MIT-licensed SDK monorepo giving AI agents 1,000+ pre-authenticated toolkits with per-user sessions, authentication, triggers, and a sandbox, and it ships TypeScript and Python adapters including one for TypeSafe (Jev).

LangChain.js is the TypeScript edition of LangChain, a framework for LLM-powered applications that runs on Node.js, Cloudflare Workers, Vercel and Next.js, Supabase Edge Functions, browsers, Deno, and Bun.

Effect is a TypeScript library for production-grade applications, covering typed errors, dependency injection, structured concurrency, scheduling, tracing, and schema validation; 4.x is a long-term support release.

BAML is Boundary's Apache-2.0 programming language for agents: TypeScript-looking syntax, a Rust-like type system that persists at runtime, typed errors, green threads, and callable from TypeScript, Python, Go, C#, and Java.

Nautilus Compass is a local-first memory and reliability layer for AI agents: SOTA retrieval on LongMemEval-S, drift detection before agents act, cross-agent contracts, plus MCP, caliber-bench, and NACRE judging artifacts.

A playable Three.js driving simulator where Jev-powered autopilot picks steering and speed up to four times per second: compact tables of eligible paths, traffic and road boundaries go to Jev while geometry and control math stay local.

A 144.3M-parameter bilingual typed decision model fine-tuned from jhu-clsp/mmBERT-small: it answers noul, choice, and score questions in one forward pass with calibrated confidence and zero output tokens, and it runs on CPU.

A System One model family for video: VideoJev-4B and VideoJev-35B-A3B perform temporal grounding and multiple-choice video QA by scoring candidates directly, returning probabilities instead of generated text.

An independent fork of Laya that replaces its text encoder with a small vision-language model, giving calibrated typed decisions over an image plus text in one forward pass from a 201M-parameter SmolVLM-256M backbone.

A Java and Python implementation of parallel constrained decoding: fill a whole JSON schema of booleans and enums in two forward passes, with calibrated confidence per field and output that is schema-valid by construction.

A reproducible lab measuring how several coding agents coordinate on one repository, plus Médula, a kernel that asks TypeSafe Jev before every write whether a change collides with what the other agents are doing.

A native Swift implementation of OpenJev, the Jev-compatible typed-decision server: send a state and typed questions over a Jev-compatible HTTP API and read every answer from model probabilities, on Apple silicon Macs or inside iPhone and Mac apps.

An independent reimplementation of the OpenJev mechanism on PrismML's 1.75-bit Bonsai weights: typed decisions read straight off the next-token distribution of a 5.95 GB 27B model in one forward pass.

A curated list tracking the open side of the System One ecosystem — runnable Jev-like models, independent benchmarks, and calibration and constrained-decoding tooling — as the counterpoint to lists about the closed hosted Jev.

An OpenCode plugin that keeps the session on a cheap sticky parent model so the cache stays warm, and asks Jev whether a turn is hard before escalating through jev_escalate to temporary stronger subagents.

A playable Tetris where Jev never sees the board: code enumerates every legal placement as a sentence and Jev returns a probability for each in about 380 ms. The field glows with the whole distribution before the piece drops.

A native R client for Jev and TypeSafe System One: send a state plus typed questions and get structured answers back in R. Supports jev_choice, jev_score and jev_noul questions, several questions per evaluation, and jev_map over many states.

A Japanese System One decision model built on modernbert-ja-310m: send text and typed questions and get typed answers with probabilities from one forward pass, no text generation, at 314.6M parameters that also run on a CPU.

Head-to-head benchmark for System One-style classification models across choice, noul and score questions. Jev led both hash-locked suites at 0.974 micro accuracy on v1 (8 tasks, 78 cases) and 0.964 on v2 (49 tasks, 866 cases), ahead of local Von 1.1, GLiNER2 and Laya.

An MCP stdio server that judges every research step: guarded_search, guarded_fetch and research_report score each query, result and fetched page with Jev for relevance, credibility and steering risk, with budgets, SSRF-guarded fetching and a live SSE dashboard.

An audio-native decision model shaped like Jev: audio is encoded once, several typed questions branch over that single encoding, and answers come back as calibrated probability distributions — no transcript, no ASR, the Whisper decoder never runs.

Official MCP server for JevGuard and TypeSafe AI: zero-dependency guardrails over JSON-RPC 2.0 on stdio, gating shell commands and code patches, caching decisions in local SQLite and pruning state.

Benchmark harness that scores TypeSafe Jev against any OpenRouter model or local checkpoint on labelled classification data: accuracy, calibration (ECE), confidence distribution, latency and cost across five tasks with 300 items each.

Open, CPU-sized Jev-style decision model: give it a situation, a question and options, and Decima returns calibrated probabilities in roughly 20-50 ms per decision as int8 ONNX, with no GPU, no API key and nothing leaving the machine.

Benchmark results for JEV 1.13 in Choice mode across MetaTool, When2Call and BFCL V4: tool selection, abstention and hallucination tables with bilingual reports and CSV data.

A Google Sheets add-on that classifies, tags and scores text with plain-language formulas: JEV_IF, JEV_PROB, JEV_CHOICE and JEV_SCORE return typed values, and uncertain rows can say UNSURE instead of guessing.

Probabilistic control flow for TypeScript: Hunch asks a System One model such as Jev yes/no questions, thresholded booleans, picks and ratings, and returns typed answers you can branch on in ordinary code.

Measured cost, latency, accuracy and raw output from the live Jev API across twelve realistic use cases, plus twelve other decision models on the same 633 items. Reproducible with your own key; the whole measured Jev run cost under one cent.

Examples for consuming the AlgoVault Verifiable-Signal v1.0 spec across trading and execution platforms — FreqTrade, Hummingbot, 3Commas, Coinbase AgentKit and others — plus a decision-layer example whose transformer returns a TypeSafe SystemOneRequest that Jev answers before code applies every threshold.

A semantic command palette demo where Jev ranks 77 commands by intent in Portuguese or English: one Choice question per keystroke, with the full probability distribution over the command catalog as the ranking. Runs side by side with a classic fuzzy matcher that fails honestly on the same queries.

Browser chess and Chess960 where code works out every legal move's facts and Jev picks one per turn as a single typed Choice; the mirror of the chriswijnia.com/lab/chess monorepo.

A website companion's code: a page's actions are offered as WebMCP tools, a visitor's request becomes one Jev Choice, and a three.js voxel character hops to the button and does it.

Audits any business site for SEO and AI-search visibility: a deterministic crawl feeds narrow typed Jev judgements that stream into a live dashboard page by page, with no LLM-authored findings.

A Java 21 client and CLI for the TypeSafe API: send state with Noul, Choice, and Score questions, get typed answers, and optionally run local Clef and Laya models via ONNX Runtime with no API key.

A git pre-commit hook that asks TypeSafe Jev whether each new file belongs in your repo, catching scratch scripts, debug dumps, build output and local config before they land. Local rules run first, so .env and .DS_Store are matched locally and never sent anywhere.

A typed-decision accuracy layer for RAG pipelines that wraps the seam between retrieval and generation with six cheap checks: intent, relevance, clarify, sufficiency, grounding and caveat. Each check returns a calibrated probability you can threshold and log.

A Pi extension for selective, verbatim context compaction: Jev scores every tool call and its result, unneeded calls are dropped, and everything kept stays byte-identical. The README measured 15.5% reclaimed on a synthetic window, rising to 33.5% with prose included.

A Ruby gem that turns typed Jev judgments into ordinary ActiveRecord attributes: Noul, Choice and Score answers become indexable, sortable columns with SQL scopes like urgency_above(0.8). It also works as a plain Ruby client with no Rails.

A Codex and Claude Code Stop hook that detects overloaded multi-topic messages and forces the agent to present issues one at a time with context and missing info, using two Jev Choice questions behind confidence thresholds.

A set of experiments that uses TypeSafe's Jev as a decoder through its Choice primitive, sampling ASCII characters, BPE tokens and grammar-constrained SQL from Jev's probability distributions, and measuring next-character loss against uniform sampling on tiny-shakespeare.

An interactive chess experiment on chriswijnia.com: play Jev, TypeSafe's System One model, a simple engine or a friend, or watch Jev play itself. Each turn Jev weighs every legal move at once as one typed Choice and shows how sure it is.

A shared 1,000 by 1,000 emoji canvas where visitors paint and Jev paints alongside them: after each stroke it reads what is around it by name, weighs emoji that belong with it, and paints one or finishes a shape it is sure you meant.

Jevvie is the companion in the corner of every page on chriswijnia.com: ask it for something and Jev picks which of the page's actions you mean, one typed Choice at a time, then Jevvie hops over and does it. The same actions are WebMCP tools.

Perry Link's Zenodo preprint compares three judgment layers - a local Laya judge, TypeSafe Jev and DeepSeek-V4.1-Flash - on the same 120-checkpoint task, reporting that cost is not the binding constraint, that p50 latency spans about 25-32x, and that the judges' self-reported fields fail in clustered ways.

A Hugging Face Space for the Decima decision model: choose a preset or write your own question, list possible answers, and paste any text you want the model to consider. The app then shows the probability for each answer.

A Hugging Face Space that runs a tiny System One model entirely in the browser: type a prompt and the app produces output on the spot, with no server connection or installation required.

A community gallery of Jev use cases and experiments drawn from projects, X posts, and videos, reporting 319 projects, 273 X posts, and 261 videos at review time, with language filters and a submit-content form.

A directory of 2,086 open-source projects built on Laya, the open System One decision model, with category and platform filters, star counts, a live laya-mlx demo, and a hosted Laya + Clef API with $1 free credit.

Ollaya's documentation index for its local decision-model runtime: quickstart, the full CLI reference from run to mcp, native and TypeSafe-compatible API endpoints, Modelfiles, and MCP plus agent-skill guidance.

Ollaya's searchable registry of open decision models you can run locally: 21 models with capability filters, and cards showing authors, sizes, tags, update dates, and typed-decision scores with RTX 4090 latency.

An OpenRouter cookbook recipe that replaces a blanket human-approval rule with a per-call Jev check: the proposed tool call, ticket, and policy go to Jev, whose probabilities route to approve, block, or review.

An OpenRouter cookbook recipe for a draft-verify-escalate cascade: a cheap model drafts an answer from retrieved context, Jev votes supported, unsupported, or declined, and a frontier model rewrites only when verification fails.

A Convex page for comparing models that answer verified multiple-choice questions about Convex, scoring them with source-weighted results and showing latency, cost and inspectable outcomes alongside the scores.