Recipe: The Jev → LLM Front-Filter Pipeline

This is the foundational Jev pattern — the one every early-access demo converged on. Master this and most use cases on this site are just instances of it.

Based on early-access reports — verify API details against official docs at jev.com. This recipe describes an architecture pattern, not specific endpoints or parameters.

#The pattern

                ┌─────────────────────────────────────────────┐
 items (all) →  │  JEV STAGE: judge every item, cheaply        │
                │  yes/no · one-of-N · score                   │
                └─────────────────────────────────────────────┘
                       │ keep            │ discard/route
                       ▼                 ▼
                ┌─────────────┐   (archive, log, human queue,
                │  LLM STAGE:  │    cheap handling — no LLM)
                │  generate    │
                │  only for    │
                │  survivors   │
                └─────────────┘

Two stages, one rule: the expensive model never sees an item the cheap model has already rejected.

#Step 1 — Design the judgment

Write the filtering decision as one closed question per stage:

• Binary gate: "Does this item meet the bar for expensive processing?" → yes/no
• Triage: "Which lane does this item belong to?" → one of N labels, where one lane is "no LLM needed"
• Rank-then-cap: "Score this item 0–100" → send only the top K (or score ≥ threshold) to the LLM

Keep the input fields minimal and structured: exactly the signals the decision needs, nothing more. Judgment quality tracks question clarity.

#Step 2 — Set the routing rules

Every verdict must route somewhere. A complete rule set for a triage judgment looks like:

Note the subtlety: the LLM is not only for "passing" items. A well-designed pipeline also spends LLM budget on the uncertain band, where nuance is actually worth paying for.

#Step 3 — Measure the filter rate

The economics live or die on one number: what fraction of items still reach the LLM. Track it from day one.

• Filter rate 95% → LLM spend drops ~20× before counting Jev's lower per-call cost.
• Filter rate 50% → still a 2× saving, but check whether your question is too permissive.
• Filter rate drifting over time → input distribution shifted; revisit the judgment design.

Early demos claimed headline figures like "400X cheaper" (Jack Roberts) — achievable when the filter is aggressive and the LLM stage is genuinely expensive. Run your own arithmetic on your own volumes.

#Step 4 — Guard the boundary

• Log discarded samples and spot-check them weekly. A silent filter that starts dropping good items is worse than no filter.
• Version your questions. Judgment prompts/configs are code: review changes, keep history.
• Define an escape hatch. Some class of items should bypass or override the filter (VIP senders, legal holds, safety-critical flags).

#Variations

• Chain of judges: several cheap Jev judgments in sequence (language? → on-topic? → quality bar?) before the LLM — each cheaper than the last failure it prevents.
• Judge after, too: use a judgment pass on the LLM's output (did it answer? is it safe to send?) before delivery.
• Score-aware routing: high scores go to the strongest model, mid scores to a cheaper one, low scores to none.

#Sources

• "Jev + GPT-6 Astra = 400X Cheaper" — Jack Roberts (~21K views, 11 hours) — the front-filter cost argument: rapid, low-cost micro-decisions feeding frontier models.
• "Jev is HERE. How to use it" — Greg Isenberg (~293K views, 1 day) — classification-first usage patterns.
• "Jev: The New AI Model That's Breaking The Internet (Full Tutorial)" — Moritz (~43K views, 2 days) — applied demos built on this pattern.

Unofficial fan-made handbook. Not affiliated with TypeSafe AI or jev.com. Jev is a trademark of its respective owner.