I Was Letting Claude Decide Everything. Jev Fixed It for $0.0002 a Call

September 21, 2026 9 min read

I let Claude decide everything. Is this transcript passage a sponsor read? Ask Claude. Which model should build this task? Ask Claude. Is this screenshot worth keeping? Ask Claude. Each of those was a five-second call that cost about two cents, to get a yes or a no.

Then I put Jev in front of it, and one of the first things Jev did was route a build to Haiku at 97% confidence. Haiku wrote the module, wrote the tests, and stopped at the integration step. The rule I got out of that is the most useful thing in this post, so I’ll get to it.

This is the technical version: install, numbers, code. If you’re not sure what Jev even is, start with What Is Jev? (plain English) and come back.

This is the Claude Code + Obsidian setup I actually run. If you’ve read my Claude Code guide or the agentic PKM guide, this is the next layer down: what happens when you stop paying a full model to make small decisions.

What Jev is

Jev is TypeSafe’s System One model. It answers three shapes, and only three:

noul gives you a probability between 0 and 1. “Is this email asking for a refund?” → 0.98.
choice picks one option from a list you hand it, and tells you how sure it is. “Haiku, Sonnet or Opus for this spec?” → Haiku (0.97).
score places something on a rubric you define, low to high. “How severe is this design-system failure: Cosmetic, Minor, Major, Blocking?” → 2.86.

It does not write sentences. That sounds like a limitation until you count how many of your Claude Code calls only needed a number.

Jev vs Claude, same question

I ran this on my own machine, same question both ways: “is this passage a sponsor read?”

	Jev (System One)	Claude Haiku via Claude Code
Answer	0.98	0.99
Wall time	~1.5 s from a shell script (mostly python + curl spawning); ~200 ms from Python	5.1 s
Cost per call	~$0.0002	$0.0194 (`total_cost_usd` in the JSON output)
Writes prose	No	Yes

Same answer, roughly a hundredth of the price, a fraction of the wait. Multiply by every “is this X?” your workflow asks and the Claude Code cost line moves.

Install in five minutes

Five steps. None of them need you to be a programmer; you’re pasting commands into a terminal you already use for the Obsidian CLI.

1. Put the key in the macOS keychain, not a file.

security add-generic-password -a "$USER" -s TYPESAFE_API_KEY -w "<your key>" -U

2. One script, three verbs. Mine is classify.sh, about forty lines of shell plus a little python to build the request. It reads like this:

J=~/Projects/03-Resources/tools/jev/classify.sh
$J noul   "Is this email asking me for a refund?"  "<the email text>"
$J choice "Which tier should build this spec?"     "<the spec>"  "haiku:simple,sonnet:medium,opus:hard"
$J score  "How severe is this finding?"            "<the finding>" "Cosmetic,Minor,Major,Blocking"

3. Symlink the folder into your Claude Code skills directory as jev. From then on /jev exists in every project and every chat.

4. Write the rule where your agents read first. Mine lives in the vault’s map (the ACE Atlas that every session loads): sort, route, gate, rank, classify: Jev first, a model second, and always a heuristic fallback so nothing breaks if Jev is down.

5. Start a log. USE-CASES.md. Every place Jev runs gets one row: date, where, question shape, result, what it saved. This is the part that compounds, and I’ll come back to it.

Where it runs: nine uses, with the numbers

Everything below is from the log. Nothing here is a demo I made up for the post.

Product: WatchNotes

WatchNotes is my tool that turns YouTube videos into notes with screenshots. It used to grab a frame every fifteen seconds and throw a third of them away as duplicates. Now each transcript paragraph gets one noul question: is the speaker showing something on screen worth a screenshot?

Six real passages:

Passage	Score
”Look at this chart, the cost drops from $10.72 to $1.33”	0.85
”Here’s the config file on screen”	0.85
”As you can see in the diagram”	0.69
”Thanks for watching”	0.10
”I was really nervous about this launch”	0.06
”Let me tell you a story about my first job”	0.02

The pipeline screenshots the top group and skips the bottom one. Anything at or above 0.7 shows up in the reader as a key shot.

Two more in the same tool. A choice between fast / standard / deep distill depth from the title and opening text (standard, 0.68) routes cheap videos to the cheap tier without a model call. And I probed eight more shapes in one sitting: sponsor filler 0.98 vs content 0.05, duplicate-video 0.92, “does this need my attention” 2.24 out of 3.

Ops: the agent dispatcher

A ClickUp board sends tasks to a coding agent on my server. Before it spends an agent run, Jev answers one noul: does this task have enough concrete detail for an autonomous agent to act on unattended? If not, it comes back to me. If Jev is unreachable, the gate fails open and the old behavior runs. Write-up coming: [coming: the ClickUp → agent dispatcher post].

My own build loop

Review triage. When Codex reviews a diff, each finding gets a choice: fix now, next pass, defer. Four findings in one session: one migration bug → fix_now at 0.83, three cosmetic → next pass. That decides what blocks a deploy without anyone re-reading the diff.

