20 open-source-Jev-projecten die je in 2026 kunt proberen: MCP, codeeragents, browserautomatisering en meer

Jev is nog maar korte tijd openbaar, maar ontwikkelaars hebben het al geïntegreerd in codingagents, browserlussen, MCP-tools, datasetpijplijnen, games, robotica-experimenten en handelssystemen.

Dit is niet zomaar een lijst met theoretische Jev-toepassingen. De onderstaande projecten laten iets nuttigers zien: waar ontwikkelaars een beslismodel in echte software plaatsen, wat Jev mag beslissen en welke onderdelen onder deterministische code of een groter generatief model blijven.

Als je nog niet bekend bent met het model zelf, begin dan met onze uitleg over hoe Jev-beslismodellen werken. Als je op zoek bent naar bredere toepassingspatronen in plaats van afzonderlijke repositories, behandelt de eerdere gids over praktische Jev-toepassingen agentorkestratie, onderzoekstriage, browserautomatisering en andere soorten workloads.

Eén kanttekening: dit ecosysteem is nog zeer jong. Veel repositories zijn experimenten, demo's of projecten van één ontwikkelaar. Controleer de huidige repository, licentie, API-werking en veiligheidsgrenzen voordat je een ervan als productiesoftware beschouwt.

Wat deze 20 Jev-projecten daadwerkelijk testen

De projecten lijken aan de oppervlakte sterk van elkaar te verschillen, maar de meeste volgen dezelfde architectuur:

gestructureerde toestand ↓ begrensde beslissing ↓ gewoon softwarebeleid ↓ tool, model of actie

Het belangrijkste is dat Jev zelden de volledige workflow beheert. Meestal vervangt het één beperkte, vage beoordeling waarvoor anders een nieuwe LLM-aanroep of een steeds grotere verzameling heuristieken nodig zou zijn.

Codingagents worden de interessantste testomgeving van Jev

Codeeragents genereren enorme hoeveelheden tussentijdse status: bestandsinhoud, opdrachtuitvoer, stacktraces, diffs, testlogboeken en herhaalde routeringsbeslissingen. Veel van dat werk heeft geen nieuwe alinea van een frontiermodel nodig. Het vereist selectie.

1. fast-jev-compaction — Comprimeer context zonder die te herschrijven

fast-jev-compaction vervangt de gebruikelijke, sterk op samenvattingen gerichte compactionstap door relevantiebeoordelingen van eerdere toolaanroepen en resultaten.

Informatie met weinig waarde kan worden verwijderd of afgekapt, terwijl behouden opdrachten, paden, fouten en uitvoer woordelijk intact blijven. Daardoor wordt contextcompressie een selectieprobleem in plaats van een herschrijfprobleem.

De waarde zit niet in het feit dat Jev een betere samenvatting schrijft. Het voorkomt dat er überhaupt een wordt geschreven.

2. Winnow — Stop irrelevante tooluitvoer voordat die de context binnenkomt

Winnow pakt hetzelfde probleem eerder in de pijplijn aan. Grote Read, Bash of Grep resultaten worden in blokken opgesplitst en vervolgens beoordeeld op relevantie voor de taak voordat ze meer context in beslag nemen.

Het verschil met compaction is belangrijk:

• Winnow: filtert informatie terwijl die de werkcontext binnenkomt.
• fast-jev-compaction: verwijdert verouderde informatie die al in de gespreksgeschiedenis staat.

Samen laten ze twee verschillende plekken zien waar codeeragents tokenintensieve samenvattingen kunnen vervangen door begrensde relevantiebeoordelingen.

3. Jev Codex Router — Bepaal hoeveel model een taak werkelijk nodig heeft

Jev Codex Router verplaatst de beslissing een niveau hoger: voordat Codex een taak uitvoert, selecteert Jev een modelniveau en de benodigde redeneerinspanning.

Hierdoor fungeert Jev als verkeersregelaar in plaats van als codeermodel. Eenvoudig werk kan via een goedkopere route blijven lopen, terwijl moeilijke beurten kunnen worden opgeschaald.

De repository rapporteert een historische simulatie die aanzienlijke besparingen suggereert in vergelijking met het doorsturen van elke geteste beurt via de voormalige route met de hoogste kosten, maar dat cijfer moet worden gezien als een backtest en niet als een meting van de huidige Codex-quotabesparingen.

De architectuur sluit ook aan bij een bredere vraag die we eerder hebben onderzocht: of een klein model verzoeken naar grotere modellen kan doorsturen zonder zelf de uiteindelijke redeneermotor te worden.

4. Jev Review — Richt reviewaandacht op wat ertoe doet

