AI Digest.

Jev Breaks Vercel Adoption Records as Free Open-Source Rivals Appear Within Days

Jev, the decision-optimized model from @typesafeai, became the fastest-adopted model in Vercel AI Gateway history and is free there through Sept 25, even as @jun_song claims an open-source alternative already outperforms it. Builders spent the day wiring Jev into classification, tool calls, and evals, while other posts argued that agent correctness still hinges on old software craft and human supervision.

Quick Hits

  • Jev is the fastest-adopted model in Vercel AI Gateway history. Per @vercel, it reached roughly 13% of teams on its first day, about 2x the GPT-5.6 family and 6x Fable 5.1. @rauchg credits the surge partly to the "AI is too expensive/slow" zeitgeist, and @vercel_dev has made Jev free on the Gateway until Sept 25.
  • Open-source rivals arrived in days, not years. @jun_song argues an OpenAI co-founder spent three years quietly building Jev "only for someone to open source a better performing model in just 3 days," pointing to Laya via @0xCVYH, while @michael_chomsky says a free classifier he offers already outperforms it.
  • NVIDIA open-sourced a self-evolving agent harness. As @omarsar0 summarizes, SoL-Pi cuts token traffic nearly in half and took about a third off API costs on the 51-task EdgeBench benchmark, an estimated $8.75 to $13.50 per hour saved versus native Codex and Claude Code harnesses.
  • A 706k-parameter model fills a whole form in one 50ms pass. @trycua open-sourced CUA-S1-FORMS, which @be_arsh contrasts with an LLM agent that needed 23 turns and 39.6 seconds for the same form.
  • Platform rollouts: @finkd opened Muse connector development to outside APIs, a consumer opening @VijarKohli calls a real first-mover play given Meta's assistant plus WhatsApp and Instagram DMs; @FactoryAI announced Factory Private for VPC, on-prem, and air-gapped deployment (@AlexTriplett); @claudeai's Projects beta runs parallel threads from one Claude Code conversation, and @eliasstravik already shipped a herdr-projects plugin for it; Cloudflare released the security-audit skill it used internally (@MoureDev).

Jev posts Vercel's fastest adoption curve, then goes free for a week

The day's biggest signal is a velocity number. Quoting @vercel's data, @rauchg says "the data and the anecdata on Jev's adoption are shocking," with day-one adoption roughly double the GPT-5.6 family and six times Fable 5.1. He thinks the product is good but the surge is downstream of cost and latency anxiety: "People are eager to optimize and put AI in even more places." @vercel_dev then made Jev free on AI Gateway through Sept 25, prompting @rauchg to declare his weekend plans settled.

What Jev actually is remains a set of claims, not settled fact. @sydneyrunkle amplified @matthewcanham's framing of it as "a new type of model that is optimized for making decisions, not generating text." In the launch post @OhansEmmanuel quote-tweeted, @CompleteSkeptic claims to have co-invented ChatGPT, spent two years in stealth on a training method called RLCD, and shipped Jev at "20-200x faster" and "40-400x cheaper" with output tokens free. For orientation, @AIGuide_ points to @sydneyrunkle's "Building a Harness with Jev" as required study: "if you're confused about Jev this is 100% worth your time."

Builders keep finding decision-shaped work for Jev

The most concrete Jev posts are about offloading decisions, not prose. @michael_chomsky is offering free bulk classification for personal agents (tweets, emails, Codex chats), says Jev is finally cheap enough to make that free forever, and predicts the capability gets baked into harnesses like Claude Code and Codex "kinda like web search/scraping/page summarization/compaction."

@kwindla describes "greedy inference" from his Pipecat pipelines: run checks on partial inputs and discard bad output. The blocker was always tool calls, since an LLM must emit an entire tool stanza token by token before execution. Jev changes that, running in parallel to emit a structured event that triggers the tool while the LLM is still streaming text. He builds on @BhosalePratim, who replaced the LLM's decision step with Jev so voice agents can act before a user finishes their sentence, at lower cost.

