Jev API: wat TypeSafe's System One-model is, wat het kost en wanneer je het gebruikt

Wat Jev werkelijk is

TypeSafe introduceerde Jev op 15 september 2026 als het eerste "System One-model." De framing komt uit Kahneman's Thinking, Fast and Slow: huidige LLM's gedragen zich als een redenerend, deliberatief systeem, en TypeSafe bouwt de snelle, intuïtieve helft — behalve dat "intuïtie" hier een gekalibreerde waarschijnlijkheidsverdeling over antwoorden betekent, niet een onderbuikgevoel dat als tekst wordt weergegeven.

De naam is een Jevons-verwijzing, en de pitch is dat een snel, goedkoop beslissingsprimitief veel vaker wordt aangeroepen dan een duur.

De mechanische verschillen met een LLM zijn wat voor engineering belangrijk is:

• De output is getypeerd. Je verklaart de vorm van het antwoord vooraf — een Choice over enumereerbare opties, een Score over beschrijvende niveaus, of een Noul (ja/nee) met een waarschijnlijkheid. Er is geen vrije tekst om te parsen, en het matchen van het schema is een eigenschap van de architectuur in plaats van iets waarvan je hoopt dat het model zich eraan houdt.
• Je krijgt waarschijnlijkheden, niet alleen een keuze. Een Choice retourneert de geselecteerde optie plus een waarschijnlijkheid voor elke optie en een aparte confidence-waarde. Dat is wat je in staat stelt op onzekerheid te routeren: handel boven een drempel, val eronder terug naar een groter model.
• Vragen draaien parallel. Jev neemt de state één keer op en evalueert tegelijkertijd elke vraag in het request ertegen. Dertig vragen stellen in plaats van één voegt heel weinig wall-clock tijd toe, wat de batch-classificatie-use cases hieronder mogelijk maakt.
• Het is bewust smal. TypeSafe's richtlijn is om control flow in je code te houden en Jev atomaire, gestructureerde beslissingen te geven in plaats van één grote beoordeling.
• Output heeft geen sequentiële structuur. TypeSafe's oprichter heeft gezegd dat strings en andere sequentiële datastructuren niet zijn toegestaan aan de outputzijde, en de genoemde reden is precies dit: het is wat elke answer parallel laat berekenen, en daarom zijn er geen outputtokens om te factureren. Je kunt Jev niet vragen om een zin voor je te schrijven, en die beperking is waar de prijs op is gebouwd.

Een minimaal request ziet er zo uit:

curl -X POST "https://apimaster.ai/v1/systemone" \
  -H "Authorization: Bearer $APIMASTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "Help! My payouts have been failing for 3 days.",
    "model": "jev-latest",
    "questions": {
      "is_urgent": { "type": "noul", "instructions": "Does this convey urgency?" }
    }
  }'

Jev-specificaties in één oogopslag

Specificatie	Jev 1.13
Model-ID	jev-1.13.0
Aliassen	jev-latest, jev-preview (beide verwijzen vandaag naar 1.13)
APIMaster-endpoint	POST https://apimaster.ai/v1/systemone
APIMaster model-ID	jev-latest
Prijs	$42 per miljard inputtokens / $0,042 per 1M
Outputprijs	Gratis — alleen gefactureerd op input
Snelheidslimieten	250.000 tokens/s en 1.200 requests/minuut, opgegeven als dynamisch
Contextlengte	64k per request (state plus alle vragen); 32k voor state plus de langste vraag
Inputtypes	Tekst: string, JSON-object of array. Geen afbeelding, audio of video
Output	Getypeerde Choice-, Score- en Noul-antwoorden met waarschijnlijkheden en confidence
Client-SDK's	Python typesafe-sdk, JavaScript @typesafe-ai/sdk
Custom weights per account	Nee. Jev wordt niet fine-tuned of LoRA-aangepast met klantgegevens
Trainingsdata van klanten	Nee. Requests en responses worden niet voor training gebruikt

Waar Jev past, en wat TypeSafe in code zegt te houden

TypeSafe publiceert ook de scope van jev-1.13 in detail: negen gebieden, elk met het patroon dat het in plaats daarvan aanbeveelt, laatst herzien op 17 september 2026.

