w3cj writes about jev-chat, a tool-calling chat bot that routes user requests to real tools using Jev, a non-generative classifier from TypeSafe, with no LLM writing any output. Every value on screen was either typed by the user or returned by a tool, so the assistant cannot invent a fact. The system supports weather, unit conversion, Wikipedia lookups, recipes, web search, Todoist, and Home Assistant via MCP servers, with an inspector pane exposing every decision and probability for each turn.
- Jev answers only two question types — Choice and Noul — and never produces text; all reply wording is templated in code
- Pre-processing handles spell-check (cspell + compromise) and resolves short follow-ups like "what about Boston?" by swapping in the new value
- Multi-step tools (Wikipedia, web search) chain multiple Jev requests: pick topic, then article, then the exact line that answers
- Confidence-gated routing shows two buttons when the top tools are close rather than guessing
- The repo is a proof of concept; the author will not accept PRs for new features
- English only; no compound requests or multi-step reasoning supported
- Jev answers only two question types — Choice and Noul — and never produces text; all reply wording is templated in code
- Pre-processing handles spell-check (cspell + compromise) and resolves short follow-ups like "what about Boston?" by swapping in the new value
- Multi-step tools (Wikipedia, web search) chain multiple Jev requests: pick topic, then article, then the exact line that answers
- Confidence-gated routing shows two buttons when the top tools are close rather than guessing
- The repo is a proof of concept; the author will not accept PRs for new features
- English only; no compound requests or multi-step reasoning supported
jeff is a self-hosted drop-in replacement for TypeSafe's jev System One API, powered by the 400M-parameter GLiFormer-large-v1 model. It serves `choice`, `score`, and `noul` classification questions over a compatible wire format, so existing applications using the official `typesafe-sdk` can point at it by changing a single base URL. Deployment targets include GPU (L4, A10G) and CPU (ONNX Runtime with int8 quantization) via Modal, with ~50 req/s per container throughput on L4. Benchmarks on 1,600 labeled items show it costs roughly a quarter of jev per million requests but trails significantly on reasoning-heavy tasks like irony and reading comprehension.
- `JEFF_ISOLATE=nouls` (default) gives separate encoder passes per noul question to reduce cross-question interference; choice and score questions share a pass unless set to `all`
- Default temperature of 3.2 calibrates noul probabilities; setting it to 1 makes `score` output match the weighted average of displayed probabilities
- A smaller `gliformer-base-v1` variant with `JEFF_NOUL_MODE=single` is recommended for faster local iteration
- `JEFF_ISOLATE=nouls` (default) gives separate encoder passes per noul question to reduce cross-question interference; choice and score questions share a pass unless set to `all`
- Default temperature of 3.2 calibrates noul probabilities; setting it to 1 makes `score` output match the weighted average of displayed probabilities
- A smaller `gliformer-base-v1` variant with `JEFF_NOUL_MODE=single` is recommended for faster local iteration
Gregory Gibson writes about applying the Linux kernel's tool-generated content guidance to his vibe-coded Morse decoder app, CW Inspector. He used OpenAI Codex to build the app, then subjected it to the kernel's five transparency rules: name the tool, preserve inputs, keep the prompt trail, record exactly what the tool changed, and make the generated code prove itself. The process exposed a critical flaw — the decoder confidently produced a wrong answer (reading TTT E as SE) with zero errors, demonstrating that a clean run doesn't guarantee correctness.
- The original algorithm treated the shortest 55% of keyed pulses as dots, which broke on dash-heavy messages; the fix looks for a large ratio between short and long pulse clusters before recording dot duration.
- The author deliberately withheld the actual WAV file from Codex, providing only metadata and the expected message, to create an independent acceptance test rather than letting the model optimize against the exact sample it would later decode.
- The kernel's guidance applies only when a tool generates something substantial (functions, files, fixes, translations), not for spelling corrections, autocomplete, or variable renames.
- The original algorithm treated the shortest 55% of keyed pulses as dots, which broke on dash-heavy messages; the fix looks for a large ratio between short and long pulse clusters before recording dot duration.
- The author deliberately withheld the actual WAV file from Codex, providing only metadata and the expected message, to create an independent acceptance test rather than letting the model optimize against the exact sample it would later decode.
- The kernel's guidance applies only when a tool generates something substantial (functions, files, fixes, translations), not for spelling corrections, autocomplete, or variable renames.
Deepan Wadhwa writes about OpenDecision, a Python package that makes structured semantic decisions using a zero-shot NLI model (~400M ModernBERT-large) instead of a generative LLM. It exposes three typed primitives—Choice (select from a set), Noul (binary predicate), and Score (ordered rubric)—and serves them locally via FastAPI with a TypeSafe SDK-compatible endpoint.
- Inspired by TypeSafe's Jev "System One Model" announcement; the author previously built similar fraud-detection logic for a healthcare client.
- Choice uses two complementary NLI "compilers" and falls back to a third adjudication pass when they disagree, all on the same model.
- On TypeSafe-adapted benchmarks: 84.3% Choice accuracy, 85.0% Noul, 0.375 MAE on Score; on its own 125-case holdout: 86.4%.
- The returned "confidence" value is a concentration measure over the probability distribution, not a calibrated correctness estimate.
- Inspired by TypeSafe's Jev "System One Model" announcement; the author previously built similar fraud-detection logic for a healthcare client.
- Choice uses two complementary NLI "compilers" and falls back to a third adjudication pass when they disagree, all on the same model.
- On TypeSafe-adapted benchmarks: 84.3% Choice accuracy, 85.0% Noul, 0.375 MAE on Score; on its own 125-case holdout: 86.4%.
- The returned "confidence" value is a concentration measure over the probability distribution, not a calibrated correctness estimate.
logicrw writes a community-maintained directory and radar for the Jev ecosystem, highlighting open-source projects that utilize System 1 decision architectures to enable fast, typed discrete decisions. The repository serves as an audited catalog of over 306 curated projects across various domains such as browser automation, CLI tools, data search, and security guardrails, with every entry linked to commit-pinned source code for verification.
- Provides sub-second latency (50–100ms) compared to the high latency of reasoning LLMs.
- Features native typed outputs like Choice, Score, and Noul without fragile regex parsing.
- Organized into extensive categories including Model Routing, SDK Integrations, and High-Frequency Games.
- Includes an "Agent Skill" that allows users to query projects directly from their terminal or via agents.
- Provides sub-second latency (50–100ms) compared to the high latency of reasoning LLMs.
- Features native typed outputs like Choice, Score, and Noul without fragile regex parsing.
- Organized into extensive categories including Model Routing, SDK Integrations, and High-Frequency Games.
- Includes an "Agent Skill" that allows users to query projects directly from their terminal or via agents.
Nolen Jonker writes that Google Antigravity, Claude Code, and Codex each occupy a distinct niche among LLM coding agents: Antigravity excels at frontend work requiring visual verification (via its built-in browser that navigates running apps and records proof), while Claude Code dominates multi-file refactoring and production code quality, and Codex dominates terminal automation, DevOps, and token-efficient high-volume workflows.
Antigravity's free tier is the only one offering full access to frontier models without a subscription, and its built-in Chrome browser lets agents visually verify frontend work by navigating and recording the running app. However, Claude Code leads on complex multi-file refactoring, and Codex dominates terminal automation and token efficiency.
Antigravity's free tier is the only one offering full access to frontier models without a subscription, and its built-in Chrome browser lets agents visually verify frontend work by navigating and recording the running app. However, Claude Code leads on complex multi-file refactoring, and Codex dominates terminal automation and token efficiency.
Zhang writes about Agora, a system that repurposes Git as shared memory for fleets of autonomous research agents, storing their contributions as an append-only directed acyclic graph where every claim is an immutable commit with parent edges encoding dependencies. In a 12-day run, 13 language-model workers with no assigned tasks or central planner tackled a weight-transfer problem—initializing a frozen 119.6M-parameter attention-SSM hybrid from 141 pretrained donor models without training data or gradient updates—and published 1,703 contributions, closing 62% of the gap to a trained GPT-2 124M (3.39 → 1.899 bits per byte). The winning recipe compresses donor next-token statistics into the target's embedding and output head, then adds short-range context through sparse edits to attention, feed-forward, and state-space blocks; its 145-commit ancestry spans 15 accounts and was independently reproduced 165 times with zero failures.
- A single mid-run human intervention was required to break a monoculture that the diversity-aware selection rule alone could not prevent
- A derived index exposes the frontier, neglected branches, and per-claim verification status
- The target's dimensions match no donor, making direct weight transfer impossible
- The authors acknowledge the experiment does not yet establish whether shared research state improves discovery per unit of compute and outline the controlled comparison that would settle this
- A single mid-run human intervention was required to break a monoculture that the diversity-aware selection rule alone could not prevent
- A derived index exposes the frontier, neglected branches, and per-claim verification status
- The target's dimensions match no donor, making direct weight transfer impossible
- The authors acknowledge the experiment does not yet establish whether shared research state improves discovery per unit of compute and outline the controlled comparison that would settle this
Yifan Zhang and co-authors write about Agora, a Git-backed shared memory system that coordinates multiple autonomous research agents by recording every contribution as an immutable commit in an append-only directed acyclic graph. In a 12-day run, 13 LLM coding agents (Claude Opus 4.7 and GPT-5.5) with no assigned tasks or central planner solved a weight-transfer problem—initializing a frozen 119.6M-parameter attention-SSM hybrid from 141 pretrained donors with no training data or gradient updates—closing 62% of the gap to a trained GPT-2 124M (3.39 to 1.899 bits per byte). The winning method compresses donor next-token statistics into a low-rank transition matrix stored in the target's embedding and output head via randomized SVD, then re-enables sublayers with sparse deterministic edits on 96-dimensional hidden-state bands.
- The first 18 scored contributions delivered ~98% of the total score reduction; the remaining 1,106 found only 0.03 bpb
- 696 pairs of different accounts posted identical scores, 63% within an hour—parallel rediscovery was rampant despite the shared graph
- A single human intervention (deploying clustering and diversity-aware UCB views on May 2) broke a five-day monoculture within a day
- 165 independent verifications covered 95 distinct targets; none reported a failure
- Quality is scored by downstream evidence (who built on your work from other accounts), not votes; self-citation is excluded
- The winning lineage spans 145 commits across 15 accounts; 115 of 144 parent edges cross account boundaries
- The first 18 scored contributions delivered ~98% of the total score reduction; the remaining 1,106 found only 0.03 bpb
- 696 pairs of different accounts posted identical scores, 63% within an hour—parallel rediscovery was rampant despite the shared graph
- A single human intervention (deploying clustering and diversity-aware UCB views on May 2) broke a five-day monoculture within a day
- 165 independent verifications covered 95 distinct targets; none reported a failure
- Quality is scored by downstream evidence (who built on your work from other accounts), not votes; self-citation is excluded
- The winning lineage spans 145 commits across 15 accounts; 115 of 144 parent edges cross account boundaries
OpenProse is a declarative language for standing AI work, where users write Markdown contracts to describe a desired world state and a deterministic reconciler keeps reality matching it. The project applies classical declarative paradigms (SQL, Terraform, Kubernetes, React) to agent-based systems, using "Responsibilities" as the core unit — standing goals with sections for what they maintain, what they require from upstream, and what wakes them. It ships as a skill installable into any Prose-Complete agent host and runs without a separate binary.
- Tagline: "Stop scripting agents. Declare them."
- Forme, the wiring layer, automatically matches subscriptions between contracts so the dependency graph assembles itself with no manual wiring
- The old LLM-based judge loop was retired entirely in the v2 overhaul; a render fires only when a content-addressed fingerprint moves, with no model in the wake/commit decision
- The reference harness "Reactor" was extracted to its own repo and is labelled experimental (alpha)
- Tagline: "Stop scripting agents. Declare them."
- Forme, the wiring layer, automatically matches subscriptions between contracts so the dependency graph assembles itself with no manual wiring
- The old LLM-based judge loop was retired entirely in the v2 overhaul; a render fires only when a content-addressed fingerprint moves, with no model in the wake/commit decision
- The reference harness "Reactor" was extracted to its own repo and is labelled experimental (alpha)
OpenProse is a declarative language for standing model work in which you describe desired world states in Markdown contracts and a reconciler handles execution. Rather than scripting sequential agent steps that drift over time, you declare what must stay true and the system determines how much work is needed to keep reality matching that declaration. It ships as a skill for coding agents like Claude Code or Codex CLI with no separate binary or server to run.
- The core unit is a "Responsibility" whose Maintains section defines material fields and a content-hash fingerprint to avoid redundant re-runs
- The dependency graph self-wires: a node's Requires section subscribes to upstream Maintains facets, so structure emerges from the contracts rather than being explicitly drawn
- Five kinds exist: responsibility, function, gateway, pattern, and test
- Continuity (when a node wakes) is a first-class contract section, not an afterthought
- Optional imperative ProseScript plans are available for cases requiring exact choreography
- The core unit is a "Responsibility" whose Maintains section defines material fields and a content-hash fingerprint to avoid redundant re-runs
- The dependency graph self-wires: a node's Requires section subscribes to upstream Maintains facets, so structure emerges from the contracts rather than being explicitly drawn
- Five kinds exist: responsibility, function, gateway, pattern, and test
- Continuity (when a node wakes) is a first-class contract section, not an afterthought
- Optional imperative ProseScript plans are available for cases requiring exact choreography
