kenny. @codebykenny

You can now define evaluations with Jev.

I've seen people describe Jev as an "AI if statement". But what if it actually WAS an if statement? Introducing Probably: a programming language powered by Jev: …bably-lang.southpolesteve.workers.dev Jev baked into the language. “feels” asks a question. “match” routes between descriptions. “while” keeps going until something stops feeling true. This is obviously a toy, but it's fun to think about what something like Jev unlocks. Jev makes the decisions, an LLM does the writing, and a little program ties it together.

Ultra-fast, criteria-based model routing using Jev from @typesafeai.

Yeah Jev by @typesafeai is very cool. It classified 500 emails in seconds. And it costed 3.5 cents.

This is going to change everything. Instant/real-time browser use is immediately going to revolutionize everything we do in our lives Faster than a human can navigate the web

Filip @Neriousy

a week ago

Testing apps with @typesafeai jev & @opencode will be soooo fast small demo:

53 43 1K 552K 804

Testing apps with @typesafeai jev & @opencode will be soooo fast small demo:

you can just hallucinate the entire internet with Qwen 3.8 27b running at 2,000 tokens/second? part 2 of turning @cerebras + @Alibaba_Qwen 3.8 27B into an OS: built an offline browser with zero network calls and mounted it directly the JIT ubuntu desktop. no wifi. no scraping. zero packets sent to external CDNs. you search a site, set a year, and qwen 27b at 1,950 tok/s synthesizes the entire DOM on the fly. here is youtube in 2045 vs 1999: → search google for youtube inside the OS → scrub to 2045: instant futuristic feed → scrub to 1999: raw web 1.0 time capsule in seconds at this speed, browsing isn't retrieving files from a server, it's querying an alternate reality. a 2D browser window is just step zero. imagine full operating systems, virtual worlds, and complex simulation engines existing purely as model weights. zero gigabytes stored on disk, just pure interactive reality streamed on demand. What else becomes a possibility with the qwen 3.8 27b (dense) at 2000 tokens/sec?

Alok @analogalok

2 weeks ago

Operating System powered by Qwen 3.8 27B at 1950 tokens/sec! here is what 1,950 tokens/second @Alibaba_Qwen's 3.8 27b actually looks like on @cerebras: i wrote a minimal python web server that turns cerebras inference into a live operating system. zero apps on disk. when you

35 58 745 449K 495

I got access to Jev earlier today (thank you @hackgoofer). I have run ~5,000 requests so far, (which cost me around $2!), across classification, model routing, intent, steering, and many other things. tl;dr, Jev enables a new intelligent decision-making primitive, separate from deterministic code and LLM calls. This allows a class of decision-making that was neither suited to dumb, unintelligent code, nor to slow, expensive LLMs. It is super fast and cheap, and I think I will likely end up making a few Jev calls to every LLM call I make in my product. I think probably any company using LLM requests today can probably add a Jev call pre and/or post LLM calls to quite literally make their product much better for free, and have better tool calling behavior in many cases. I happened to have a personal benchmark for this as I’d been working on a ton of proactivity and classification tasks. I have been using the deepseek flash and more recently gpt 5.6 luna family of models as reasonably smart classifiers with low latency. Think questions like: - Did this conversation output contradict something they’ve mentioned before? - Should we send a followup message to this user based on our rules? - It’s been a few seconds of silence. Should we proactively send a message? In the past, I’ve been forced to write a bunch of what I call decision chains, mostly because an LLM classification call is very expensive in TIME (avg 4s), and less importantly can cost quite a bit if run on every message. Imagine a normal chat app. If you added 4s to every response to figure out if the response is good before sending it out, that ends up being pretty bad. So instead, I usually have to write some code that is a crude heuristic that runs quickly and decides whether to run the classifier. Obviously this sucks because you call the classifier many times that you don’t want to, which makes your p95 bad, and you also miss cases with the heuristic, and you also have to manage all of these weird chains. With Jev, it’s cheap enough, and fast enough (p50 ~150ms, p95 ~350ms in my testing!) that you can easily run it every turn. Heck you can reasonably run it before generation AND post generation, for any application that isn’t realtime voice, and still feel snappy. But this is just one use case. Think: smarter model routing, better context packing, better responses, better observability for intent/tags/safety, smarter retries and so much more. By simply thinking about the inputs and outcomes you want to enforce, you can use Jev to supercharge most model calls and reduce bad user outcomes. The more “quirks” a model has, the more valuable it ends up being. It’s a bit weird and unintuitive using Jev. Generally, you want to decrease the # of questions you ask a classifier, or it makes more mistakes. In fact, you might want to ask your questions kind of in a compound way, because the reasoning happens in a shared scratchpad of sorts. Adding questions muddies the scratchpad and makes it take longer. With Jev, you feel incentivized to go the other way, to formulate your query as a set of independent questions. It doesn’t feel like adding more questions decreases your performance on others. You can go a bit deeper to improve tool calls. Many model tools are things like turning on settings, or other things. You can easily improve models that are not very good at tool calling with Jev, by simply figuring out when to run them. You can do a pre-LLM call to figure out when to unfurl different tool definitions, in order to make your main LLM run better, you could run a background task with Jev + another LLM to reduce tool and context burden on your main LLM, and free it to be responsive. I’ve only scratched the surface of my testing but very excited!

