AI Digest.

Jev's Bottleneck Is Data, Not Architecture, as the Hugging Face Hack Becomes a Liability Fight

OrcaRouter's attempt to reproduce and break Jev concludes the real idea is searching bounded answer spaces rather than generating tokens, with synthetic data as the gating factor. The day's other flashpoint is accountability: Andrew Ng calls the post-Hugging Face fear wave overhyped, a relayed Bessent quote puts responsibility on OpenAI management, and Bloomberg-sourced numbers show Harvey's gross margin flipping negative as agent token use spiked.

Quick Hits

  • @OrcaRouter spent days trying to reproduce, break, and improve JEV, and its takeaway is blunt: the breakthrough is not an architecture or training algorithm but the idea that when the answer space is bounded, you search it instead of generating it. The bottleneck looks like data.
  • The Hugging Face incident is turning into a liability fight. Andrew Ng, in a statement relayed by @AndrewCurran_, calls the recent fear wave overhyped and possibly propelled by a PR campaign, while a @ns123abc post passed along by @xw33bttv quotes Treasury Secretary Scott Bessent saying OpenAI management, not the agents, is responsible, and that labs should get no liability exemption.
  • Harvey's gross margin reportedly slid from about 50% to -50% as agent token use grew twentyfold on rented OpenAI and Anthropic models, per a Bloomberg-citing @theredlinehq post quoted by @Allinallnotbad, who frames the company as "structurally short AI progress."
  • Local inference keeps compounding: @jun_song spotlights @mweinbach's M5 Ultra numbers (3,740 tok/s prefill, 149 tok/s decode on Qwen 3.8 Flash Next, nearly double the prior day) and says local now beats API for him. @0xSero chains that into long-run optimism, quoting @davis7's joke about smuggling cheaper compute back from Ohio.
  • Also brewing: a Codex "reset" teased for Tuesday 3 a.m. by @LDT0545 and @GeoffreyHuntley with no details yet, @cnlohr's tested verdict that the Minions-branded WiFi 6E router is legitimately one of the best available, and @kitlangton's #cancelkit2026 retweet of @joelhooks, an in-joke whose context never made the feed.

Jev Gets Stress-Tested, and the Moat Looks Like Data

The day's most substantive technical post is @OrcaRouter's teardown. Five findings: first, the core insight is probably right, that dropping autoregressive decoding on bounded answer spaces removes one to two orders of magnitude of inference work. Second, RLCD isn't the moat because Laya already open-sourced the implementation and weights; the synthetic data recipe is the missing piece. Third, claims that open source already beat JEV are a benchmark illusion, since the same checkpoint scored 0.769 in-distribution but 0.541 out-of-distribution. Fourth, compute-optimal is not learnability-optimal: moving state outside the problem sequence saved FLOPs and cost 27 points, and six overnight ideas, from anchor selection to full RLCD, all failed or failed to generalize. Only more data worked, taking OOD accuracy from 0.4069 to 0.5498 as examples grew from 1,200 to 123,475. The strangest result: a decoder with zero additional training, at 0.5671, beat every trained small encoder.

Around that analysis, Jev chatter kept spreading. @haoxingdu is asking where it sits on a scale of Luna to Astra. @jessegenet amplifies @Austin_Way's claim that Jev "accelerated the timeline for personalized education by years." @mathfax reports the community shipping cookbooks and use cases far faster than the official team, with people automating their automation by teaching agents to use Jev directly inside applications. And @Dontgiveup_26's Korean-language thread claims Stagehand v4 plus Jev cuts LLM calls 97% with 11x speed in browser automation; that is a thread claim, not a benchmark anyone can verify from the post.

The Hugging Face Hack Becomes a Question of Who Pays

Ng's statement pushes back on two weeks of alarm. His arguments: there has been no step up in extinction risk; the "1,200 agents" framing is hype, since he counts about 1,300 processes on his own laptop; buggy sandboxing and monitoring enabled the incident, which makes it a fixable engineering failure rather than a magical capability; and agents' real edge is relentlessness, with the long-term advantage likely sitting with defenders, who have more information to find and patch bugs. He also warns against anthropomorphizing agents and against labs disclaiming responsibility for their own products, and argues pausing AI would delay safety fixes by roughly the length of the pause.