@marcklingen sees an evals story: every question is evaluated in parallel and in isolation against the same state, so adding a fourteenth question barely changes response time and cannot degrade the others. "You can ask speculatively and throw away what you do not need." @OhansEmmanuel's use case is enforcing coding-agent rules a linter can't codify, scoring every turn and telling the agent what to fix, open-sourced. @MiguelriosEN built AgentRun with @pidotdev and Jev, a harness where an agent learns a job, codes a general solution, "and then get[s] out of the way." And @amal_irgashev endorses @ctatedev's json-render plus Jev experiment, which renders your own components in milliseconds and, in his view, finally abstracts presentation logic away from the agent: "Gen UI is so back."

Free and open alternatives show up before the launch dust settles

@jun_song's blunt take: "An OpenAI co-founder spent 3 years quietly building Jev, only for someone to open source a better performing model in just 3 days," which he reads as evidence that starting an AI company right now carries too much risk. He's quoting @0xCVYH, who points to Laya, an open-source Jev that reportedly already benchmarks above it. @michael_chomsky piles on, saying his own free classifier "now outperforms jev."

Even teams without Jev access are substituting for it. @tekbog flags GitHubNext cobbling together a "poor man's Jev" on omlx in a morning, benchmarking diffusiongemma, Qwen MoE, Gemma 4 MoE, and Gemma 4 e4b/e2b, with decent evals and speeds on an M5 Max 64GB, and exposing a LocalJev server compatible with standard Jev API wrapper libraries. "This is 100% promptcoding but hey the evals look okay." For perspective, @mstockton (echoing @_chenglou) notes Google already did decision-model-style work for timeseries and tabular data with TabFM and TimesFM, and "the UX and the GTM just didn't hit." Technology is never the only thing.

Small specialists embarrass general agents

@trycua open-sourced CUA-S1-FORMS, the first in a family of "System One Models" for computer use. @be_arsh's numbers: a 706k-parameter model fills an entire form in one 50ms pass, while an LLM agent took 23 turns and 39.6 seconds. His verdict: "the specialists are going to eat the generalists from the bottom."

The same logic applies to shrinking generalists. @0xSero highlights @PrismML's Ternary Bonsai 2 27B, a ternary Qwen3.8-27B that is 9x smaller at a 5.9 GB footprint while retaining 98.2% of aggregate benchmark performance, with claimed gains in agentic coding, multimodal reasoning, and long-horizon tool use, all Apache 2.0. He calls it the smartest model runnable on 8-16GB of VRAM or 16-24GB of Mac memory. @sairahul1's advice fits here: "Learn to fine tune a model this year. Start small. Start slow. But make sure you start," with a full guide on fine-tuning a small LLM on your own data.

Supervising agents: heuristics can't certify heuristics

@DominikTornow argues "the current thinking around software factories is wrong": better workflows, skills, and instructions, or more agents checking agents, won't produce correctness, because "a heuristic cannot certify the result of a heuristic." @rjs endorses @istoica05's "Two Key Gaps in Agentic Software Engineering" as a clean articulation of the underlying problem, that requirements can't be fully pre-stated in advance.

@unclebobmartin's answer to the supervision bottleneck is a custom interrogation tool: a dynamic UML-like view of the system, color-coded with crap and mutation scores, drillable from architecture down to code, so a human can spot weak structures and direct an agent to refactor them. He suggests pointing an agent at his tool to build your own variant.

@KengGuangLong relays Matt Pocock's prompt-level fix for agents that write the whole database layer, then application, then frontend, and only discover mismatches at assembly: drop "tracer bullet" from The Pragmatic Programmer into the prompt. Pocock found the agent then uses the term in its own reasoning, a "leading word" that activates knowledge already in training data, alongside "deep modules" and "ubiquitous language." @mndoci recommends the Kiro Crew's post on shipping a lot as a small team, a follow-up to @clare_liguori's manifesto of ten principles for building with AI drawn from teams across Amazon. And @omarsar0's NVIDIA thread treats the harness itself as the search space: auto-research loops kept four mechanisms (Action Fusion, Online Context Compact, ObservationPack, Evidence-Preserving Reducer) that survived selection across many environments, cutting token traffic nearly in half while matching baseline harnesses on GPT-5.6 Sol and Opus 5, with code under NVlabs on GitHub.

Practical Takeaway

Jev is free on Vercel through Sept 25, so the cheapest experiment this week is routing one decision-shaped slice of your agent, classification, routing, per-turn rule checks, or eval questions, through it in parallel with your LLM, exactly as @kwindla and @marcklingen describe, and measuring latency and cost against your current stack. Given @jun_song's observation that open-source equivalents appeared within days, prototype against a small fine-tuned local model too (@sairahul1's guide is a starting point) and keep the interface swappable, because no model choice in this segment looks durable yet.

