JEVATHON (w/ The AI Collective)

asdsad

Banana Eater

asd

LlamaIndexCognitionBrowserbase

Gustave, the voice shopping assistance

Gustave

Online shopping means typing, filtering, scrolling and comparing across tabs. And most "shopping assistants" just swap the search bar for a chat box: type, wait, see three products, type again, wait again. In a store, you just talk, and someone starts pulling things off the rack while you're still talking. Every reaction you give sharpens what they bring next. Meet Gustave: a voice shopping assistant that recreates that natural, iterative experience.

TypeSafe AI

Explore project

Worth Your Saturday

Worth Your Saturday is a decision-intelligence prototype that helps people discover what they actually won’t compromise on before spending their time. Using apartment hunting as the demo, Jev speculatively evaluates 1,872 evidence-level distinctions across five apartments; as a conversation clarifies the user’s priorities, the same evidence fields are re-projected with zero additional Jev evaluations to surface meaningful matches, tradeoffs, and unresolved questions. The result isn’t another ranked list—it’s a realistic Saturday of tours worth taking, delivered through an agent connected to iMessage with Photon Spectrum. The broader primitive is intent-conditioned salience: evaluate evidence broadly, discover what matters to the person, preserve consequential uncertainty, and allocate scarce human attention accordingly. Https://worth-your-saturday.vercel.app

TypeSafe AIPhoton

Explore project

Recording

UnSlop

Slop isn't just AI, it can also be human. Unslop will input a website and cut out all the ineffective fluff/slop with context decisions and browserbase lookup centered around jev decision making.

TypeSafe AIBrowserbase

Explore project

Recording

KYC Sentinel

KYC-Sentinel

KYC Sentinel: adverse-media screening for AML/KYC analysts. Jev judges, code decides, the LLM only writes. Compliance analysts waste hours clearing irrelevant news hits: same-name strangers, victims, passing mentions. KYC Sentinel pulls news for every client in a portfolio. Jev (TypeSafe AI) judges each client–article pair: same person? the perpetrator? what risk? how severe? A pure, unit-tested router then sorts every client into CLEAR / REVIEW / FLAGGED / NO_COVERAGE. • Fails closed: any uncertainty or model error means REVIEW, never CLEAR. • Autonomy Dial: a compliance manager drags strictness and the whole portfolio re-routes instantly from stored Jev probabilities, with zero new model calls. • Thresholds live in code, not prompts. The LLM only writes analyst memos, on demand, for flagged/review clients, citing sources. It never decides. • Full audit log of every decision, plus a live receipts meter. Results on a 26-client portfolio: 37 Jev calls, 0 errors, 0.9s, $0.0011, about 145× cheaper than the same job on a frontier LLM (est. $0.16). Famous-name collisions (Michael Jordan, Michael Cohen) are cleared as "different person" even when the other person's news is damning. Victims and identity-theft targets are cleared as "not the subject". Vague common-name mentions go to REVIEW. Documented fraud cases and a Tulsa accountant who shares Taylor Swift's name are surfaced, while the pop star's news is ignored. Stack: Jev (TypeSafe AI), FastAPI, GDELT, Gemini for memos, vanilla JS. 77 tests. Data note: GDELT rate-limited our network, so several clients use clearly labelled synthetic articles (domain synthetic-demo.local). Everything downstream runs identically.

TypeSafe AI

Explore project

Recording

Beethoven

A live band you conduct with paintings: arrange artworks on a musical staff, and every bar an AI conductor (TypeSafe Jev) decides how the band plays while Google's Lyria RealTime generates the music. Painting Band 🎨🎶 Arrange paintings on a staff. A playhead sweeps across. Every bar, an AI conductor decides how the band plays, and an AI music model plays it live. Nothing is pre-recorded. The music is generated live from what's on the canvas. How it works 1. See: Gemini looks at each painting and writes how it should sound: mood words, sound ideas (e.g. "cascading koto arpeggios"), instruments, and the painting's musical tradition (Japanese, Hindustani, Western…). Upload your own image and it's described in about 2–3 s. 2. Arrange: Drag paintings onto the staff. - Left → right = when a painting plays - Height = register (high or low) - Size = how strongly its mood and sounds lead 3. Conduct: Every bar (2.7 s), TypeSafe Jev answers up to 12 typed questions in parallel in 150–300 ms: - how loud each painting should be, and the mood and energy - drums, bass and the lead instrument - two extra sounds and the transition - which culture leads when traditions mix Jev never plays notes; it only decides. 4. Play: Jev's choices become weighted text prompts plus density, brightness and mute settings for Google Lyria RealTime, which streams AI-generated 48 kHz audio and blends toward each new decision. The music changes when you move, resize, add or remove a painting. Architecture - Deciders never make sound; engines never make decisions. Code sits in between. - Deadline-safe: if Jev is later than 150 ms before the next bar, the band reuses the last bar's choices, so the music never stops. - Always playing: if Lyria stalls, the app switches to Strudel (a browser-based live-coding music engine) mid-song, and you can switch back with one click. - Explainable: the panel shows each bar's questions and Jev's odds for every option, the exact prompts sent to Lyria, what Gemini saw in each painting, and a live log of every model call. Features - Drag, resize and delete paintings; draggable playhead (Home = start) - Silence where there's no painting under the playhead - Upload any image; Gemini describes it (with automatic model fallback when busy) - Cultural awareness: each painting's musical tradition shapes the sound, and Jev picks which tradition leads - Jev vs. Rules toggle (keys J/R) to hear the difference judgement makes - Live stats: Jev latency, missed bars, and cost ($0.00001 per bar) Tech stack - Vite + React + TypeScript - TypeSafe Jev: per-bar decisions (/v1/systemone, typed choice answers with confidence) - Google Gemini: image understanding (structured JSON output) - Google Lyria RealTime: streaming music generation (@google/genai) - Strudel: fallback engine (@strudel/web, General MIDI soundfonts) - API keys stay server-side behind a Vite proxy (except Lyria, which streams from the browser in this local demo) Run it Open and drag a painting onto the staff. Paintings Seven public-domain works from Wikimedia Commons: Hokusai, Monet, Van Gogh, Bruegel, Seurat, Rembrandt and Raja Ravi Varma.