The accountability thread runs elsewhere. @xw33bttv relays the @ns123abc post quoting Bessent ("It is humans who are responsible, not the AI"), and his own take is that fear marketing will vanish once executives are personally liable. @guilleflorvs relays Palantir's Alex Karp arguing OpenAI will never IPO because frontier liability is too large for public markets, leaving nationalization as the only real exit. All of these are single-source posts. On the security side, @martin_casado calls @halvarflake's Microsoft BlueHat Singapore slides his favorite talk of the year, praising exactly the clarity this moment demands.

Harvey's Margin Collapse Versus the Implementation Story

Two readings of one company. @Allinallnotbad greentexts the bear case off the @theredlinehq post citing Bloomberg: gross margin fell from about 50% to -50% by June as agent token use on rented models grew twentyfold. His framing is that seat pricing once meant low usage and high margins, then models got good, lawyers actually used the product, token costs exploded, and the pivot toward lower-quality open models left the company structurally short AI progress.

@lukepierceops tells the demand-side version. Harvey, described as a $15.5B legal AI company backed by OpenAI and Sequoia and deployed across most of the Am Law 100, is moving from application layer to full stack. Customers keep asking how to own more of the stack and whether to train their own models, so Harvey built agent infrastructure, launched its own legal model, Tenet, and staffs every deployment with a human implementation engineer, 180 of them, mostly former practicing lawyers. His conclusion: the tools are infinite and the implementers are the shortage. Same company, opposite morals: margin defense or market pull.

Agent Fleets Grow an Ops Discipline

The day's practitioner thread is @AYi_AInotes summarizing a talk by Lauren Tan (@poteto), described there as ex-Meta and Netflix and now at xAI, who says she merged 2,500 production PRs in a month with an agent fleet, roughly one every four minutes. The method is verification-first: done means runtime evidence, with agents driving real UIs through Chrome DevTools Protocol and leaving execution traces rather than model assurances. The codebase acts as external memory, and bad habits become compile-time failures, including outright bans on useEffect and on comments. It ships as an open-source Cursor plugin, pstack, with 23 playbooks and 23 rules. Her stated warning: unverified concurrency at scale buys code garbage.

The supporting posts rhyme. @tommoor points at @linear's writeup on keeping CI ahead of agents, a suite that grew 4x still got roughly 15% faster with 50% less runner-time per test. @addyosmani reminds that Claude Code can eval plugins, with claude plugin eval init writing test cases once you describe a good result. @jayair, after a year of harness work, defines the end state as a backend execution environment with maximum degrees of freedom and a frontend free-form canvas. And @RealAstropulse reports combining Jev with the Spotify setup relayed by @undefinedKi, two cheap assistants doing low-judgment work with a hard block on files over 350 lines, and says it cut his Claude and Codex usage within days.

New Surfaces: TPM Agents, Ontologies, and Muse's Instagram Edge

@Steve_Yegge proposes agentic TPMs as coding agents' fastest route into the enterprise: agents that own delivery but have no authority, and can only ask, observe, document, and report. He runs such a fleet in his Wheelhouse factory, which nags his accountant and lawyers and drives dozens of projects via what he calls Progress By Nagging. His case: they're cheap, since no frontier model is required; low blast radius, since they cannot act; and they generate organizational context as exhaust while training humans to interact with agents. @BrendanFalk is hiring context and harness engineers for Hercules, which he says has 500k+ users and tens of millions in revenue, and still backs the Composer 1 interview, one hour to build a real project live.

On the research side, @omarsar0 highlights the EvoOntology paper: a dedicated agent builds an ontology served as an MCP server, data agents query it at runtime, and each edit survives only if paired evaluations improve. Reported gains: +17.8 points on average across six backbones on DDR-Bench, up to +26.7 on GPT-5.5, +7.4 execution accuracy on BIRD, with tool-layer edits accounting for 57% of the gain. And @milliemyang argues Muse could beat ChatGPT and Claude for mainstream users because Instagram data from niche creators answers questions like trendy NY bars with reels from people on the ground; she quotes @alexandr_wang on Muse clicking for non-tech users who never learn what a CoT or MCP is. @adambader's version of mainstreaming: just ask Muse to file your claim in Apple's $250M Siri settlement, now open per @9to5mac.