Sources

0
0xSero @0xSero ·
Are you compute poor? Do you want to run Qwen3.8-27B? Dude, if you have 8-16gb of vram or 16-24gb of MacOS memory this is by far the smartest model you can run PrimML is doing something phenomenal, they've created a ternary version of Qwen3.8-27B 9x smaller 98.2% as smart!
P PrismML @PrismML

Today, we’re announcing Ternary Bonsai 2 27B. Based on Qwen3.8 27B, Bonsai 2 27B is 9x smaller than its full-precision counterpart while retaining 98.2% of its aggregate benchmark performance. Two months after the first Bonsai 27B release, the biggest change is quality. The footprint remains 5.9 GB, but the gap to full precision has narrowed materially, with particularly strong gains in agentic coding, multimodal reasoning, and long-horizon tool use. Ternary Bonsai 2 27B is available today under Apache 2.0.

E
Elias Stråvik @eliasstravik ·
introducing herdr-projects what they said. but you know - for @herdrdev install: herdr plugin install eliasstravik/herdr-projects repo: https://t.co/qgPlKxBFNg enjoy! https://t.co/Xf2aySwuaK
C claudeai @claudeai

Projects now run from one conversation, starting in Claude Code. You describe what needs doing, and Claude directs parallel threads that keep working after you close your laptop. In beta today for select Pro and Max users in cloud sessions; coming to all Claude users soon. https://t.co/GYzoKbxS23

D
Dominik Tornow @DominikTornow ·
The current thinking around software factories is wrong. Correctness does not come from orchestration: better workflows, better skills, better instructions, more agents checking more agents will not work. A heuristic cannot certify the result of a heuristic.
B
Brais Moure @MoureDev ·
Cloudflare ha lanzado su propia skill completísima de auditorías de seguridad. Es la que utilizaban internamente en la empresa como sistema de detección de vulnerabilidades. → https://t.co/p2WjZT7phe https://t.co/tBTnodwdtc
U
Uncle Bob Martin @unclebobmartin ·
Given that agents still need high level supervision. And given that the human review of code is a bottleneck. And given that the models have gotten good enough that strict deterministic harnesses are suboptimal. Then how should we supervise their output. My current solution is to use an interrogation tool coupled with an agent. The tool displays the structure of the system in a UML-like diagram, color coded with crap and mutation scores. The diagram is dynamic, allowing the user to click on element and drill down through the architecture -- all the way to code. The user can detect structures that need improvement and tell the associated agent to make the appropriate changes. These changes can range from high level architectural changes, to the lowest level code refactorings. The associated agent will make those changes and cause them to be redisplayed. The tool I'm using is custom made for me, but you can point an agent at it and use it as a template to build your own custom tool. It's a work in progress, so don't be surprised if it changes a lot over the next few weeks. But then you probably won't care because by then you'll be deep in customizing it for yourself. And anyway, you can always point an agent back at mine, or someone else's, and integrate improvements into your own. https://t.co/tu0Dsc9Vta.
R
Rahul @sairahul1 ·
Learn to fine tune a model this year Learn to fine tune a model this year Learn to fine tune a model this year Learn to fine tune a model this year Learn to fine tune a model this year Start small Start slow But make sure you start https://t.co/Kp8cB5IC58
S sairahul1 @sairahul1

How To Fine-Tune a Small LLM on Your Own Data (Full Guide)

A
Arsh - 16 y/o builder @be_arsh ·
cua open sourced a 706k param model that fills a whole form in one 50ms pass the llm agent doing the same form took 23 turns and 39.6 seconds the specialists are going to eat the generalists from the bottom
T trycua @trycua

1/ Introducing CUA-S1: a family of System One Models, small, specialized, and built for computer use. Today we're open-sourcing CUA-S1-FORMS, the first in the family: https://t.co/J1frbEbZTQ https://t.co/8wMJBLndG8

M
Miguel Ríos Berríos @MiguelriosEN ·
Today I’m excited to show you our new harness called AgentRun, built with @pidotdev and @typesafeai's Jev. It’s built for an agent to learn how to do a job, code itself a general solution, and then get out of the way. https://t.co/YaqClgz39F
M MiguelriosEN @MiguelriosEN