TypeSafe AIGMI

Explore project

Recording

Reinforcement Learning for Enemy ai

a 2D platformer where every decision and every physics tick goes through jev, a physics/AI backend (currently a local mock, swappable for the real service). You have 30 seconds to reach the flag as many times as possible. Deaths respawn you — the clock doesn't stop. High score persists across sessions. Everything runs through jev: - step — all physics: player, bullets, monsters (gravity, velocity, AABB collision) - aim — two turrets that study your recent movement history and adapt after misses (leading runners, ambushing campers, shooting landing spots of jumpers) - decide — two flying monsters that dash every second in 2D, intercepting where your velocity says you'll be - reset — wipes all learned state on a new game (N); respawns keep the memory — the enemies keep learning mid-run Controls: ←→/A/D move · Space jump · R respawn · N new game How the game talks to jev The context stream — history Every frame, game.js appends one sample: It's a rolling 12-second ring buffer (HISTORY_SECS), 720 samples of your position and velocity — the raw material for every enemy decision. Nothing else about you goes over the wire; habits are computed from this stream, on jev's side. The three decision channels (all async, all JSON request/response): step — physics. The game never moves anything itself. Player, both monsters, and every bullet are each submitted as {x, y, w, h, vx, vy, noGravity?} plus the level's solid rects and dt. jev returns resolved positions and contact flags; the game applies them verbatim. noGravity: true on a body = flight (monsters, bullets share the same solver, gravity skipped). aim — the shooters. Per frame, per turret: the request carries the turret's id and muzzle, the full history buffer, now, and report — the outcome of its last shot ({hit: true|false}). That's the feedback loop: jev answers fire: false while its 2 s cooldown runs, or {fire: true, dir, target, mode} where mode names the tactic it picked (lead runner-prediction, zone bombardment of your favorite territory, anti-jump at your landing spot). Each turret has an independent cooldown by id, but hit/miss learning is shared — what one learns, both use. decide — the dashers. Per frame, per monster: id + offset give each its own 1-second cadence, phase-staggered (m1 is offset 0.5 s so they don't dash in lockstep). The request has the monster's pos and the same history. jev reads the last 1 s of samples, averages your vx/vy, and returns a normalized 2D dir plus the impulse — it intercepts where you're heading, including vertically (swoops up at jumpers, dives at fallers). idle between pulses; the game dampens velocity 0.94×/frame. The loop in one breath: the game is a sensor array and a renderer — it records what you do, asks jev what everything should do next, and draws the verdict. The mock computes the brains locally; set endpoint in jev.config.js and the identical JSON POSTs to {endpoint}/step|aim|decide|reset. The tactic word in the HUD — zone, lead, or anti-jump changes based on what you just did (standing still → zone, running → lead, jumping → anti-jump) - Shots get more accurate over a run — every miss feeds back to jev, which adjusts where the next bullet aims; the target coordinates in the HUD shift after each miss - N resets it — new game wipes the memory and the enemies go back to firing dumb straight shots That's the whole story: the turret's aim line in the HUD is literally jev telling you what it learned.

The AI Collective

Explore project

Recording

Sreak

Real-time persuasion training game — talk your way past an AI guard, investor, or friend, and every sentence is instantly scored and reacted to.

TypeSafe AI

Explore project

Recording

JAPA (Jev-based Article Political Analysis)

HaleStorm

I built a web app that uses jev plus browserbase to analyze the claims, entities, statements, laws etc that are discussed in published political articles with a recurssive jev + browserbase research engine to investigate claims, analyze related articles, and display all the results in a unified exploratory UI in near real-time