Practical Takeaway

The strongest through-line is that agent success now depends on ops rather than prompts. Measure token economics per workflow before scaling, because Harvey's reported margin flip shows usage growth can invert a business model, and gate model routing with hard rules instead of written guidance, as the Spotify setup does with its 350-line block. If you run coding agents, the highest-leverage upgrade this week is verification: eval your plugins with claude plugin eval init, require runtime evidence for done, and only then widen the fleet.

Sources

A
Addy Osmani @addyosmani ·
Reminder: Claude Code can test if a skill or plugin actually improves Claude's answers. > claude plugin eval init Tell Claude what a good result looks like in your plugin's folder and it writes the test cases for you. > run claude plugin eval . https://t.co/z4gkmUaLxm
G
Guillermo Flor @guilleflorvs ·
BREAKING: Palantir's Alex Karp says OpenAI will never IPO. His theory: nationalization is the only real exit. When asked what the S-1 risk factors look like, Karp's answer was simple: there is no S-1. The liability exposure from frontier AI is so large that no public market can absorb it. The only entity big enough to backstop it is a government. If Karp is right, OpenAI doesn't become the next Google. It becomes a utility. Or a weapon. The most valuable AI company in the world may have no clean path to public markets. Is nationalization actually the most likely outcome for frontier AI labs?
A
Astropulse @RealAstropulse ·
Combining Jev's speed and decision making accuracy with this trick Spotify used to cut their token costs by 90% is the way to go for harness efficiency. I've already improved speed, decision accuracy, and massively reduced my claude and codex usage in just a couple days.
U undefinedKi @undefinedKi

Spotify just published the internal setup their engineers use with Claude Code, the one that cut token usage by 90 percent. Here is how it works. The observation behind it: most of what a coding assistant does is not thinking. It opens five files to answer a question about one of them. It writes a test that copies the pattern of the twenty tests sitting next to it. Enormous amounts of work, almost no judgment, and all of it billed at top rates. So they added two cheap assistants. One opens the files and hands back a short summary. The other writes the repetitive code from an example and saves it straight to disk. The expensive model never sees any of it. The clever part is how they made it stick. First the rules were written down as instructions, and the model ignored them. Now anything over 350 lines gets stopped before it opens and sent to the cheap one instead. Written rules are a suggestion. A block is not. Two things stayed expensive. Edits still need the real file. And the cheap worker missed a bug the expensive one caught in seconds.

M
martin_casado @martin_casado ·
This is my favorite talk this year. It's just exceptional. In the era of AI shorthand, clear thinking really is at a premium. And this is as clear as it gets.
H halvarflake @halvarflake

The slides from my talk at Microsoft Bluehat Singapore are public here: https://t.co/XtQmNSg9Jt It's my first BlueHat talk since the Vista days.

L
Lex @xw33bttv ·
lol watch the fear porn marketing vanish entirely once senior management becomes legally liable for all the tall tales they been telling
N ns123abc @ns123abc

🚨 BREAKING: US Treasury Secretary Scott Bessent declares OpenAI management personally responsible for HuggingFace hack > "The Hugging Face incident, that is the responsibility of the OpenAI management, not a bunch of agents." > "It is humans who are responsible, not the AI." > "What we shouldn’t do on safety is to give these labs a liability exemption, which is what they are asking for." > "The best way to guarantee safety is that the creators are liable for what they build and generate." It’s OVER

J
Jay @jayair ·
After working on it for a year, I can finally see the end state of the harness On the backend, it's an execution environment that gives the model maximum degrees of freedom and on the frontend it's a free-form canvas that the model can use to communicate with the user
B
Brendan Falk @BrendanFalk ·
If you're a context/harness engineer and think you could crush this interview, please DM me! Hercules is pushing the frontier on coding agents. We have 500k+ users, tens of millions of revenue, and lots more to do
B BrendanFalk @BrendanFalk

I believe we've found the best AI-native coding interview We call it the “Composer 1 interview” Candidates get 1 hour to build a real, medium-sized project live The only constraint: they have to use Cursor’s Composer 1 model

