We placed the fruit fly brain inside Odyssey-3, a frontier world model. The lil’ guy is now flying around totally imagined, simulated worlds all by itself 🫶

My hypothesis, after months of building with agents every day. Software work has three parts. Deciding what to build. Building it. Checking that it works. For decades the middle part was the expensive one, so we organized everything around it. Job titles, team sizes, estimates, how agencies charge. Agents are collapsing the middle. The two ends aren't getting cheaper at all. If anything they matter more, because a bad decision now gets built in an afternoon. So the valuable person is whoever owns the ends. I call that person a product builder.

Young people actively hate AI. My two younger daughters are 19 and 18, both at universities - one in the UK the other in Italy. Through them, I happen to know quite a few kids their age. And ALL OF THEM seem to universally hate AI. To them it's "something old people invented that we now have to deal with... as if climate change wasnt enough" AI is cringe. When they introduce me to their friends, they literally say "heyya, meet my dad, he's a software engineer but nonono, NOT IN AI, dont worry, hahah". They hate it for flooding their social feeds with slop, ruining music, taking phone scams to the next level, also destroying careers & devaluing their hobbies - why become an architect, this skill is about to become worthless? Why learn a musical instrument if session musicians are already obsolete? The outcome is interesting, though - they're spending less and less time on public social, meeting up IRL, moving their online lives into private group chats with actual verified friends. TikTok and Reels are increasingly cringe-something for old dudes. Which, I guess, might be a net positive after all...

AI can write code faster than ever, so why does reviewing it still take just as long? That’s the question @codefrenzy explores in her #YOW26 talk - The Wrong Side of the Equation: Cybernetics for the Agentic Era.

“Systems engineering is the attempt to keep at all times the larger goals in mind and to translate local actions into global results.” — Richard Hamming.

🚨 BREAKING: A Broadcom Wi-Fi bug lets anyone in range run code on routers without the password. Quentin Kaiser showed it on Proximus, Orange Belgium and VOO routers and estimates ~1.5M in Belgium are exposed, none patched. The bug dates to 2010. Broadcom won't assign a CVE.

Do any of the sandbox providers give me the ability to: - have N sandboxes running with disks that... - can be mounted on another sandbox (at least 32 at a time) - without knowing those mount points before the sandbox has started - and being able to vary them throughout the lifecycle of that one sandbox? im basically looking for a way to have a parent sandbox, N children sandboxes (where N varies, and has max X concurrency, which would be lower than max of N), and have those children write to a point on the disk that the parent could read from. N readers 1 writer semi-persistent disks.

In July we open-sourced a dynamic graph of everything a child learns in primary school. 1,590 concepts, 3,221 dependencies. Now we’re turning every concept into interactive experiments kids can play and learn from. First one, age 7: heat and water. Everything that used to be a boring textbook can now be an engaging experience, potentially tailored to every child. Kids education just got a massive upgrade.

It's such a strange time to be a programmer. In a two-minute span it's "DDD and domain modeling generally are more important than ever" then "reading code is a waste of time, just let the agents manage it" then "classical software design principles are what matter." Please help.

We had a security breach last night related to a large scale distillation attack that impacted 1.4% of OpenCode Console users We have notified them all this morning via email. If you did not get an email you were not impacted, it was a subset of users who had external providers linked The incident is ongoing so we cannot share more details at this point but we are working with Anthropic, OpenAI, and Google to remediate

Very excited to share the most important discovery of my career yet: your brain switches between a conscious and an unconscious mode ~15 times every second. Consciousness may depend not on where in the brain activity occurs but when. Find out more below. bit.ly/3WvA6di

New from our STEM Fellows Program: Designing more efficient quantum circuits with Claude. Given plain-language instructions, Claude Mythos 5 designed quantum circuits that improve on the best published ones, sometimes by an order of magnitude or more. More efficient circuits reduce the resources needed by quantum algorithms, which could bring quantum computing applications in chemistry and materials science within reach sooner. Read more: anthropic.com/research/desig…