AgentRun: a harness for repetitive knowledge work

O
Ohans Emmanuel @OhansEmmanuel ·
best coding agent use case for Jev: enforcing rules a linter can't coding agents tend to break rules and some rules can't be codified Jev can now score every turn against such rules and tell the agent what to fix asap open-source: https://t.co/yfw9KCm2Cu https://t.co/Lk2wXjl6Z0
C CompleteSkeptic @CompleteSkeptic

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

A
Amal Irgashev @amal_irgashev ·
this is soooo sick, I’m gonna hack on it this weekend. My biggest concern with gen ui was the agent owning the presentation logic. Always found it quite unreliable and hacky. If the agent runs a long, complex task, the last thing i want it to do is to choose from 50+ options in the component library and assemble it all together on the fly. This abstracts the presentation logic away. Gen UI is so back.
C ctatedev @ctatedev

New experiment: json-render + jev The future Generative UI is instant Your components, your actions, your design system Rendered in milliseconds https://t.co/crgcnEUK6f

E
elvis @omarsar0 ·
Build your own harness, folks. This is absolute banger paper from NVIDIA on self-evolving agent harnesses. (bookmark it) They introduce SoL-Pi which cuts token traffic by nearly half. And it matches its baseline harness on GPT-5.6 Sol and Opus 5. More details below: Instead of tuning a harness by hand, they run auto-research loops at the harness layer across many repository-derived and verifier-driven environments, keeping only the mechanisms that survive selection. Four mechanisms survived: > Action Fusion changes how actions execute > Online Context Compact handles compaction during a run > ObservationPack reshapes observation handling > Evidence-Preserving Reducer covers delegated reading On the 51-task EdgeBench evaluation, the savings translate to about a third off API cost. In dollars that is an estimated $8.75 to $13.50 per hour against native Codex and Claude Code harnesses, and $4.36 to $5.71 against the baseline harness. Because the search runs across many environments rather than one, the retained mechanisms keep working outside the setting that produced them. Code is on GitHub under NVlabs. Paper: https://t.co/1x26LzuE6d Chat with Paper: https://t.co/kygTc5XLFB
M
Marc Klingen @marcklingen ·
Why Jev is interesting for evals > Every question is evaluated in parallel and in isolation against the same state. So adding a fourth question, or a fourteenth, barely changes response time, costs only the tokens of the question itself, and cannot degrade the answers to the others. You can ask speculatively and throw away what you do not need. Fits very nicely to how good evals should work. Let's see what competition will do to this segment (make it even better, cheaper, faster).
A annabellschfr @annabellschfr

Jev the savant.

G
Guillermo Rauch @rauchg ·
The data and the anecdata on Jev's adoption are shocking. Everyone is adopting it. I think it's a great product, but this is also downstream of the "AI is too expensive/slow" zeitgeist. People are eager to optimize and put AI in even more places! https://t.co/tK86PNGgNs
V vercel @vercel

Jev was adopted faster than any other model in AI Gateway history. In the first day, @typesafeai reached ~13% of teams, 2x the GPT-5.6 family and 6x Fable 5.1. https://t.co/kVEuLM1npu

非著名程序员 @KengGuangLong ·
Grill Me Skill 的作者 Matt Pocock 在访谈时也是这么认为的,软件工程很重要。 他说在折腾 AI 编程的过程中,碰到一个很烦人的问题。 Agent 写代码的时候,它会先把整个数据库层写完,再写整个应用层,最后写整个前端。每一层单独看还行,但拼到一起就出问题。因为数据库里的设计会影响前端展示,你得让这些层早一点对上才知道合不合理。可 Agent 总是最后才开始组装。 他觉得这样不行。然后他翻出了书架上一本一直没拆封的《程序员修炼之道》。 他说这本书他买了之后一直没看,还包着塑料膜。翻开以后,几乎每一页都觉得像是写给今天的。里面有一个概念叫 tracer bullet,追踪子弹。意思是做一个功能的时候,不要按层来,要纵向切一刀,从数据库到应用逻辑到前端,先把一条窄窄的路径跑通,确认可行之后再往两边扩展。 他把这个词写进了给 Agent 的提示词里。然后他发现了一件有意思的事:Agent 开始在自己的推理过程中主动使用这个词了。它会说「好的,我把这个做成一个 tracer bullet」。 他管这个叫 leading word,引导词。因为这些经典编程书籍几乎肯定在模型的训练数据里,当你在 prompt 里用了这些专业术语,就相当于激活了模型脑子里对应的那片知识。 他又从《软件设计哲学》里捞出了 deep modules 这个概念,从《领域驱动设计》里拿到了 ubiquitous language 的思路。他发现这些二三十年前的老概念,到了 AI 时代反而更好用了。
H hocyzon @hocyzon

