10 Wild Things You Can Build With Jev

0:00 Watch this. A browser opens Google Flights on its own, types Zurich to London, sets a date, and pulls up the results. About 7 seconds, and that clip is playing at normal speed. The whole

0:10 search cost around a third of a cent, and the thing driving the browser isn't a chatbot. It's a new model called Jev, and Jev can't write you a single sentence. That isn't a limitation

0:20 somebody forgot to fix. The lab that made it, Type Safe, built it that way on purpose. Jev doesn't produce text, it makes decisions. Type Safe came out of 2 years of stealth on September 15th with

0:31 40 million in funding and this one strange idea. Within 6 days, people had bolted it onto everything from Mario to an air traffic control tower. To be clear on the timeline, this all happened

0:42 between September 15th and about the 21st. One launch, then a flood. That speed is a big part of the story. I pulled the 10 best builds from that week. We'll start with the useful ones,

0:53 work up to the ridiculous ones, and I'll show you how each actually works instead of just pointing at a demo. Then the part I didn't expect, somebody rebuilt the whole idea as open source over a

1:03 weekend. And at the end, the real question, whether any of Jev's big claims survive contact with someone outside the company. Start with the model, because

1:12 it reframes everything after it. A normal language model writes one word at a time, left to right. Ask it a yes or no question, and it still spins up the whole sentence

1:21 machine just to say yes. Jev is what Type Safe calls a system one model. You give it the current state of your program and a set of questions, and every question comes with a fixed menu

1:31 of allowed answers. It reads all of it in one pass and returns each answer with a probability attached. Say your agent lands on a page and you ask two things at once, which

1:40 button do I click and is the form finished? Jev answers button four at 91% and not finished in a single shot in well under a second. No paragraph, just the pics. The person behind it is Diogo

1:53 Almeida, who was on the original team that built ChatGPT. His argument is almost a confession. Superhuman chat didn't deliver what it promised, so he went the other way toward a model that

2:04 decides instead of talks. His framing borrows a split from psychology. Fast automatic judgments on one side, slow deliberate reasoning on the other. Chat models chase the slow talkative kind.

2:15 Gev is built for the fast automatic kind, the thousands of tiny calls software makes that didn't need a paragraph in the first place. How it's trained matters for later. Typesafe

2:24 calls it reinforcement learning for calibrated decisions. Think of a weather forecast. If it says 90% chance of rain, it should rain about nine times in 10. Calibrated means Gev's confidence is

2:34 honest the same way, and hold that word because it comes back. The pricing is the flex. 4 cents per million words of input, and the output side is free because a typed choice is too small to

2:45 bother billing. A normal model charges for every word it writes. Gev barely writes anything, so there's almost nothing to charge for. Put real numbers on it. A million small decisions from

2:56 Gev cost you 4 cents, and each call comes back between 70 and 500 milliseconds. Ask a normal chat model to make those same million judgments, one wordy answer at a time, and you're into

3:07 dollars and long minutes of waiting. So, back to those flights. The project is called Gev ultrafast from a team named BrowserUse, and why it's fast is the part worth understanding. Most web

3:17 agents work like this. Take a screenshot, send the picture to a big model, then wait while it says what to click, do it, and repeat. Every step is a slow expensive round trip. Gev

3:28 ultrafast throws out the screenshot. It hands Gev a numbered list of everything clickable on the page and asks one thing, which action and which element number. When the action is type some

3:38 text, a tiny separate model fills in the actual keystrokes. Same flight search their old agent ran, the browser used to talk to the page about 1,100 times. With Gev choosing the

3:48 moves 101. 9 and 1/2 seconds became 7. Under 4/10 of a cent a run. 9,000 people started in 3 days. Two things worth noting from the team. The whole project is open source under a permissive

4:00 license, and the founder pointed out the demo runs at real speed. No editing tricks. Even the calls to Jev itself dropped from 22 down to 17. If the flights are the sensible use,

4:12 Fede Al Shake built a gloriously silly one. He got Jev to play Super Mario Brothers. The clever move is that Jev doesn't see the screen. The emulator hands it a description instead. Mario's

4:22 position, how fast he's going, whether he's mid-jump, the nearest enemy, and when it'll reach him, the gap coming up. Every eight frames, Jev picks from seven moves. Stand still, go right, jump, run,

4:34 run and jump. It also answers a side question each time. Roughly, how dangerous is this exact moment, which nudges whether it should leave the ground. Can it finish the level? There's