#	Gebied	TypeSafe's richtlijn
1	Letterlijk lezen — het beantwoordt de vraag die je schreef, niet de vraag die je bedoelde	Formuleer de exacte voorwaarde; zet grensgevallen in de criteria
2	Wiskunde en getallen — het is geen rekenmachine en telt niet betrouwbaar	Houd rekenen en tellen in code
3	Datum- en tijdvergelijking — datums worden als tekst gelezen, niet als geordende grootheden	Extraheer componenten; vergelijk in code
4	Indirectheid — dubbele ontkenningen en meerstapsvragen kosten nauwkeurigheid	Reduceer stappen; wijs direct naar de relevante state
5	Grote state vol irrelevante details	Filter eerst; stuur alleen wat de vraag nodig heeft
6	Adversariële content	Schrijf precieze instructies en test edge cases voordat je uitrolt
7	Tegenstrijdige instructies en criteria	Lijn de instructie en de criteria op elkaar af
8	Common-sense structurele invarianten	Stel elke beslissing op één manier; handhaaf identiteiten in code
9	Generatie	Gebruik een generatief model

Twee hiervan zijn in de praktijk het belangrijkst. Ten eerste tellen: de documentatie stelt ronduit dat jev-1.13 "niet betrouwbaar telt" — tekens in een woord, voorkomens in een passage, items in een lange lijst — en dat de fout groeit met de grootte van het getelde ding. Ten tweede generatie: Jev schrijft je samenvatting, je antwoord of je commit message niet. Het beslist; iets anders schrijft.

TypeSafe's eigen aanbevolen patroon voor tellen toont de beoogde taakverdeling: itereer over kandidaten in code, stel één Noul per kandidaat, en tel de antwoorden zelf op.

Waar de opvallende cijfers vandaan komen

Twee cijfers reizen mee met bijna elke Jev-discussie. Ze komen uit verschillende bronnen en beschrijven verschillende dingen.

0,7 seconden. Every publiceerde een stuk getiteld "TypeSafe's Jev Judged Everything I've Written in 0.7 Seconds." Build-indexen die dat artikel catalogiseren beschrijven het als 777 beoordelingen over 37 artikelen. We konden de volledige tekst van het artikel niet laden om het kostprijscijfer te bevestigen, dus behandel de kosten per run die rond die demo worden genoemd als de eigen meting van de auteur en niet als een gepubliceerd tarief.

724 advertenties, 40 seconden, ongeveer 9 cent. Deze is tweemaal gedocumenteerd. De buildpagina madewithjev.com — 724 competitor ads, broken down stelt dat 724 live advertenties van 37 merken in ongeveer 40 seconden werden geanalyseerd. De post van de auteur op X (17 september 2026) voegt de kosten toe — "used 9 cents of tokens" — en noemt de dimensies die per advertentie werden geëxtraheerd: hook, format, offer, CTA, awareness stage en landing-page mismatch.

Het onderscheid tussen de twee is het waard om te behouden: 0,7 seconden is de evaluatietijd van het model op een corpus van paragraafschaal, terwijl 40 seconden het ophalen en verwerken van 724 live advertenties omvat. Geen van beide cijfers is een doorvoergarantie voor jouw workload.

Waarmee de community het bouwt

Jev's adoptie is ongewoon makkelijk te inspecteren, omdat bijna alles wat in de eerste week is gepubliceerd open source is. De sterrencounts hieronder zijn gelezen via de GitHub API op 20 september 2026.

Browser- en computergebruik. browser-use/jev-ultrafast (★10.113) komt uit de browser-use-organisatie en is het project dat de toon zette. Het stelt een vaste actieruimte beschikbaar (CLICK, TYPE_TEXT, SELECT, SCROLL_UP, SCROLL_DOWN, WAIT, DONE, BLOCKED) en vraagt Jev om zowel de operatie als het doelelement te kiezen. Beide beslissingen gaan in één TypeSafe-request, waarbij de doelelement-vraag als speculatief is gemarkeerd. Alleen TYPE_TEXT roept een tekstmodel aan, en het voorbeeld in de README gebruikt daarvoor een klein model. De demonstratietaak — Zürich naar Londen op Google Flights — wordt opgegeven als 7,1 seconden inclusief tekstgeneratie en paginaloads. Er zijn geen sitespecifieke scripts.