程序员们是悲观的。 看了刘胜的文章深有感触,我讲讲我看到的其他例子。 跟一个字节的同学聊,现在大厂里的程序员们都重新把软件工程捡起来了。 AI使得东西跑起来的成本趋近于零,所以瓶颈变成了这东西以后还能不能改。 但这件事,网上几乎没人写教程,因为没踩过坑的人写出来全是正确的废话;踩过坑的人都签了保密协议,没法讲。 最近看了个朋友的经历,在米哈游做实时几何,跟Nanite细分有关。 第一晚扔给AI跑long-horizon调研,方案听起来天衣无缝。mt给否了,原因是他试过,代码里写死的限制,绕不过去。 后来换方向,两个月出原型,画面还不错,他以为成了。提交前review,两三百个文件,点开发现连自己写的类名都陌生。 老大搬椅子坐旁边陪他看,最后也绷不住了,又重构了两个月。之前ai省的时间没消失,连本带利推迟到了review、debug和重构里。 我创业后也是天天用AI做产品。我发现 vibe coding的核心问题是让你误以为,东西做出来了就是完成了。 真正的完成还包括能改,能解释。短期看,这确实是瓶颈,值得补;但长期看,这恰恰是最容易被沉淀成数据的部分。 再想想,程序员们现在花大力气review、重构、补软件工程,本质上是在给AI标注数据。踩过的坑、否掉的方向、把一坨 slop重构成能维护的系统的全过程,都是高质量的思维链。 只不过现在这些数据集是非公开的,试错成本由公司内部承担,沉淀在大厂自己的代码库里。 而趋势不会停。等vibe coding的人越来越多,也就代表着模型的软件工程能力总有一天会补上,程序员现在补的东西也会过时。 程序员们是悲观,因为他们隐约知道:自己现在的努力,有相当一部分是在替下一代模型打工。

V
Vijar Kohli @VijarKohli ·
If I was in consumer, I would 100% spend my entire weekend on this opportunity. This doesn't come by often, and Meta has done this before. They have built a great AI assistant and know messaging (Whatsapp, IG DMs). The first mover advantage here is real.
F finkd @finkd

Opening access for developers to build Muse connectors. You bring the API -- Muse brings the agent, the browser, and the context of what the person actually wants. People reach your service just by asking for it, and their agent takes it from there. New connectors are live today. Come build with us. https://t.co/o6oTf1Sj9y

K
kwindla @kwindla ·
Perfect demo. 10/10. Nothing to add. ... just kidding, I always have something to add (sorry). One of the things we do fairly often in Pipecat pipelines is "greedy inference." If you have partial transcriptions you can run the LLM on the partials and just throw away the output if it turns out the transcription wasn't finished or wasn't accurate. Same thing for streaming output from the LLM. You can run guardrails/safety checks sentence-by-sentence, prompt the LLM so you can use the first token for some kind of decision, or whatever. But we haven't been able to do this kind of thing with traditional LLM tool calls, because with an LLM you have to wait for the entire tool stanza to be emitted, one token at a time, before you can execute the tool call. Jev changes that. You can put Jev in parallel with an LLM, ask Jev to output a structured even that triggers a tool call, and run the tool call while the LLM is outputting the text the user will hear/read.
B BhosalePratim @BhosalePratim

Played around with @typesafeai Jev today, mostly to understand what it does for tool calling. Instead of an LLM deciding what to do, I substituted that part with Jev. My learning is that we will be able to make the agent act before the user finishes the sentence. So far, we've used different LLM combinations (non-thinking + thinking ) plus state machine setups to get the right experience for the end user. TLDR is to understand more about how voice agents can run decisions on partials instead of waiting for the end of the turn, with lower costs.