Jev Review splitst codebeoordeling op in beperktere beoordelingen, zoals welke bestanden aandacht verdienen, welk bewijs relevant is en hoe ernstig een vermoedelijk probleem kan zijn.

Het interessante onderdeel is prioritering. Jev hoeft niet de uiteindelijke review te genereren om de workflow te verbeteren; het kan eerst een grote diff beperken tot de plekken waar diepere redenering of menselijke beoordeling de moeite waard is.

5. Blink — Door een codebase navigeren met één semantische keuze tegelijk

Blink behandelt zoeken in repositories als padselectie.

Op elk mapniveau worden zichtbare bestanden en mappen kandidaten. Jev selecteert de meest veelbelovende volgende tak voor de huidige vraag, waarna de zoekopdracht recursief doorgaat.

In plaats van vóór elke query een volledige repository in te sluiten, stelt het systeem herhaaldelijk een veel specifiekere vraag: waar moet ik nu kijken?

6. Canny — “Ik denk dat ik klaar ben” scheiden van bewijs dat het werk klaar is

Canny richt zich op claims van agents dat ze klaar zijn.

Deterministische registraties houden bij wat er daadwerkelijk is gebeurd: welke bestanden zijn gewijzigd, welke opdrachten zijn uitgevoerd, welke tests zijn voltooid en welke uitvoer is verschenen. Jev kan semantische oordelen aan dat bewijs toevoegen, maar het model wordt niet de uiteindelijke machtigingslaag.

Deze scheiding is belangrijk voor lokale agents die echte systemen kunnen aanpassen. Onze gids over vertrouwensgrenzen voor tooluitvoering legt hetzelfde principe uit op het niveau van een bredere agentarchitectuur: vaststellen dat een actie geschikt lijkt, is niet hetzelfde als toestemming geven om die uit te voeren.

MCP- en CLI-projecten maken van Jev infrastructuur

De volgende groep is minder toepassingsspecifiek. Deze projecten maken Jev beschikbaar als een herbruikbare beslissingsprimitive binnen bestaande tools.

7. typesafe-mcp — Bestaande agents rechtstreeks toegang geven tot Jev

typesafe-mcp stelt Jev beschikbaar via het Model Context Protocol.

Een Claude-, Codex- of MCP-compatibele agent kan een gestructureerd Choice-, Score- of Noul-oordeel opvragen zonder voor elke workflow een nieuwe Jev-integratie te implementeren. De agent bepaalt nog steeds wanneer de tool moet worden aangeroepen en wat er met het resultaat moet gebeuren.

8. jev-mcp — Veelvoorkomende beslissingen verpakken als agenttools

jev-mcp verhoogt het abstractieniveau door vertrouwde bewerkingen zoals classificatie, scoring, screening en matching beschikbaar te maken.

In plaats van dat elke agent een nieuwe prompt bedenkt voor hetzelfde oordeel, kunnen veelvoorkomende beslissingspatronen herbruikbare interfaces met gestructureerde uitvoer worden.

9. SemDecide — Plaats semantische logica in Unix-pijplijnen

SemDecide verkent een nog kleiner integratieoppervlak: de opdrachtregel.

grep → jq → semantische beslissing → shellactie

Dit is nuttig voor vragen die moeilijk in een regex zijn uit te drukken, maar nog te beperkt zijn om een autonome agent te rechtvaardigen, zoals de vraag of een wijziging beveiligingsgevoelig lijkt of dat een record tot een semantische categorie behoort.

De belangrijkste grens blijft deterministisch: rechten, destructieve opdrachten en veiligheidscontroles voor productie moeten in gewone code blijven.

Browser- en desktopagents: kies acties in plaats van ze te genereren

Browserautomatisering past uitzonderlijk goed bij een begrensde beslislaag. Zodra een pagina is omgezet in kandidaatelementen, bestaat een groot deel van de lus uit actieselectie in plaats van taal genereren.

10. jev-ultrafast — Alleen genereren wanneer de browser daadwerkelijk woorden nodig heeft

jev-ultrafast bouwt een geïndexeerde actieruimte op basis van de huidige pagina en laat Jev een bewerking en doelelement kiezen.

Een generatief model is alleen nodig wanneer de geselecteerde actie nieuwe tekst vereist, zoals bij het invullen van een formulierveld.

De Google Flights-demo van het project rapporteert ongeveer zeven seconden voor één voorbeeldtaak, inclusief generatie en wachttijden voor pagina's. Dat moet niet worden opgevat als een universele benchmark voor browseragents. Het belangrijkere resultaat is architectonisch: het selecteren van klikken en het genereren van tekst hoeven niet hetzelfde model te gebruiken.

11. agent-desktop — Pas hetzelfde patroon toe op native UI