Contextcompressie voor coding-agents. tamaratran/fast-jev-compaction (★4.544) bepaalt welke tool-resultaten in een transcript van een coding-agent nog de moeite waard zijn om te bewaren, zodat een lange sessie kan worden gecompacteerd zonder een volledige samenvattingspass. Er bestaan ports en varianten voor andere agent-harnesses.

Agent-guardrails. DevMortimer/pi-warden (★99) en shiftynick/jev-axi (★17) plaatsen beide een beoordeling vóór elk commando of elke tool-call: vraag eerst, blokkeer de gevaarlijke. Dit is het patroon waarbij "gekalibreerde waarschijnlijkheid plus een drempel in je eigen code" echt beter is dan een tekstantwoord dat je moet interpreteren.

Modelroutering. vinilana/jev-gateway (★61) routeert eenvoudige requests naar een laagkostenniveau en escaleert alleen de moeilijke. Het is de meest directe uitdrukking van TypeSafe's eigen argument — dat een beslissing een fractie kan kosten van de generatie die het poort.

Games en control-demo's. fhshaik/typesafe-mario (★289) speelt Super Mario Bros. op basis van gestructureerde emulator-state, en RomanSlack/jev-drone (★81) draait een drone-control-loop in MuJoCo. Deze verspreiden zich veel sneller dan ze worden uitgerold; behandel ze als demonstraties van de interface, niet als bewijs over productiebetrouwbaarheid.

Open reproducties. Dit is de interessantste thread voor iedereen die de capaciteit wil zonder een nieuwe leverancier. TheoLeeCJ/SemIf (★2.123) draait een open model op een enkele RTX 3090 thuis en is expliciet dat het onafhankelijk is van TypeSafe. TianyuCodings/NanoJev (★1.175) is een kleinschalige reproductie. convaiinnovations/laya is een Apache-2.0, commercieel bruikbaar classificatiemodel getraind met RLCD, gepubliceerd onder de tags system-one en calibrated-decisions, met een bijbehorende runner in receptron/laya. Geen van deze is Jev, en de benchmarkgrafieken die ze publiceren zijn hun eigen; het punt is dat de vorm van het model reproduceerbaar is.

Batch-classificatie. De advertentie-analyse hierboven is het voorbeeld bij uitstek, en het is het patroon dat het meest waarschijnlijk contact met productie overleeft: houd de state vast, stel veel nauwe vragen in één request, en lees de waarschijnlijkheden.

Is Jev echt goedkoper dan een goedkope LLM?

Niet per inputtoken, en dit is het deel dat de meeste artikelen overslaan. Jev rekent $0,042 per 1M inputtokens. Op APIMaster is gpt-5.6-luna in de aanbieding vanaf $0,022 per 1M inputtokens — ongeveer de helft van Jev's inputtarief — met glm-5.3-flash op $0,105 en deepseek-flash op $0,15. De goedkoopste gehoste generatieve modellen onderbieden Jev al op inputprijs.

Jev's kostenargument rust op drie andere dingen:

• Geen outputtokens. Het goedkoopste generatieve model zendt nog steeds tekst uit voor elke beoordeling, en output is meerdere malen hoger geprijsd dan input. Jev retourneert een waarschijnlijkheid en stopt.
• Latentie. TypeSafe publiceert end-to-end responstijden van 70ms tot 500ms en beschrijft de vergelijking met frontier-modellen op System One-vormige queries als 40× tot 200× sneller. Snelheid is wat een beslissing in een requestpad laat draaien in plaats van achter een wachtrij.
• Marginale vragen zijn bijna gratis. Omdat vragen parallel over één state uitwaaieren, kost de tiende vraag een fractie van wat een tiende API-call zou kosten.

Of dat wint, hangt van je workload af. Als je beoordelingen weinig, lang en gebaat bij redeneren zijn, is een goedkope LLM met gestructureerde output de betere koop. Als je veel korte beoordelingen per werkeenheid maakt, of het antwoord nodig hebt voordat een gebruiker een pauze opmerkt, verandert de rekensom.

Hoe roep je Jev aan op APIMaster?

Niet tegen TypeSafe's eigen endpoint, en het verschil is structureel in plaats van een kwestie van configuratie:

• Andere route. TypeSafe documenteert één evaluatie-endpoint, /v1/systemone, en een /v1/models-listing. Er is geen gedocumenteerde /chat/completions.
• Andere body. Het request draagt state en een map met getypeerde questions. Een OpenAI-achtige body draagt messages en verwacht gegenereerde tekst terug.
• Andere response. Je ontvangt waarschijnlijkheden en confidence-waarden met de vraagnamen die je hebt gekozen als keys, niet een completion-string.

Op APIMaster gebruik je het native System One-request hierboven met een APIMaster-key en jev-latest. Er is geen vertaallaag nodig voor die API-vorm. Het OpenAI-compatibele endpoint blijft nuttig voor de tekstgenererende helft van een pipeline, maar het is niet de manier om Jev zelf aan te roepen.

Wat je vandaag kunt draaien als je snelle beoordelingen nodig hebt

Als wat je feitelijk nodig hebt een beoordeling is via een bestaand OpenAI-compatibel endpoint, is de praktische vraag naar welk laagkostenniveau je het stuurt. Live APIMaster-routes per 20 september 2026:

Model-ID	Routes in de aanbieding	Vanaf (input / output per 1M)	Referentielijstprijs	Geschatte korting
gpt-5.6-luna	3	$0,022 / $0,134	$0,20 / $1,20	~89% korting
glm-5.3-flash	3	$0,105 / $0,35	$0,15 / $0,50	~30% korting
deepseek-flash	1	$0,15 / $0,60	Gelijk aan DeepSeek off-peak	Geen opslag
gpt-5.6-terra	15	$0,12 / $0,72	$2,00 / $12,00	~94% korting
gemini-3.8-flash	7	$0,20 / $1,00	$1,50 / $7,50	~87% korting

Jev is live als de getypeerde beslissingslaag; de niveaus hieronder zijn voor de tekstgenererende of escalatielaag. Drie opmerkingen bij het lezen van die tabel. Prijzen zijn de laagste route in de aanbieding op het moment van controle, en verschillende routes voor hetzelfde model hebben verschillende prijzen — open de modelkaart voordat je volume vastlegt. deepseek-flash is geprijsd tegen DeepSeek's eigen off-peak tarief, dus de eerlijke formulering is "geen gateway-opslag," niet een korting. En een lagere inputprijs is niet automatisch de goedkopere keuze: outputlengte, cache-hit gedrag en retry-percentage domineren meestal de uiteindelijke rekening.

Een werkbare verdeling voor een Jev-achtige pipeline op één key:

1. Zet de nauwe, hoogfrequente beslissing op een klein, laagkostenniveau en poort op je eigen confidence-drempel.
2. Escaleer alleen de gevallen die onder die drempel vallen naar een sterker model.
3. Houd tellen, rekenen en datumvergelijking in je eigen code — hetzelfde advies dat TypeSafe geeft, en het geldt voor elk model in de tabel.

Maak een APIMaster-account aan, voeg pay-as-you-go-tegoed toe vanaf $1, maak een key aan in de console, en richt een OpenAI-compatibele client op https://apimaster.ai/v1 met een van de model-ID's hierboven. Eén key dekt de GPT-, GLM-, DeepSeek-, Gemini- en Claude-families, zodat het escalatiepad in stap 2 op dezelfde integratie blijft. Valideer een route met de model-tester voordat je productieverkeer verplaatst.

FAQ

Wat is Jev? Jev is het System One-model van TypeSafe AI. Het neemt een state plus een map met getypeerde vragen en retourneert gekalibreerde waarschijnlijkheden — Choice-, Score- en Noul-antwoorden — in plaats van gegenereerde tekst.

Is Jev een taalmodel? Nee — en TypeSafe's eigen formulering is stelliger dan dat. In de launch-thread beschreef de oprichter het als "een gestructureerd datamodel, maar technisch geen taalmodel (het genereert geen taal)". Het leest de tekst die je stuurt en retourneert getypeerde beslissingen met waarschijnlijkheden en confidence-waarden, en het genereert nooit proza. TypeSafe plaatst het naast RLHF-chatmodellen en RLVR-redeneermodellen als een derde categorie in plaats van als een kleinere versie van een van beide.