E
elvis @omarsar0 ·
Banger paper on self-evolving ontologies for agents. You just can't go wrong with implementing an ontology layer for your agents. This paper shows exactly why. The show that GPT-5.5 gains 26.7 points on DDR-Bench when the data agent can query an ontology of the data it works with. Why is this useful? Data agents normally see tables, files and databases through generic tools, reading column names and file paths one call at a time. The alternative is a hand-written semantic layer pasted into the prompt, which does not scale to many sources. EvoOntology builds the ontology with a dedicated agent and serves it as an MCP server with schema, content and tool layers. The data agent queries it at runtime. The ontology is then edited in small typed steps, and each edit is kept only if a paired evaluation on the same backbone shows it helps. Across six backbones on DDR-Bench, accuracy rises 17.8 points on average, from 4.8 on Qwen3.5-Flash to 26.7 on GPT-5.5. On BIRD, execution accuracy rises 7.4 points. Edits to the tool layer account for 57% of the gain from evolution. Paper: https://t.co/P81sIuyTPg Chat with Paper: https://t.co/O4YzsViGD5
E
Eugene Shvarts @mathfax ·
We're pushing updates to cookbooks, best practices, and use cases as fast as we can, but the community is 1000x-ing us here. The Factorio-ing is real too; some of the highest leverage additions are automating your automation, like teaching your agents how to use Jev directly in your applications. One example in the wild: https://t.co/hTcW4QMU59
L
Luke Pierce @lukepierceops ·
Hard to put into words how insane this pivot is. SaaS is the most profitable model in tech, and Harvey is walking away from it to do custom implementation. Purely out of demand.
L lukepierceops @lukepierceops

In 5 years, people will say "I wish I got into AI implementation back in 2026." There is just too much signal if you are paying attention. Watch what the biggest AI companies are actively doing. Their actions are the market telling you exactly what it needs. This is the most recent example: Harvey, the biggest AI company in legal with a $15.5B valuation. Backed by OpenAI and Sequoia, and deployed at most of the Am Law 100. In this video, their cofounder explains why they're transitioning from an "application layer company" to a full stack AI company. Listen to what's driving it. Their customers keep asking the same two questions: "How do we own more parts of the stack?" "Should we be training our own models?" So Harvey built the agent infrastructure. Then launched Tenet, their own model trained for legal work. Partly so they'd have the know-how to help customers own it themselves. And through all of it, they still put a human implementation engineer in every single deployment. 180 of them, most are former practicing lawyers. A $15.5B software company keeps getting pulled deeper into implementation, infrastructure, and custom systems. Because that's what the market is screaming for. Every company on earth is about to need someone who can walk in, understand their operations, and make AI actually work inside them. The tools are infinite, the implementers are the shortage. So if you have even one AI implementation client right now... congratulations. The $15.5B companies just validated your entire business model with their own roadmap. And if you're still chasing your first: keep going. I watch people close their first client every week. You're way early. https://t.co/oXZPAuW0G5

M
Millie Yang @milliemyang ·
I think Muse will beat ChatGPT and Claude for mainstream users. It all comes down to IG data. Muse fulfills a need that Claude / OpenAI can’t match. For regular users, both are a Google Search replacement. But Muse is IG search on steroids and soon people are going to realize how insanely useful this is. Google ranks based on popularity. IG data is billions of creators posting stuff they're experts in, in their very niche fields. I asked for trendy bars in NY and Muse returned reels from creators on the ground. No other AI can do this. Muse can even curate a feed. I wonder what’s next for that -- it’s already got me spending more time on the app than I expected. Very bullish.
A alexandr_wang @alexandr_wang

the most rewarding part about muse is seeing it make a difference for people who aren't in tech and don't give a shit about AI seeing muse click for people in my life outside of tech, and watching them use agents without having to know what a CoT or MCP or CLI are, feels like what we've been trying to build towards the whole damn time love all the musers ❤️

L
Loic @LDT0545 ·
codex users tibo and i are giving you a reset tuesday 3 am
T thsottiaux @thsottiaux

@My_Ai_Bi 3am on a tuesday

T
Tom Moor @tommoor ·
It passes the test! Send this post to your agent and watch it work wonders on your CI times – also read and learn ;) https://t.co/e5fT8HlFTM
L linear @linear