Diogo Almeida @CompleteSkeptic

2 weeks ago

After co-inventing ChatGPT, I kept asking myself: why have superhuman chat models not led to AGI? I’ve spent the last 2 years in stealth building a new way to train models (RLCD), and a new type of frontier AI model that we are releasing today: Jev • 20-200x faster • 40-400x

4K 8K 76K 39.6M 59K

After co-inventing ChatGPT, I kept asking myself: why have superhuman chat models not led to AGI? I’ve spent the last 2 years in stealth building a new way to train models (RLCD), and a new type of frontier AI model that we are releasing today: Jev • 20-200x faster • 40-400x cheaper (w/ output tokens free) • Frontier composable intelligence optimized for decisions AFAICT the shortest path to AI-based economic revolution

GPT-6 Astra has just beaten a standard game of Factorio with enemies enabled after nearly 44 hours in-game time, and 4 days 11 hours on his Codex /goal clock. At API pricing, logs indicate it would've cost about $4500. It could probably be 50x cheaper by offloading more to Luna and providing some standard scripts for common tasks. My next test might be Astra coaching Muse Spark or Qwen 3.8 27B into solving a random seed, now that we have successful logs to review.

Tim Cook: "Despite this table being so small, you could put every Apple product on it. Every single one that we ship today." "Most companies begin to do larger and larger and larger portfolios because it's so easy to add. It's hard to edit. It's hard to stay focused. Yet we know we'll only do our best work if we stay focused. The hardest decisions we make are all the things not to work on. There are lots of things we'd like to work on, that we have interest in, but we know that we can't do everything great." (Charlie Rose || 2014)

This is so good!

Matt Pocock @mattpocockuk

3 weeks ago

/show-me is a phenomenal skill Makes PR descriptions extremely easy to read Basically a toolbox of "nice ways to look at code" Nice work, @dexhorthy github.com/humanlayer/ski…

80 516 8K 884K 12K

@DottChen @culturedcode If you use things for GTD(Getting Things Done) what the app is deeply inspired by, then an MCP would be a massive help

@dhh @MarceloLima @wholemars It was sad today when I realize omarchy didn’t support m3 MacBook Air

I stopped having to single-threadedly debug like that somewhere between opus 4.5 and fable haven’t opened lldb in many months Easily one of the most time inefficient parts of programming

@brian_lovin @andymadrick I’m so lost the entire time I’m using IDE mode. My editor is literally a tiny square at this point because I can’t be bothered to learn how tf to dismiss anything anymore