4:44 no clean run posted start to finish, so I won't tell you it beat the game. What you can watch is a model that thinks in fast reactions, keeping Mario alive in real time. Which shouldn't

4:54 really work as well as it does. So, that's the pattern. Hand Jev a state in a menu, get a quick decision back. Now, the builds you might actually install, the developer tools. Tony Din, an indie

5:05 developer with a long list of shipped tools, made a Chrome extension that skips the sponsor read in a YouTube video for you. Not from a crowd list of timestamps, it listens and decides,

5:15 second by second, is this the sponsor or the actual video? By his own estimate, it runs about half a cent per video. The code is public if you want to poke

5:24 at it, though there's no license on it yet, so don't ship on top of it without checking first. Marcel Poshau, who runs a developer tools company, aimed it at the folder where all a little ashamed

5:33 of. His desktop app watches your downloads, and the second a file lands, it decides what it is and where it belongs. Something that reads like an invoice gets filed with your invoices.

5:43 The detail I liked from in post, no other model in the loop, just Jev. There's no big language model reading your files and summarizing them. It's one small decision repeated, which is

5:54 why it's cheap enough to leave running all day." A day earlier, he'd pointed the same idea at his own feed. A browser extension where you type a plain rule like hide engagement bait, and Jev walks

6:05 down your timeline collapsing the posts that match it. He says it's quick enough that you don't notice it working. There's no measurement on that, so file it as a demo, not a benchmark. Still, a

6:15 content filter you describe in one sentence instead of hunting through settings is a real shift in how you'd use a site. The sixth build is the one developers keep arguing about.

6:25 Instead of asking a model to generate a whole app from scratch, you give it a box of pre-built pieces, a button, a chart, a form, and let Jev decide which ones this screen needs and how they're

6:35 arranged. A UI framework called JSON Render wired that in directly. Your app lists the candidate components. Jev picks which to include, in what order, where they sit. One pass to

6:47 choose them, another to lay them out. Why does that matter? Generating a full interface with a big model is slow, and it drifts. Picking from parts you already trust is fast, and it can't

6:57 invent a button that doesn't exist. Same safety by construction idea pointed at design. A clip going around credited to Michael Tetteh Akula shows an interface assembling itself in about a second.

7:09 I couldn't track down his original post, so take that speed as what the video shows, not a lab result. The mechanism under it though is already inside real component libraries. The seventh build

7:19 goes after a pain you felt if you use Claude code. The context window fills up, and the tool makes room by having a language model summarize the conversation so far. Those summaries

7:29 drop details you needed, and you find out which ones too late. >> [snorts] >> Tamar Tran's project takes a different route. It walks back through your old

7:36 tool calls and asks Jev two tiny questions about each one. Keep this call at all? And keep result word for word, or trim it. Whatever survives is kept exactly, not rewritten, not summarized.

7:49 Now, the eye-catching animation on her post is, by her own read me, a dramatized mock-up. It doesn't call the real model. It exists to be screen recorded, and it's lovely, and it isn't

8:00 evident. Because when someone ran the actual thing across five real coding sessions at a safe confidence setting, it dropped 0% of the context. The calls Jev wanted to throw away were the ones

8:11 it was least sure about, so a careful cutoff kept everything. Good idea, not proven yet. Remember that, it's about to become the whole point. To be fair to the idea, keeping the real text instead

8:22 of a summary is the right instinct. The trouble is trusting a confidence score to decide what's safe to lose, and that confidence is the exact thing that hasn't been checked yet. The eighth

8:31 build is where the weak tipped into spectacle. Somebody generated an entire simulated JFK airport using GPT-6 Astra, then dropped Jev into the control tower. Every clearance is a Jev decision.

8:43 Cleared to land, hold your position, go around. A separate voice model handles the radio, so you hear the pilot and the controller talk while Jev makes the calls underneath. As the traffic climbs,

8:54 you watch it keep planes separated without stalling. It's a simulation, and the builder says so up front, not real air traffic data. As a stress test of decisions under

9:03 load, though, it's the clearest one in the batch. The ninth one turns the model on you. Kill my idea. From an indie hacker who posts as Tim Monde takes your startup pitch and instead of writing

9:13 feedback, fires about 10 Jev questions at once. Demand, competition, execution risk, each scored in parallel. Outcomes a single verdict. Kill it, fix it, or ship