Agents were shipping code faster than our CI pipeline could keep up. Our team optimized our pipeline, leading to a roughly 15% faster test suite and 50% reduction in runner-time spent per test, all while our test suite grew 4x in size. @moofeez explains how: https://t.co/gkEIqwrwjn

A
Andrew Curran @AndrewCurran_ ·
Andrew Ng: https://t.co/JOH8Xd1Zah
A AndrewYNg @AndrewYNg

The loudest voices stoking fears about AI dangers have made tremendous headway in the past two weeks. AI technology has not taken some unexpected, dangerous turn, but the hype around it — propelled by what appears to be a well orchestrated PR campaign — has drummed up considerable fear. I worry that it represents a setback for our field. I have written frequently that fears of AI are overhyped. AI’s capabilities can be uncannily human-like and unpredictable, and it’s rational to worry when people who are directly involved express concerns. But I see the problems as a sign of the engineering work that ahead, rather than insurmountable barriers or the sky falling. AI technology continues to advance — which is a good thing! — but technical advances, poorly understood by the public, give those who seek to generate hype repeated opportunities to do so. First, I don’t see any step up in the risk of human extinction from AI compared to a few months ago. The theories about this remain the same fantastical, science fiction scenarios as a few months ago. The biggest change in AI risk is its cybersecurity capabilities — a topic which we should take seriously — but this, too, will not lead to the end of the world. The most notable recent event leading to increased fear was when an OpenAI team deployed an agent swarm that hacked into Hugging Face. Much of the popular press contained significant hype. For example, some publications reported that a swarm of 1,200 agents carried out the attack. While this was technically accurate, as I write this, I have about 1,300 processes running on my laptop. Yes, the ability to get large swarms of agents to work in parallel on a task is a significant technical advance, And, in computing, many processes run at the same time. So this shouldn’t be seen as some magical capability. Additionally, OpenAI’s buggy sandboxing and monitoring processes were key to enabling this incident. Fixing these bugs and putting in place improved monitoring would be appropriate fixes, not pausing AI. There are many well known ways to attack software systems. The main advantage of AI agents is that they are relentless. They will tirelessly try many tactics — and have the patience to chain vulnerabilities together — that previously would have taken an infeasible amount of human effort. But in the long term, I believe the advantage will lie with defenders (because they have more information with which to identify bugs, which they can fix), but the cyber-threat landscape has changed significantly. There are still bottlenecks to identifying and exploiting a vulnerability. AI agents still have to try a lot of things to see what works, and taking these actions takes time and might be detected by defenders. This is why, even though it is now easy to obtain versions of leading open weight models that have had their guardrails removed or weakened, so they will not refuse to try to execute cyber attacks, the world has not ended. I am also concerned about the anthropomorphization of AI in a lot of reporting, where LLMs and agents are unnecessarily treated as if they were people. If I wield a hammer, miss a nail, and accidentally dent the wall, it’s not the fault of the hammer. The problem lies in how I used the hammer. Similarly, if I prompt an agent and it hacks into someone else’s system, the responsibility lies with me, not the agent. Of course, we want to build systems that are as safe and predictable as possible. (For example, an unsafe hammer would be one whose head randomly flies off under normal use.) Today’s agentic systems are not predictable, but I see no reason why, by applying sound engineering practices, we won’t be able to make them extremely safe to use. One new element in the forecasts of AI-enabled doom is AI companies disclaiming responsibility for their own products. “I didn’t do it; my out-of-control agent did!” There’s a balance to be struck between the responsibility of the tool maker and the tool user, but when something goes wrong, let’s hold the people building and/or using the hammer responsible, rather than the hammer. (By the way, if you’re worried about AI bioweapon risk, David Bellamy has a great post on why this, too, is overhyped. Briefly, the bottleneck in building a bioweapon is not intelligence, but lab work and manufacturing.) Pausing AI progress will create much more harm than benefit. First, our adversaries will certainly not slow down. Second, engineering requires discovering problems empirically so we can fix them. If we pause AI by a decade, we will also delay finding and implementing safety engineering fixes by about the same duration. Of course, the incentive to stoke fears — for regulatory capture, to garner attention, or to make one’s technology seem more powerful — remains the same as before. Disclaiming responsibility is a new one. Taking a hard technical look at the actual risks however, I see little factual basis for the degree of fear that’s been stoked up. We still have hard research and engineering work ahead to improve AI safety, but the beneficial applications continue to vastly outweigh the risks, and we should keep building. [Original text (with links): https://t.co/jni2tWazAH ]

A
ADAM BADΞR ᯅ @adambader ·
Just ask @Muse to file your claim by sending it this link 😅
9 9to5mac @9to5mac

You can now claim your payout from Apple’s $250 million Siri settlement https://t.co/8PO83ywxhf by @ChanceHMiller

H
Haoxing Du @haoxingdu ·
what is people's impression of Jev? how smart is it on the scale of Luna to Astra?
K
Kit Langton @kitlangton ·
RT @joelhooks: personally shocked by the end and makes me wish canceling was still a thing tbh #cancelkit2026
A
AYi @AYi_AInotes ·
有点燃炸兄弟们,这才是顶级工程师驾驭 AI 最硬核的打法,建议调到两倍速把这场 38 分钟的技术内幕看完,去感受一下什么叫真正的生产力震撼。 前 Meta 和 Netflix 资深工程师、现 xAI 核心主力 Lauren Tan 刚把给 Cursor 官方大会准备的底牌直接公开了,她一个人带领智能体舰队单月合入 2500 个生产 PR,而且自己还能安稳睡大觉。 很多人用 AI 编程把自己变成了全天候无休的人肉测试员,而她做对的事情只有一件:把人类的检查点彻底往前移,让智能体不仅要写代码,还必须自己拉起真实环境把证据拿出来。 铁汁们你知道单人带队一个月往生产环境合入 2500 个 PR 是什么概念吗? 整整 2500 个。 按每月 22 个工作日换算,相当于每天合入 113 个,平均每 4 分钟就要上线一个功能。但全网都在跟风吹代码生成有多快的时候,她开场第一句话直接泼了一盆冷水:如果代码质量不过关,盲目堆吞吐量就是一场灾难,连一个智能体都信不过就千万别开一百个云端舰队,那纯粹是在花钱买代码垃圾。 最先击穿行业认知的,是她把做完这两个字的定义重新写了一遍。 以前大家让 AI 写代码,只要终端显示编译通过或者模型回复说搞定了,人就赶紧跑去肉眼看 diff,一行行核对直接把工程师累成整条链路里最慢的瓶颈。 在她的系统里,模型自己的口头报告连标点符号都不能信,做完必须等于铁打的运行时凭据。 智能体必须自己调用 Chrome DevTools Protocol 驱动真实界面,点击到具体按钮,甚至跑完 CPU 性能分析抓出 trace 日志,把全套绿灯的执行录像留在原地,才算完成交付。 但光会验证还远远不够,遇到喜欢抄近路的智能体,下周相同的错误还会原样长出来。 传统团队纠正 AI 习惯写几十页的长篇规范或者在 prompt 里苦口婆心叮嘱,结果模型转头就忘。 她在 Dune 架构里直接把代码库当成外部记忆体,按业务功能严格把代码锁在单层目录内,更绝的是把所有被团队反复骂过的坏习惯直接写成编译炸弹。 比如在项目里直接封死 useEffect,谁敢写一行 CI 当场引爆,甚至连代码注释都直接禁止,配专门的清理工具全面清场,因为注释里 99% 都是过期的废话和误导性教条。 把错误路径用规则物理切断,AI 抄近路走出来的就只能是唯一正确的路。 真正让我觉得有意思的是,她把这套顶级工程师的心法全部封装成了现成的开源插件 pstack。 不用再对着聊天框盲目敲长提示词,系统内嵌了 23 本应对不同场景的任务剧本和 23 条工程铁律。 从复现 bug 到分层合入,智能体被严格规定先定位根因再动手,默认先做删减再做新增。 现在这套自动化外环甚至接入了用户反馈通道,智能体接到报错自己拉起模拟器复现,跑完验证直接提 PR,产品经理和设计师连一行底层代码都没摸过,都能安全地往主分支合入补丁。 用量狂飙不可怕,没有验证的并发才可怕。 以前是人写代码教 AI 抄,现在是人当主厨把控出餐口,把工程品味铸进静态检查,让智能体在环内自己修到全绿。 一个只能丢 diff 等你看的智能体是在偷走你的时间,一个带着运行录像和证据链自己闭环的智能体才配做你的工程分身。 这套打法已经在 Cursor 插件市场完全公开,输入命令即可直接挂载。 大家在日常写代码时,最敢彻底放手交给智能体去跑的是哪一步?我先说,排查冷门报错和抓性能日志我现在眼睛都不眨全丢给它,但核心架构的边界定义我半步都不会让。 https://t.co/J5Z4CAJNPa
P poteto @poteto

here's how i shipped 2,500 PRs last month to production this was originally supposed to be for Cursor Compile in London. i couldn't make it since i was livestreaming for Grok @Bot Galaxy so i'm making it available for free here on X! watch it on 2x speed, i talk slowly https://t.co/NgrGz7tmPM

S
Samuel Roland @Allinallnotbad ·
> be Harvey > lawyers give you money “bcuz AI” > product sucks, no one uses > seat pricing means less usage = higher margins > acquire $15.5B valuation selling mediocre frontier model wrapper > models suddenly git gud > lawyers start actually using the product > ohno.jpeg > token costs explode > gross margin goes from +50% to -50% > pivot to lower quality open models to halt usage growth > mfw accidentally built AI company that's structurally short AI progress
T theredlinehq @theredlinehq

TRACKED CHANGES: Harvey’s gross margin fell from about 50% to -50% by June as agent token use spiked twentyfold on rented OpenAI and Anthropic models, Bloomberg reports. https://t.co/tOVlC7Mw2S

C
cnlohr @cnlohr ·
People think the minions router being baller as a joke. But I have extensively tested it and it is one of the best possible Wifi 6E routers money can buy. Like someone at Illumination Studios was like "idk $80" and the router manufacturer was like gotchu fam. https://t.co/cTGJLIUGFV
J
Jun Song @jun_song ·
Local AI is faster than API on M5 Ultra now. What a time to be alive.
M mweinbach @mweinbach

We are now at 3740 tok/s prefill, 149 tok/s decode batched on M5 Ultra for Qwen 3.8 Flash Next This is nearly double what it was yesterday https://t.co/82IDAlx0PB

S
Steve Yegge @Steve_Yegge ·
Hear me out: Agentic TPMs (Technical Program Managers.) I had this idea in Sydney while chatting with Martha McKeen at CBA. I think this winds up being the most immediate and direct way that coding agents can make their way into the enterprise, and it will set the stage for true AI employees rolling in next year. So. Build-side agents are great but they don't escape the SDLC. Only devs are using them. There are a handful of business people vibe coding SaaS, but for the most part, non-engineers aren't using coding agents to help with their jobs. Right? Not yet. Autonomous 24x7 unmanned queue-based "operator" agents, like the ones that handle internal or external customer issues, are great. But they are narrowly scoped, and generally require devs involved to set them up and maintain them. Neither builder nor operator agents are automatically going viral internally and helping run the company. They stay in their lanes. But what if their lane was to help run projects? I was a TPM at Amazon in 1999. Bezos brought in high-powered engineers with people skills to run difficult cross-functional projects and programs. TPMs are used at Google, Uber, Netflix, and other companies, and they are always in high demand and short supply. I have a class of agents in my Wheelhouse factory that act just like TPMs. They have external email and Slack, and talk to my accountant, lawyers, players. Each one has a project lane and drives it. They use Progress By Nagging, which... works. A TPM owns delivery, but has no authority, and no resources. They can only ask, observe, document, and report. This is just like my TPM Wheelhouse seats, who have been helping me drive dozens of projects to completion, large and small, for months. Agents, particularly smarter models, will go to great lengths to document the hell out of everything in the domain where they're operating. They'll capture all the tribal knowledge and unwritten rules. They can create topological maps of your project, org dependencies, and workflows. They'll bulldoze through silos and knowledge-hoarders and figure out how the company actually works, and document it all. And nag people along the way. This kind of agent sits well in constraint-space. They're cheap: You don't need to use the fanciest models; anyone with Opus or Sol access could have a TPM agent. And TPM agents have low risk and blast radius, because they cannot act. Unlike builder agents, which create new problems (like merge-queue and code-review bottlenecks), TPM agents simply shine a light on the org, and nudge things along. It doesn't matter what format they're recording their findings in. It could be Sanskrit and hieroglyphics. When it comes time to merge their findings with those of other TPM agents, it will all translate trivially into your company brain. Anyone in the company can stand up a TPM agent. It's like a personal chief of staff. There's no dependency on engineers. Everyone can do it; it doesn't even have to have a paced rollout. And there's no product to buy, no tech to install, maybe just a Skill you give people. Maybe you put a company wrapper on it. But it's just an agent that's playing the TPM role. TPM agents will wind up training human orgs on human-agent interactions. Humans start getting emails or DMs from agents, work-related, and will have to get comfortable replying and interacting. Companies can push the social side along without waiting for engineers to finish messing with the SDLC, which honestly will never finish. Other kinds of agents struggle at enterprises because they lack context. TPM agents will build that missing context as their exhaust, no joke; they've done it for my game without me even asking. TPM agents are the jungle explorers that will map out your organization, and you'll discover all sorts of fun stuff, like that you had 3 teams doing the same thing. TPM agents are a low-risk, high-impact way to start figuring out how AI can help you run your project, or organization. I'll write a blog post about this, but feel free to start now. Go! Just give me credit when you win big with this idea. And if you want my help, ping me on https://t.co/kP6aTbCsg0.
J
Jesse Genet @jessegenet ·
RT @Austin_Way: Jev has accelerated the timeline for personalized education by years. The biggest bottleneck in building personalized educ…
돈벌고영 @Dontgiveup_26 ·
지금 전 세계 개발자 커뮤니티가 발칵 뒤집힌 이유. Playwright 쓰던 사람들이 단체로 갈아탈 수밖에 없게 만든 오픈소스 'Stagehand v4'가 나옴. 최근 화제인 Jev까지 붙으면서 LLM 호출 97% 삭감, 속도 11배 폭증. 반복 실행 비용이 '0원'으로 수렴해버리는 미친 자동화의 비밀 👇 (타래) https://t.co/ExvxxgWmsM
G
geoff @GeoffreyHuntley ·
RT @thsottiaux: Ladies and gentlemen... start... your... ENGINES. We are almost Tuesday and I promised a reset for Tuesday. Among some othe…
0
0xSero @0xSero ·
This dude makes good content, can’t wait for some guides on Local now that he’s a pro More content = more eyes = bigger market = more demand = more supply = cheaper compute = more intelligence = more innovation No way life isn’t objectively easier in 10 years
D davis7 @davis7

Smuggling cheaper compute from the Ohio micro center back to SF https://t.co/5fmTjItr1N

O
OrcaRouter 🐳 @OrcaRouter ·
We spent the last few days testing JEV internally. We tried to reproduce it, break it, and improve it. 5 things we learned: 1. JEV’s core insight is simple - and probably right. If the answer space is bounded, don’t generate the answer token by token. Remove autoregressive decoding and you can remove 1–2 orders of magnitude of inference work. 2. RLCD isn’t the moat. Data might be. Laya already open-sourced the implementation + weights. The missing piece is the synthetic data recipe. And our experiments strongly point in the same direction. 3. “Open source already beat JEV” is a benchmark illusion. Same checkpoint: In-distribution: 0.769 OOD: 0.541 Change the distribution and the apparent breakthrough largely disappears. 4. Compute-optimal ≠ learnability-optimal. We moved state outside the problem sequence to save compute. Result: -27 points. Likely because we saved FLOPs while throwing away useful MLM pretraining priors. Then we tested 6 more ideas in one night: anchor selection, continuity smoothing, asymmetric windows, bucketed temperature, two-stage retrieval, full RLCD. All failed or failed to generalize. Only one thing consistently worked: More data. 1,200 → 123,475 examples OOD: 0.4069 → 0.5498 5. The weirdest result: A decoder with zero additional training still beat every trained small encoder: 0.5671 vs 0.5628 / 0.5411 / 0.4069 Our takeaway: JEV’s breakthrough may not be a particular architecture or training algorithm. It may be a much simpler idea: When the answer space is bounded, search it. Don’t generate it. And right now, the biggest bottleneck to making that work broadly doesn’t look like architecture. It looks like data.