agent-desktop stelt macOS-interfaces beschikbaar via toegankelijkheidsgegevens en stabiele elementreferenties.

In plaats van het bureaublad bij elke stap aan de hand van schermafbeeldingen te reconstrueren, kan het systeem Jev een begrensde set bedieningselementen en acties geven. Native tooling voert de daadwerkelijke klik-, focus- of toetsenbordbewerking nog steeds uit.

Dit is een nuttige herinnering dat betere observatie vaak belangrijker is dan een groter model.

12. json-render + Jev — Generatieve UI zonder willekeurige UI-generatie

json-render experimenteert met het gebruik van Jev om interfaces samen te stellen uit een door de applicatie beheerde componentencatalogus.

De applicatie bepaalt welke componenten, eigenschappen en acties zijn toegestaan. Jev kiest uit die kandidaten, terwijl gewone code de resulterende structuur samenstelt en valideert.

Het Jev-compositiepad blijft experimenteel, maar laat een nuttig alternatief zien voor het onbeperkt genereren van UI-JSON: laat de applicatie de woordenschat definiëren en laat het model daaruit kiezen.

Games en robotica laten zien wanneer Jev niet de controle moet hebben

Realtime systemen maken architecturale grenzen duidelijk. Fysica, botsingsafhandeling, veiligheid en snelle besturingslussen kunnen niet wachten op een onzekere modelreactie.

13. typesafe-mario — Gestructureerde spelstatus erin, legale controlleractie eruit

typesafe-mario zet telemetrie en RAM-gegevens van de emulator om in een compacte gestructureerde status, in plaats van schermafbeeldingen naar Jev te sturen.

Jev kiest vervolgens uit legale controlleracties, zoals naar rechts bewegen, springen of rennen en springen. Timingberekeningen, emulatorbesturing en het uitlezen van de spelstatus blijven bij gewone software.

De demo isoleert het beslisprobleem helder: het model hoeft de spelwereld niet vóór elke beweging opnieuw uit pixels af te leiden.

14. jev-drone — Houd het model boven de veiligheidslus

jev-drone bestuurt een autonome quadcopter door een MuJoCo-simulatie.

Snelle geometrische besturing, begeleiding en veiligheid blijven deterministisch. Jev opereert veel langzamer als adviserende tactische laag die de huidige situatie interpreteert.

500 Hz vluchtbesturing 50 Hz begeleiding + veiligheid 15 Hz camera → symbolische scène ~2,5 Hz tactisch oordeel van Jev

Het project is een simulatie, geen bewijs dat Jev een echt vliegtuig zou moeten besturen. De architecturale les is sterker dan die bewering: probabilistisch oordeel hoort boven harde realtime-veiligheidslogica te staan.

15. OneVOneJev — Een gameloop bestaat voornamelijk uit herhaalde selecties

OneVOneJev past Jev toe op een browsergebaseerde één-tegen-één-shooter.

De server beheert de fysica, netwerkverbinding en wettelijke spelstatus. Jev opereert binnen die begrensde wereld door bewegings- of gevechtsacties te kiezen.

Daardoor is het project minder nuttig als gameproduct en meer als stresstest voor herhaalde, begrensde beslissingen waarbij het produceren van uitleg in natuurlijke taal vrijwel niets zou toevoegen.

Handelsexperimenten: beslismodellen horen de wallet niet te beheren

Financiële demo's verdienen een strengere interpretatie. Een snel marktoordeel is geen bewijs van winstgevend handelen, en een experimentele bot mag niet worden verward met een gevalideerde strategie.

16. jev-trader — Eén richtingsbeslissing per Monad-block

jev-trader volgt het Kuru MON-USDC-orderboek op Monad en vraagt Jev eenmaal per block om een koop- of verkooprichting te kiezen.

Het omliggende systeem verwerkt marktgegevens, stelt limietorders op, bewaakt positielimieten en voert orders uit. Het ondersteunt ook proefuitvoering zonder privésleutel.

Die grens is het nuttige deel: Jev levert een marktoordeel; gewone software beheert nog steeds de handelsmechanismen.

17. Prism — Behandel Jev als een signaal, niet als de strategie

Prism kiest voor een meer adviserende aanpak. Jev beoordeelt marktomstandigheden, zoals flowkwaliteit, druk of mean-reversionsignalen, terwijl de strategie- en uitvoeringslagen gescheiden blijven.

Dit is een beter algemeen patroon voor workflows met grote impact: modellen kunnen probabilistisch bewijs leveren zonder zeggenschap te krijgen over onomkeerbare acties.

Zoek- en datapipelines laten zien dat Jev geen agent nodig heeft