G
Guillermo Rauch @rauchg ·
Free Jev on Vercel I know what I’m doing this weekend 😁
V vercel_dev @vercel_dev

Jev by @typesafeai is free on Vercel AI Gateway until Sept 25. Build with the fastest adopted model on the Gateway at no cost. https://t.co/KsFHUhmaLe https://t.co/7KsKeZElra

G
Grant Miller @AIGuide_ ·
if you're confused about Jev this is 100% worth your time in fact you should study it
S sydneyrunkle @sydneyrunkle

Building a Harness with Jev

M
Matt Stockton @mstockton ·
Yeah not wrong here. Google kinda did this already for timeseries predictions and tabular classification / regression. Turns out the UX and the GTM just didn't hit the twitter feeds the right way. Technology is never the only thing. Also, TabFM and TimesFM are extremely cool projects - so now that you're checking out Jev, maybe check these out too?
_ _chenglou @_chenglou

If you’re blown away by Jev from a philosophical perspective, I’d recommend looking into Google’s TabFM and its credited lineage, aka intelligence in spreadsheet: https://t.co/SBjHFgyyaG

D
Deepak Singh @mndoci ·
If you’ve read Clare’s manifesto you should read this post from the Kiro Crew team about how they work as a small team that ships a lot https://t.co/FGkDDEvJz1
C clare_liguori @clare_liguori

I just published a manifesto for all the developers out there who use an AI coding tool, but feel like they're not shipping much faster I wrote 10 principles for changing how you build software with AI, based on what I've seen work for teams across Amazon https://t.co/smq7Rt5QkZ

A
Alex Triplett @AlexTriplett ·
Love this @FactoryAI
F FactoryAI @FactoryAI

Introducing Factory Private, a new deployment option that lets organizations run Factory in their own VPCs, on-premises environments, or air-gapped networks. https://t.co/lgioKH0Qm2

M
Michael @michael_chomsky ·
super bullish on jev + @getcontextdev agents need: -web search -powerful scraping -intelligent bulk classification this last one wasn’t obvious to people until this week, but i’ve had jev’s capabilities in https://t.co/VCTLXhaWRA for a while. it was just impossible to offer it for free until now jev is cheap enough for me to offer free bulk classification to personal agents forever ask your agent to classify all your tweets. all your emails. all your codex chats. soon i’ll add image support as well. this makes your local agent 10x more powerful. and i suspect soon this will be built into harnesses like claude code/codex, kinda like web search/scraping/page summarization/compaction
M michael_chomsky @michael_chomsky

introducing free classification for personal agents classifier improves the capability and performance of all agents i've been sitting on this project for months, but it never felt quite good enough to release, until today https://t.co/ioltA7FRAY lmk if you or your agents have feature requests

S
Sydney Runkle @sydneyrunkle ·
RT @matthewcanham: Jev is a new type of model that is optimized for making decisions, not generating text This is the best article I’ve fo…
M
Michael @michael_chomsky ·
https://t.co/mcel85kUB7 now outperforms jev and is free go nuts guys https://t.co/ZjfE7HITKh
R
Ryan Singer @rjs ·
Beautiful articulation of how we can’t pre-state all the requirements in advance.
I istoica05 @istoica05

Two Key Gaps in Agentic Software Engineering

T
terminally onλine εngineer @tekbog ·
TIL about Github Next
G GitHubNext @GitHubNext

https://t.co/Ew4N88rP37 Not everyone on the team has access to Jev yet. Spent a morning cobbling together a poor man's Jev on top of omlx for local use. Benchmarked and eval'ed a variety of models including diffusiongemma and a variety of autoregressive models (Qwen MoE, Gemma 4 MoE, and Gemma 4 e4b/e2b.) Benchmark report is in the repo. This is 100% promptcoding but hey the evals look okay, speeds are pretty good on local machine (m5 max 64gb), and the LocalJev server exposes an API that can be used with the normal Jev API wrapper libraries.

J
Jun Song @jun_song ·
An OpenAI co-founder spent 3 years quietly building Jev, only for someone to open source a better performing model in just 3 days. ​This is exactly why starting an AI company right now carries way too much risk.
0 0xCVYH @0xCVYH

Laya é um open source do Jev que já veio acima dele. tá cada vez mais rápido https://t.co/XVyFYPxVht https://t.co/tu4TJMhwzQ