I think the most interesting thing about Jack Dorsey's "Slack killer" is the idea around shared compute. I haven't seen people talk about it so here are my thoughts FWIW: Open models got good, close enough to the paid frontier stuff to run for real. But the strongest ones need expensive hardware most people probably won't buy alone, and it's kinda a pain to set up if you aren't technical. Shared compute solves exactly that. In Buzz, one person runs the machine, loads up an open model like Google Gemma, and everyone in the community plugs into that same model. Basically, a whole group has real AI they own and control together, running on their own hardware, learning from their own data. Once you see it, a bunch of things click into place. 1. A community can now run a top open model together, on a machine they own, instead of renting from a lab. 2. It learns from the group's private data and gets sharper over time, and all of that stays inside the community. 3. A narrow, private model can quietly get better than ChatGPT for the one world your group lives in. 4. It's impossible to copy, because the edge is the private data on your machine, not the model itself. 5. The moat stops being how smart your AI is and becomes whose data it learned from. 6. Compute becomes something you share like a building shares a gym. 10 people split one machine instead of 10 people each renting forever. 7. Idle compute becomes income!!! Your machine sits dead half the day, so it earns money renting that time to someone who needs it. 8. Communities become the unit of intelligence instead of companies. The group with the smartest shared brain wins, and being a member means owning a piece of it. 9. A shared brain becomes an asset you build equity in. You put in money and data, it appreciates, and your slice is worth something the day you leave. 10. The whole thing runs on open protocols, so the group keeps full control and nobody outside can throttle it or shut it off. You know me, obviously, my head went to what startup ideas come to mind here. Adding them to @ideabrowser soon. Well… 1. The vertical brain. Pick one profession, tax lawyers or real estate agents or indie game devs, and build the shared machine trained on everything that group knows between them. A year in it's the smartest AI in that field, impossible to copy, and you own the club it lives in. 2. The rental marketplace for collective brains. Once these private models exist, outsiders will pay to use them. You build the layer where a group lists its brain, an outsider pays per task, and the money flows back to the members while you take a cut. A marketplace for expertise, not compute. 3. The idle-compute exchange. Every shared machine sits unused half the day. You build the market that rents that dead time to whoever needs the power right then, so owners earn money off a machine that was just sitting there. Idk where Buzz goes, but it's cool to see Jack putting it out. Right now the way it works in AI is you rent your intelligence from a few giant labs that own the machine, set the price, and hold the off switch. Shared compute flips that, because a community can run the model together, feed it their own private data, and keep full control of the whole thing. It's one of those things that might look tiny today, but Jack does has a habit of being early.

Vinny @hot_town

2 months ago

I tried @jack's Buzz. It's like Slack + OpenClaw + Herdr + but with some really unique features that people are sleeping on. The video below shows how it works, and some of my thoughts on the process and platform, e.g.: - Create and interact with agents on top of any harness

135 195 3K 1.4M 5K

@VictorTaelin How do you think this compares versus plan mode with /grill-me? Get the decisions up front before the implementation

actually an insane thing for openai’s head of strategy to publicly say

Dean W. Ball @deanwball

2 months ago

Some observations on Kimi: 1. It's a very good model! I don't think its performance can be explained away by distillation or anything like that. In agentic coding sessions, it seems pretty much on par with the best public models of Q1 2026. In my fairly limited use, it also

2K 936 8K 11.3M 9K

Kimi K3 is the best performing model on nextjs.org/evals, ahead of Fable, reaching a comparable success rate in less time. This is the first time that an open model is ahead of all proprietary ones for this comprehensive web engineering benchmark. Notes: ▪️ Benchmarks don’t always tell the full story, although this is important signal, adding to mounting evidence that this could be a breakthrough moment for open models ▪️ No model as of yet has reached 100% completion on this set of evals. The top performer peaks at 92% and 96% “with help”