Agent tier routing. Each spec gets a choice: Haiku, Sonnet or Opus. One went Haiku at 0.97, another came back Sonnet at 0.39. Low confidence means keep the default. More on the 0.97 in a minute.

Design-system checker triage. A 4-variant × 27-check JSON dump becomes a ranked “what needs Frank” list: score for severity, choice for whether it’s a mechanical fix or needs a decision. Four real findings, all “needs a decision” at 0.91–0.97. I planted a control (a trivial case next to a WCAG violation): Minor 0.63 vs Blocking 2.86. That control is how I know it isn’t defaulting to one bucket.

Consumer migration ranking. Twelve registered consumers of my design system, scored for drift and routed to retrofit / census-only / already-in-package / retire. The live app yt-dl ranked #1 retrofit candidate (Heavy drift 2.81, 0.81). This one also produced the second mistake.

Two mistakes, two rules

The Haiku one. I summarized a spec and asked Jev whether Haiku, Sonnet or Opus should build it. 0.97, Haiku. Haiku produced a clean pure module with eleven passing tests, then wrote “ready for integration” and stopped. The spec had five steps. Four were mechanical. The fifth threaded new fields through three files and two renderers. I described the average difficulty of the task, and Jev answered the question I asked.

Rule: route by the hardest step in the spec, not the average. And when a choice comes back under 0.5, treat it as no opinion and keep your default. Never downgrade on a weak signal.

The stripped-field one. First pass of the migration ranking, I left two numbers out of the state text (colorsMatching / colorsDifferent). Jev still answered, with confidence in the 0.20–0.53 range, and one consumer with zero real drift came out a retrofit candidate at 0.92. Re-fed with the real counts, confidence jumped to 0.80–0.97 and the ranking made sense.

Rule: Jev is only as good as the state text. A missing field doesn’t produce an error, it produces a plausible wrong answer. When confidence jumps after you add a field, the first run wasn’t cautious. It was wrong.

And a calibration note from the catalogue: I asked noul whether a summary was faithful to its source and it said 0.38 about one that was. Jev is a surface-signal classifier, not a fact-checker. For judgement-shaped questions use score with a rubric and check it against twenty examples before you gate anything on it.

Wiring it safely

The pattern is fifteen lines of Python and it’s the same in every tool I’ve put it in:

import os, subprocess, requests

def jev_noul(question: str, state: str) -> float | None:
    key = os.environ.get("TYPESAFE_API_KEY") or subprocess.run(
        ["security", "find-generic-password", "-a", os.environ["USER"],
         "-s", "TYPESAFE_API_KEY", "-w"], capture_output=True, text=True).stdout.strip()
    try:
        r = requests.post("https://api.typesafe.ai/v1/systemone",
            headers={"Authorization": f"Bearer {key}"},
            json={"state": state, "model": "jev-latest",
                  "questions": {"q": {"type": "noul", "instructions": question}}},
            timeout=8)
        return float(r.json()["answers"]["q"]["noul"])
    except Exception:
        return None   # caller keeps doing what it did before

Read the key from the environment or the keychain. Eight-second timeout. Return None on any error. The caller checks for None and runs the old heuristic. That’s why I’m comfortable putting this in front of production code. The key lives on my Mac only; anything on a server fails open until I decide otherwise.

What it is not

Not a writer. Not a fact-checker. Not a replacement for Claude. It’s a reflex in front of the big model: the thing that decides whether the big model needs to be called at all, and which one. If you’re on the fence about which Claude to use for what, the Claude Ecosystem Map is the one-page version of that question.

What I’m building with it next

From the candidate list in the log, in the order I expect to hit them:

Test-subset selection. choice over test files given a diff summary, so I run the twenty relevant tests before the 1,100-test suite.
Screenshot QA gate. noul “does this rendered page show a visual regression?” from a DOM/CSS summary, a cheap pre-check before a human or Opus look.
“Needs your attention” ranking in the WatchNotes hub: score per video on transcript / frames / notes / distilled, to order the shelf.
Note-kind routing. choice note / highlight / bookmark / ask from a selected passage, so the popover pre-selects the right action.
Codex finding dedupe. noul “is this the same defect as one already fixed?” against the last handoff.
Fetcher job routing when two machines are online.

Each of those gets a row in the log when it lands, and a Friday Build episode when it’s worth showing. The tools page and built with AI are where the finished ones surface. The printable version of the three shapes and the four rules is the Jev Decision Card. [coming: episode 03 on YouTube].

Why the log matters most

Tonight’s rows in USE-CASES.md came from three agents and two chats. The next agent, in a session that hasn’t happened yet, reads that file and doesn’t re-invent any of it. A tool becomes a system when the decisions it made are written down where the next decision-maker will look.

That’s the whole method, and it’s the same one I teach for notes: capture the decision at the moment it’s made, in the place it’ll be found. Jev just made the decisions cheap enough that I stopped skipping the writing-down part.

The tools I run, in plain English

What Is Jev? — the plain-English version of this post.
What Is DeepSeek Harness? — the cheap harness Jev now routes to, and the off-peak window.
What Is Hermes Agent? — the server-side team lead behind the dispatch gate.