9:24 it. I'd hold the result loosely, and so does the maker, who calls it purely demonstrative. A score is not a market, but there's something bracing about a tool that hands you a cold number in a

9:34 second, instead of a paragraph telling you your idea is amazing. And the 10th one is my favorite because it breaks the one rule on purpose. Jeff can't write a sentence, so a developer made it right

9:45 anyway. The hack is simple. Give Jeff a fixed list of words, then ask it over and over which word comes next, one choice at a time. A reply slowly assembles. Ask it something short and

9:56 factual and it manages. Ask it anything real and it drifts into word salad. It's a joke and the builders label it one. But it's the whole video compressed into a bit. You took a model designed to

10:08 decide, forced it to talk, and got a properly terrible chatbot. The thing it's worst at is exactly what it was built to avoid. Step back for a second. That's 10 builds and it wasn't close to

10:18 all of them. Inside one week, there were curated lists of Jeff projects, an official showcase with hundreds of entries, and so many clones that the same app name

10:27 showed up five times over. Which brings me to the part I didn't see coming. Six days after Jeff launched, a solo developer, Theo Lee, shipped an open-source version. It went out as

10:37 OpenJeff, though he since renamed it. It runs entirely in your browser on open models you can download yourself, and it proves the core trick is real. You can read the probabilities for a set of

10:47 options straight out of an ordinary model in one pass, instead of making it type them out word by word. It leans on your own graphics card through the browser, the kind of single gaming

10:57 machine has, with no server and no account. And the comparison it draws is exact. Read the answer from the model's internal scores in one pass, or make the model type that same answer out as text.

11:08 One decision, two roads, and the first road is the whole idea of Jeff. Here's the half that matters most though. OpenJeff's probabilities are raw, just the model's gut feeling over the allowed

11:19 words. They aren't calibrated the way TypeSafe says Jeff's are. On the best open model, it matched the reference answers about 85% of the time against Jeff's reported 88. And the The

11:30 browser-size models did much worse. It hit the front page of Hacker News within a couple of days, which usually means a thing struck a nerve. People wanted to try the trick with their own eyes, on

11:40 their own hardware. The author's own line is the fairest summary anyone wrote all week. This is evidence that the mechanism can be reproduced, not a reproduction of Jev's reported

11:50 performance. It proves the idea. It doesn't prove the numbers. So, after a full week of this, does Jev hold up? Two things keep getting blended together, and pulling them apart is the whole

12:00 answer. First, the part that's actually solid. Jev can't hand you an answer outside the menu. Ask for one of five choices, and you get one of five, guaranteed by the way the model is

12:10 decoded. For software, that's real value. No parsing a paragraph and praying it's valid. But, being valid isn't the same as being right, and that's where the marketing gets

12:19 slippery. Type Safe's headline says zero hallucinations, and then their own page admits that number isn't measured. They call it guaranteed by construction, which only covers the format, not the

12:29 judgment. There's one more number worth seeing. Type Safe's own accuracy check measures how often Jev agrees with a panel of frontier models, GPT-6 Astra, and Claude Fable, and it lands around

12:41 68%. That's agreement with other models, not proof of being right, and it's the company grading its own homework. The speed claim wobbles, too. One Type Safe page says 40 to 200 times faster.

12:53 Another says 20. The one independent test I could find clocked it at about a third of a second, against nearly nine Claude Fable 5 on a writing review. That's roughly 25 times faster, not 200.

13:05 And on that task, Jev missed a flaw the slower model caught. Now, line those up. The compaction tool that dropped nothing at a safe setting open Jev's accuracy gap. A zero that isn't measured. A speed

13:17 number that changes by the page. The pattern is clear. The mechanism is genuinely new and useful. The benchmark claims are not proven by anyone outside the company. So, here's where I land. If

13:28 you're building something where a fast, cheap type decision replaces a giant model, and a wrong call is easy to catch, routing a request, retrying, filtering a feed, skipping an ad, Jev is

13:39 worth trying this week. If you're leaning on the accuracy numbers from the landing page, wait for outside testing. The real headline of the week isn't the flight demo, fun as it was. It's that

13:49 the moment a model stopped trying to talk and started making decisions, developers found a hundred uses for it in six days. That's the signal worth watching. Judge Jev on the decisions it

13:59 makes, not the sentences it won't write. Every project is linked below. The flight, the Mario controller, the open-source version, all of it. If you build something stranger than putting

14:09 Jev in an airport, send it to me. Subscribe, and I'll keep taking these apart as they land.