TypeSafe AIBrowserbaseThe AI Collective

Explore project

Blamejev

kvsudhersan86@gmail.com

Blamejev Ask any git repo's history a question in plain English and find the commit responsible, without paying an LLM to read every diff. Problem - Vibecoded apps pile up hundreds of "Fix error" bot commits - Owners don't know the code's words, so git log -S, blame, and bisect don't help - Coding agents pay to read diff after diff, mostly irrelevant How it works - Plain code turns each commit into a 60-token fingerprint - TypeSafe Jev makes cheap, calibrated yes/no calls: which folders, which fix loops, which commits - A keyword safety lane and minimum budgets keep the right commit from being pruned - A Fireworks LLM verifies only the 5–15 shortlisted diffs - "When did it start" mode jumps through history in parallel

TypeSafe AI

Explore project

Recording

AntiFlood

keikoku

Live triage of building-management alarms with Jev (TypeSafe). The design is in jev-alarm-triage-spec.md; the original static mock-up is alarm-triage-poc.html. This build replaces the mock-up's scripted answers with real Jev calls behind a Python backend.

TypeSafe AI

Explore project

Recording

tired commuter

tiredcommuter

Commute Copilot A live, text-message commute decision assistant for San Francisco — built for JEVATHON. Text it where you're headed. It pulls real live transit data from multiple independent public sources, and Jev picks the option that actually gets you there most reliably — with a calibrated confidence score, not just a list of times. The problem Google Maps optimizes information — it shows you routes and ETAs and leaves the judgment call to you. It also has real, specific gaps: ferry options are inconsistently surfaced, and it has no concept of what you're actually trying to do next. Meanwhile, real commuters (the author included) routinely get left behind by buses whose live conditions diverge from the static schedule. Commute Copilot is the decision layer on top of the data Maps already has: given real-time bus positions, a fixed ferry schedule, live bike/scooter availability, and what you actually told it, Jev picks — and explains its confidence — instead of handing you a list. Live - Dashboard: - iMessage: ask in Discord / at the table for the live demo number Architecture | Layer | Source | Why this one | |---|---|---| | Bus/Muni (live) | 511.org Vehicle/Stop Monitoring API | Real GPS + live delay data, free, official — no scraping needed | | Ferry | Golden Gate Ferry fixed schedule | Ferries run a locked schedule; the gap is that Maps under-surfaces this, not that the data is hard to get | | Bike/scooter (live) | GBFS free_bike_status feed (Bay Wheels) | Open, standardized, no-auth format used by most bike-share systems | | Traffic incidents (live) | 511.org Traffic Events API | Real active incidents with coordinates, same token as transit | | Destination geocoding | OpenStreetMap Nominatim | Free, no key, turns "Mill Valley" into real coordinates | | Google Maps comparison | Browserbase + Stagehand | The one thing with no free API — scraping is the only way to get Maps' own live answer, used as an honest comparison baseline, not a data source we depend on | | Decision engine | Jev Choice primitive | Given the live options + your stated goal, picks (and ranks) the best one with a real probability distribution | | Interface | Photon / Spectrum | One agent, delivered over iMessage — no app to open | | Dashboard | Next.js on Vercel | Same data + decision logic, visualized: live map, colored route options, Jev's pick highlighted in green, live vs. Maps side by side | Why Jev specifically, not a general LLM: every decision here is a discrete choice among a small, known set of options (this bus vs. this ferry vs. a scooter), re-evaluated as conditions change — not a search/optimization problem. That's Jev's exact shape, and its cost profile ($0.042/MTok input, output free, 70–500ms) is what makes it viable to re-run this on every message instead of caching a single answer. What's real vs. what's simplified - Real: every data source above is live and independently verifiable — open the same public URLs yourself and the numbers will match what the app just used. - Origin is fixed to the CodeRabbit office (201 Spear St) for this demo — there's no GPS/location-sharing available through iMessage, so the destination comes from what you type and the origin is a known fixed point rather than fabricated. - Route paths on the dashboard are straight-line legs, not turn-by-turn routing — there's no free turn-by-turn API in scope for a 3-hour build. - Ferry ETA on the dashboard's trip planner uses the fixed schedule as a same-day approximation, not a live feed (ferries don't have one — they're not late). Running it locally Needs a .env (agent) / .env.local (dashboard) with PROJECT_ID/PROJECT_SECRET (Photon), FIVE_ELEVEN_TOKEN, TYPESAFE_API_KEY, and BROWSERBASE_API_KEY. What's next - Real origin detection (would need a proper app with device location, not just text) - Calendar/Luma integration so the deadline comes from your actual schedule, not something you type each time - Expand beyond SF: the architecture (live feed → geocode → Jev choice) is not SF-specific, just the specific data sources wired up today are License MIT

TypeSafe AIBrowserbasePhoton+1

Explore project