Wat is het Jev-model-ID? jev-1.13.0. De aliassen jev-latest en jev-preview verwijzen momenteel naar dezelfde versie; de SDK's gebruiken standaard jev-latest.

Hoeveel kost Jev? $42 per miljard inputtokens, wat $0,042 per 1M inputtokens is. Outputtokens zijn gratis, en facturering is alleen op input.

Is Jev OpenAI-compatibel? Nee. Het gebruikt een toegewijd POST /v1/systemone-endpoint met een state plus questions-body en retourneert waarschijnlijkheden in plaats van completions, dus een OpenAI-achtige client kan het niet ongewijzigd aanroepen. Roep op APIMaster dezelfde native vorm aan op https://apimaster.ai/v1/systemone met jev-latest.

Is Jev beschikbaar op APIMaster? Ja. Gebruik model-ID jev-latest met POST https://apimaster.ai/v1/systemone; de live prijs is $0,042 per 1M inputtokens en $0 output. Zie de Jev-marketplacekaart voordat je het in productie gebruikt. Combineer het met een tekstmodel zoals gpt-5.6-luna, glm-5.3-flash, of deepseek-flash wanneer een taak ook gegenereerde tekst nodig heeft.

Ondersteunt Jev Chinees en andere niet-Engelse talen? TypeSafe stelt dat Engels de primaire trainings taal is en waar de nauwkeurigheid momenteel het beste is, en dat andere talen waaronder CJK worden behandeld maar niet even goed. De documentatie zegt dat je op je eigen content moet testen en de confidence-waarden in de gaten moet houden bij het routeren.

Kan ik Jev fine-tunen op mijn eigen data? Nee. TypeSafe fine-tuned of LoRA-aangepast Jev niet per klant, en traint niet op klantrequests of -responses. Domeingedrag wordt gevormd via de state, instructies en criteria in elk request.

Welke taken moet ik uit Jev houden? TypeSafe publiceert er negen: letterlijk lezen, wiskunde en getallen, datum- en tijdvergelijking, indirectheid, grote states vol irrelevante details, adversariële content, tegenstrijdige criteria, common-sense structurele invarianten en generatie. Tellen en rekenen horen in je code.

Kan ik een alternatief self-hosten? Er zijn open reproducties — SemIf, NanoJev en de Apache-2.0 laya-encoder onder hen — maar het zijn onafhankelijke projecten met hun eigen benchmarks, niet Jev. Behandel gepubliceerde vergelijkingen als de eigen metingen van de projecten.

Wanneer moet ik Jev gebruiken in plaats van een goedkope LLM? Wanneer de beslissing nauw en getypeerd is, je hem vaak maakt, en je hem binnen honderden milliseconden terug wilt in plaats van seconden. Voor redeneren met lange context, generatie, of alles wat rekenen vereist, is een goedkoop generatief model de betere keuze.

Bronnen en verdere lectuur

• TypeSafe — Models — model-ID, aliassen, $42/Btok-prijzen, snelheidslimieten, contextbudget, taalondersteuning en dataverwerking
• TypeSafe — Jev 1.13 jaggedness — de gebieden die TypeSafe buiten scope plaatst, met het aanbevolen patroon voor elk, herzien op 17 september 2026
• TypeSafe — API reference en Quick start — endpoint, request- en responsevormen, SDK-gebruik
• TypeSafe — Introducing System One Models and Jev — launchpost, de end-to-end figuur van 70–500ms en de vergelijking van 40×–200×
• Hacker News-discussie — 1.918 punten op de launch-thread
• browser-use/jev-ultrafast — actieruimte, het single-request-ontwerp voor operatie en doel, en de Google Flights-demonstratie
• Made with Jev — 724 competitor ads, broken down — de buildpagina voor advertentieanalyse, met de post van de auteur
• Every — TypeSafe's Jev Judged Everything I've Written in 0.7 Seconds
• Hugging Face — convaiinnovations/laya en TheoLeeCJ/SemIf — open, onafhankelijke reproducties

TypeSafe's modeldocumentatie en scope-opmerkingen zijn gecontroleerd op 20 september 2026. APIMaster's jev-latest-route en prijzen zijn gecontroleerd op 21 september 2026. Prijzen, snelheidslimieten en projectstatus veranderen — verifieer op de live kaart of de eigen pagina van de leverancier voordat je een workload vastlegt.