For a while now, @kirancodes has been excitedly telling everyone at @BasisOrg who would listen about a crazy idea she's been pursuing. Not everyone thought it was possible, but it's starting to work. See basis.ai/blog/ship-your-inte… TL;DR: The bottleneck in verifying the world's software is shifting from theorem proving to specifications and semantics. We now have a way to verify semantics that can scale across all programming languages. The basic idea: To verify that a program is correct, you need the program, a specification you want to prove, and a semantics that defines what programs and specs mean. Most programming languages (Python, Ruby, Lua…) have no formal semantics, because semantics are painful to write for complex languages. You can ask an LLM to write a semantics for you, but it'll probably have mistakes. But (i) programming languages do have interpreters/compilers, which ultimately are compiled down to machine code, and (ii) some instruction sets do have formal semantics. RISC-V has an official formal model. So, crazy idea: Step 1: Compile your interpreter (e.g. Python's) down to RISC-V. Now its behaviour is formally defined. It's exact, but unreadable: thousands of machine instructions. Step 2: Ask your LLM to write a semantics for your language. Step 3: Ask the LLM to prove, in @leanprover, that its semantics agrees with the compiled interpreter on every possible program. If the semantics is wrong, the proof gets stuck, and the LLM goes back to fix it. Step 4: If the proof goes through, you have a semantics you don't need to trust, and you can verify programs in a language that never had one, with guarantees that reach the binary that actually runs. Kiran has now done this end to end for a simple WHILE language, and we're scaling it up to Lua and OCaml, with Python as the north star.

👀 @hillelogram 📎 Formal Verification of LLM-Generated Code ssvlab.github.io/lucasccorde…

CLAUDE FOUND THE SEEDS anthropic.com/research/ecdsa…

interpretability might be the most important scientific problem in the world right now, as I don't think we can solve alignment if we don't know what we're building. I think I have good news about it. I co-authored early work in mechanistic interpretability at OpenAI and came away pessimistic, because neural networks appeared to fold into arbitrary tangled knots. years later, I started openai's first large-scale automated interpretability project, finding about 2% of neurons legible with the primitive tools we had with modern agentic tools and a much closer look, the picture looks totally different. the vast majority in models up to trillions of parameters are legible, and their circuits beautiful. many famous examples of tangled neurons turned out to be misunderstood. The roadblocks I expected mostly aren't there. I now think ambitious interpretability will be solved by the time we need it most, and possibly quite soon, as automated scientists keep improving. it may be a bitter lesson for interpretability: the simple thing, at absurd scale, works already-clean.goodfire.com/

When I think about what the future of programming looks like, I think about formal methods. It’s the natural answer to both increasing levels of abstraction and increasing needs for assurance. But what’s the future of formal methods exactly? Here are two projects I think give a glimpse: 1. Simon Henniger’s Djinn, a spec first language which reimagines logic programming in an era where the synthesis of both code and proof can be done agentically: henniger.dev/post/djinn/ . Look closely at the resulting performance gains! Making ripgrep 3% faster while being provably equivalent is not easy. 2. Sam Xifaras’s ruby semantics done quick: samx.io/blog/topics/devlog/2… . Sam smartly dodges the inevitable “@kirancodes found a bug in my semantics” moment by leading with known limitations up front — and he presents a really interesting take on how to vibe semantics, with differential fuzzing for comparison.

Received a moving message from an aspiring mid-20s professional that, I think, captures an increasingly widespread despair among younger cohorts: "It really saddens me when I hear about the work [senior people in the field] are doing. Their work seems interesting, and I'll never get to do it. The people in their fifties and sixties, they're lucky. I'm even lucky. I feel bad for the kids who are fourteen. I at least got a chance to use my brain for one or two minutes, and that's still priceless. I got to be human. I got to be more than just some puppet who presses Enter so something can think for me. It's very depressing looking at people who are sixty, who I would love to be in twenty years. But to know that I won't get to do that because Dario said so, right? And, like, that's actually heartbreaking. It's heartbreaking to know that no matter how hard you try and no matter what you do, you cannot add value as a human being in a year or two's time. It's like hitting a brick wall. You feel no motivation to build the skill, to get better, to attain wisdom and knowledge. It seems worthless to you. And all the older people are telling you all your efforts might be worthless, and they don't need you anymore. And they can just sit there and, you know, make money and leave you to drown."

I've been mulling over Peter's thoughts in this post for a couple of months, and it's finally hit me: LLMs have essentially disconnected the concepts of production and verification, which for most of human history have been inextricably linked. Put another way: they can create things without understanding them. In the past it was vanishingly rare for someone to produce a correct complex math result, or a large functional program, while simultaneously having no idea how it actually worked. Humans essentially create through a process of "incremental verification". We are constantly course-correcting. A convincing sounding rebuttal to this position is "but a person using Wix has no idea how their website actually works!". That's somewhat true for the end user themselves, but someone, somewhere still does (the wix devs, the browser company, the AWS engineers, the linux maintainers, etc). We still hold the knowledge & understanding in aggregate across the human race at large, and the process for producing that website has been incrementally verified all the way up to the point that the end user engages with it. As a result, the elephant in the room is that this new mode of production relies on retroactive verification of the entire solution, which is extravagantly more expensive (in terms of human effort) than the incremental verification humans do along the way while creating something themselves. In fact from my experience with AI programming tools, I am beginning to suspect that retroactive verification is actually more expensive on its own than the entire process of creation "by hand" + incremental verification. I suspect this is also the reason why the most successful users of AI code generation tools seem to be people who are a) experts in their domains already and b) willing to babysit the production of the software in small enough chunks that they can personally incrementally verify the output. When OAI dumps 1000s of math proofs on the community, they're essentially washing their hands of the work required to actually verify the results. I wouldn't be surprised if paradoxically, we see the cost of verifying these "P-like" tasks actually greatly increase over the next 10 years, as experts tire of verifying machine generated output, and are forced out of the field by changes in economics. Of course people love to talk about the idea that "the LLMs will verify the output" but if you've used any of these tools you'll know that they all suffer from the same seemingly intractable "steering problem", where the output is dependent on the expertise of the operator. This is as true today as it was in the very early stages. Put simply, if you don't have any experts that can verify things by hand, LLM verification isn't going to help you.

We discovered a sophisticated recording device that was hidden inside one of our offices. We used our models to understand the device and where it had come from, identifying that a specific employee had planted it a few days earlier. We referred the matter to the FBI, and we’re grateful to the agents and prosecutors who moved quickly to make an arrest. The FBI’s investigation is ongoing and we will continue to support their work. At this time, we have no indications of this individual inappropriately accessing or exfiltrating model weights, source code, or customer data. The employee was terminated. We take protecting our technology, data, and people seriously, and as a matter of national importance. Our security program is designed to protect against a wide range of threat actors, from insider risks to cybercriminals to nation states, and this case is an example of how AI can help address these sophisticated security threats.