Sommige van de sterkste projecten verwijderen autonome agents volledig. Jev wordt één semantische bewerking binnen een conventioneel algoritme.

18. neo4jev — Semantisch oordeel toevoegen aan graafzoeken

neo4jev gebruikt Jev tijdens het doorlopen van een Neo4j-kennisgraaf.

Bij elk knooppunt worden kandidaatrelaties een begrensde keuze. Jev schat in welke verbinding het meest veelbelovend is voor de huidige vraag, terwijl klassieke zoekcode de traversering, bezochte knooppunten, de beam-breedte en de stopvoorwaarden afhandelt.

Dit is een nuttig patroon dat verder gaat dan grafen: vervang één kwetsbare heuristiek binnen een bestaand algoritme in plaats van de hele applicatie opnieuw rond AI op te bouwen.

19. jev-curate — Gegevens scoren voordat je er meer rekenkracht aan besteedt

jev-curate past herhaalde semantische beoordelingen toe op JSONL- of Parquet-records voordat ze naar duurdere trainings-, analyse- of beoordelingsfasen gaan.

Datacuratie is een natuurlijke taak met veel beslissingen: miljoenen rijen moeten mogelijk worden beoordeeld op relevantie, kwaliteit of risico, maar vrijwel geen enkele rij vereist een gegenereerde alinea tekst.

Het model verzorgt de vage evaluatie; de pipeline beheert nog steeds batching, drempelwaarden, opslag en het beleid voor definitieve acceptatie.

20. killmyidea — Een kleine demo die de architectuur duidelijk maakt

killmyidea vraagt Jev om een startupidee aan de hand van meerdere gestructureerde vragen te beoordelen.

De applicatie past vervolgens gewone wegingen, voorwaarden en drempelwaarden toe om die scores om te zetten in een definitief oordeel: KILL, FIX of SHIP.

idee ↓ Jev-scores ↓ deterministische weging ↓ KILL / FIX / SHIP

Het is een klein project, maar het legt een belangrijk ontwerpprincipe bloot: AI kan nuttig oordeel toevoegen zonder verantwoordelijk te zijn voor het genereren van de uiteindelijke productoutput.

Welk Jev-project moet je als eerste proberen?

Kun je deze Jev-projecten lokaal uitvoeren?

In veel gevallen kun je het omringende project lokaal uitvoeren. Dat betekent niet dat Jev zelf lokaal draait.

In september 2026 wordt Jev benaderd als een gehoste TypeSafe-service en niet via openbaar downloadbare modelgewichten. Een lokale codeeragent, MCP-server of browsercontroller kan daarom op je eigen machine draaien en geselecteerde beslisstatus naar de Jev-API sturen.

lokale bestanden / browser / agent ↓ lokale harness of MCP-server ↓ geselecteerde gestructureerde status ↓ Jev-API ↓ getypeerde beslissing ↓ lokale software voert uit

Als het belangrijk is om het beslismodel zelf op je hardware te houden, verandert daar de architectuur. Onze handleiding voor het lokale opensource-beslismodel Laya behandelt een alternatief met downloadbare gewichten dat op lokale hardware kan draaien.

Het onderscheid is nuttig voor homelab- en private-AI-implementaties:

Dat verschil is belangrijker dan of een GitHub-README “lokaal” zegt. Een workflow kan lokaal worden gehost terwijl één beslisstap nog steeds afhankelijk is van een externe inferentieservice.

Het echte Jev-patroon is kleiner dan een agent

Het belangrijkste aan deze 20 projecten is niet het aantal toepassingen dat ontwikkelaars al hebben gebouwd. Het is hoe consequent Jev op één nauwkeurig afgebakend punt in de lus verschijnt.

Een browser weet al welke elementen bestaan. Jev kiest er één.

Een codeeragent heeft al duizenden regels tooluitvoer geproduceerd. Jev beslist wat nog relevant is.

Een router weet al welke modellen beschikbaar zijn. Jev kiest een route.

Een graaf bevat zijn verbindingen al. Jev kiest welke nuttig lijkt.

Een drone heeft al een vluchtcontroller. Jev levert een trager tactisch oordeel.

Een handelssysteem heeft al orderlogica en risicobeperkingen. Jev levert een richtingssignaal.

Daarom is de eerste golf Jev-projecten interessanter dan weer een verzameling chatbotdemo's. Ontwikkelaars testen of onderdelen van de huidige AI-stack helemaal niet meer generatief zouden moeten zijn.

De nuttige vraag is daarom niet of Jev een frontier-LLM kan vervangen.

Het gaat erom hoeveel dure, open-ended LLM-aanroepen in de software van vandaag in feite begrensde beslissingen waren die op een kleinere interface wachtten.