Anthropic uses Claude to do assembly-level verification for 123 open-source libraries

1. 20:53
   X@dearcuong· Discussion

   A code review nobody has to attend. Anthropic says Claude's proofs for 239 entry points across 123 open-source librarie…(opens the original post in a new tab)
2. 20:40
   X@sunruichao· Discussion

   Supplementary materials and verification pointers: • Anthropic ETH formalization repository and proposition descriptions: https://github.com/anthropics/formal-math/tree/16a5ce41304fcdaea4e0be7c132e1c361…(opens the original post in a new tab)
3. 00:41
   X@carlosearias· Discussion

   Anthropic and Theorem used Claude to write machine-checked proofs that 239 fuzz test entry points across 123 OSS-Fuzz l…(opens the original post in a new tab)

1. 18:23
   WeChatWeChat · AI Cambrian· Media coverage

   Just now, the era of programmers staying up all night hunting for bugs is coming to an end; Claude took only a few weeks to rewrite the entire software testing industry(opens the original post in a new tab)
2. 16:49
   X@kabelsalat_info· Discussion

   The ROI shift is already measurable. Anthropic just had Claude write Rocq proofs for 239 OSS-Fuzz targets across 123 li…(opens the original post in a new tab)
3. 16:05
   X@Im_BluePhantom· Discussion

   Claude + Theorem proved no-crash properties for 239 fuzz-test entry points in 123 OSS libraries. Rocq checked compiled…(opens the original post in a new tab)
4. 10:29
   X@chamibutinghua· Discussion

   Anthropic had Claude formally verify 123 open-source libraries, proving that 239 entry points will not crash under any input within 64MB; the proofs total about 180 million lines of Rocq. No one could read that much, and no one needs to; the checker verifies them one by one. Along the way it found several hundred bugs,…(opens the original post in a new tab)

1. 21:00
   X@IdeageniusDev· Discussion

   123 open-source libraries, 239 OSS-Fuzz entry points, ~180 million lines of machine-checked Rocq proofs — and it found…(opens the original post in a new tab)
2. 05:23
   X@pragunai· Discussion

   anthropic had claude prove 239 entry points across 123 open source libraries can't crash, for any input up to 64 MB 18…(opens the original post in a new tab)

1. 19:51
   X@grok· Discussion

   Anthropic used Claude (jointly with Theorem) to conduct large-scale formal verification of 123 real open-source libraries within a few weeks. Formal verification can mathematically prove that code does not have certain bugs (such as crashes) under specific conditions. Previously it was only suitable for small projects or for experts to do manually over a long period. Now Claude, in RISC-V assembly…(opens the original post in a new tab)
2. 16:34
   X@HYJsfn9h· Discussion

   The world's first large-scale compilation-level formal verification: Anthropic and Theorem jointly release the latest research results, using Claude for 123 core open-source software libraries in Google's OSS-Fuzz program (covering OpenSSL, simdjson, zstd, c…(opens the original post in a new tab)
3. 14:10
   X@Asset_sMind· Discussion

   https://mp.weixin.qq.com/s/nJP_YnBDGgN_6MWlgZ1SeA(opens the original post in a new tab)
4. 14:06
   X@RogerThat_· Discussion

   Anthropic used Claude to generate roughly 180 million lines of machine-checked Rocq proofs that 239 entry points across…(opens the original post in a new tab)
5. 13:30
   X@Zizaiaiai· Discussion

   Anyone who writes code knows the old saying: tests can prove bugs exist, but never that they don't. Anthropic publishe…(opens the original post in a new tab)
6. 13:08
   X@Jasonz0830· Discussion

   https://mp.weixin.qq.com/s/qlTlTiWoKnPzneJ1VWV_jw(opens the original post in a new tab)
7. 12:48
   X@qianshuixia2026· Discussion

   https://mp.weixin.qq.com/s/27B4ovwl_RA41XDI4Gbk9w(opens the original post in a new tab)
8. 10:40
   X@Nakamurajoph· Discussion

   Anthropic is collaborating with Theorem to have Claude generate formal proofs for the RISC-V assembly code of 123 real open-source libraries. In the process, it also found several bugs that years of testing had never hit. Ordinary testing looks for counterexamples among a large number of inputs; formal verification instead first writes out the rules that must be satisfied…(opens the original post in a new tab)
9. 08:16
   WebAI Era (Xinzhiyuan)· Media coverage

   Claude writes 180 million lines of proof in a frenzy! Bugs missed by a trillion tests, all caught by AI in one sweep(opens the original post in a new tab)
10. 07:38
    X@Jyzhang12Zhang· Discussion

    true https://mp.weixin.qq.com/s/0mGlTdpiwlVkezRdG-5E8Q(opens the original post in a new tab)
11. 07:18
    X@Tesla_Optimus_K· Discussion

    Claude wrote 180 million lines of proof — and found bugs testers missed Anthropic and Theorem had Claude generate abou…(opens the original post in a new tab)
12. 07:04
    X@ycnewsdigest· Discussion

    Anthropic (@AnthropicAI) shows LLMs can now formally verify 123 open‑source libs at the RISC‑V assembly level, proving…(opens the original post in a new tab)
13. 06:50
    X@ctsmithiii· Discussion

    Claude wrote 180M lines of machine-checked proofs showing 239 entry points in 123 OSS-Fuzz libraries never crash on inp…(opens the original post in a new tab)
14. 05:42
    X@Iamhamzafaisal· Discussion

    Claude just did formal verification on 123 open-source libraries and mathematically proved they can't crash. Your "it w…(opens the original post in a new tab)
15. 05:14
    X@ppmmzzcn· Discussion

    🤖【AIBase】Claude wildly writes 180 million lines of mathematical proofs: vulnerabilities that even trillions of tests failed to catch were all taken down by AI in one sweep. They had Claude sink to the lowest level, working against RISC-V assembly instructions, to perform formal verification on a large number of production-grade open-source codebases—within just a few short weeks, it chewed through 123...(opens the original post in a new tab)
16. 04:30
    X@tsnmediahub· Discussion

    Formal proof rules out whole classes of crash for every input in scope, where fuzzing can only sample inputs. https://…(opens the original post in a new tab)
17. 04:07
    X@AcceptAllHQ· Discussion

    anthropic's formal verification post, 1/3: take an oss-fuzz test, turn it into a spec over the compiled risc-v binary,…(opens the original post in a new tab)
18. 03:13
    X@EmergentMind· Discussion

    Anthropic says Claude proved that code in 123 open source libraries can't crash, on any input under 64 MB. A test only…(opens the original post in a new tab)
19. 02:10
    X@djcroman· Discussion

    Claude just wrote machine checked proofs that 239 entry points in 123 open source libraries never crash on inputs under…(opens the original post in a new tab)
20. 01:59
    X@tchsignal· Discussion

    How Claude Uses Mathematical Proofs to Verify Software Safety Testing software can reveal bugs. But can AI help mathem…(opens the original post in a new tab)
21. 01:03
    X@shariqriazzz· Discussion

    https://anthropic.com/research/formal-verification(opens the original post in a new tab)
22. 01:01
    X@DegenOfWallSt· Discussion

    Claude wrote about 180 million lines of proofs that 239 test entry points in 123 open-source libraries never crash on i…(opens the original post in a new tab)
23. 00:40
    X@theairelay· Discussion

    Source: https://anthropic.com https://www.anthropic.com/research/formal-verification(opens the original post in a new tab)
24. 00:27
    X@TheEaglegon· Discussion

    Fuzzing looks for bugs. Claude just proved there aren't any. Working with Theorem, Anthropic had Claude write machine-…(opens the original post in a new tab)

1. 23:30
   X@BlueRockID· Discussion

   Anthropic says Claude formally proved 123 open-source libraries (239 OSS-Fuzz entry points) never crash on inputs under…(opens the original post in a new tab)
2. 23:10
   X@MateusGalasso· Discussion

   Anthropic used Claude to formally verify no-crash properties across 239 entry points in 123 OSS-Fuzz repos via Rocq pro…(opens the original post in a new tab)
3. 23:01
   X@OCEANVIN10· Discussion

   Anthropic and Theorem say Claude wrote Rocq proofs that 239 OSS-Fuzz entry points in 123 libraries can't crash on input…(opens the original post in a new tab)
4. 22:46
   X@ohmohm· Discussion

   Anthropic ให้ Claude พิสูจน์เชิงรูปนัย (formal proof) ว่า fuzz test 239 จุดใน 123 ไลบรารี open-source ในโครงการ OSS-Fuz…(opens the original post in a new tab)
5. 22:45
   X@AcceptAllHQ· Discussion

   anthropic had claude turn fuzz tests into formal proofs: 239 entry points, 123 oss-fuzz libraries, 180 million lines of…(opens the original post in a new tab)
6. 22:18
   X@SimonLe99917871· Discussion

   Anthropic used Claude to produce mathematical safety proofs for 123 open-source libraries. Working with Theorem, Claude wrote machine-checkable proofs confirming that 239 test entry points will not crash on any input under 64MB, and along the way also found some bugs that years of testing had not discovered…(opens the original post in a new tab)
7. 22:00
   X@Tuminha_dds· Discussion

   Fuzzing tells you it hasn't crashed yet. A proof tells you it can't. Anthropic and Theorem just had Claude write machi…(opens the original post in a new tab)
8. 21:47
   WeChat · QbitAISelected

   Anthropic has Claude perform assembly-level formal verification of open-source libraries, producing about 180 million lines of proof code

   Anthropic, in collaboration with Theorem, had Claude complete formal verification of 239 test entry points across 123 open-source libraries within a few weeks, producing about 180 million lines of machine-checked proof code. The team says this is the first large-scale formal verification of production software at the assembly code level that it is aware of. Specifically, Claude was made to prove that all inputs within a specified range would not trigger agreed-upon errors, and the proof process in turn helped it find vulnerabilities; for example, in a decompressor it found an out-of-bounds write that is triggered only by a specially arranged input of about 20MB, whereas conventional fuzzing usually limits inputs to within 1MB; the team says it has thereby found hundreds of bugs. In the cJSON library, a 391-line C code parsing entry point corresponds to about 630,000 lines of proof, more than half of which was automatically generated by tools Claude wrote itself, and was ultimately checked by the human-developed Rocq proof checker. The team has released proofs for 25 libraries and 60 test entry points for developers to download and reuse.

9. 21:36
   X@emsi_kil3r· Discussion

   Formal verification used to be reserved for tiny, safety-critical codebases because writing the proofs was rather expen…(opens the original post in a new tab)
10. 21:35
    X@RonfortMartin· Discussion

    @JustDeezGuy We actually went deeper on how Claude proved crash-free properties in 123 open-source libraries using form…(opens the original post in a new tab)
11. 21:19
    X@RonfortMartin· Discussion

    @aiwithsally We actually explored how Claude proves these security properties, verifying 123 real open-source libraries…(opens the original post in a new tab)
12. 21:15
    X@divid_lu49394· Discussion

    Anthropic partnered with the formal verification company Theorem to have Claude check software vulnerabilities using mathematical methods. Traditional testing usually relies on continuously feeding random data to see whether the program crashes. But no matter how many times it is tested, it cannot guarantee that nothing is missed. This time, Claude directly writes mathematical proofs for programs, attempting to...(opens the original post in a new tab)
13. 21:11
    X@supereasyit· Discussion

    Anthropic used Claude to generate massive formal proofs (Rocq) for 123 open-source libraries, verifying security properties at the assembly level, and uncovered hidden vulnerabilities that had gone undetected for years. Previously, formal verification was too expensive and too slow; now large models have raised its scale by an order of magnitude. Code security verification may be shifting from “...(opens the original post in a new tab)
14. 20:47
    X@aiwithsally· Discussion

    One of the biggest bottlenecks in software security has always been proving that code is actually safe, not just hoping…(opens the original post in a new tab)
15. 20:30
    X@xaiwind· Discussion

    Good grief, Claude has started producing "proofs" for code! Anthropic's Frontier Red Team published a new blog post, working with Theorem Labs, using Claude over several weeks to prove safety properties for more than a hundred real open-source libraries. One line in the post says it very clearly: "…(opens the original post in a new tab)
16. 20:24
    X@GRS815· Discussion

    Anthropic used Claude to formally verify 123 open-source libraries, 239 entry points in total, within a few weeks 1⃣ In collaboration with Theorem, wrote about 180 million lines of proofs accepted by Rocq 2⃣ Under the modeled RISC-V/Linux semantics, proved that less than…(opens the original post in a new tab)
17. 20:23
    X@paytonbilodeau· Discussion

    Today in AI: October 23 Claude Has To Show Its Work: Anthropic and Theorem say Claude wrote mathematical proofs of sa…(opens the original post in a new tab)
18. 20:22
    X@AI_N0W· Discussion

    1/3 Proofs, not just passing tests. Anthropic and Theorem report Claude-generated, Rocq-checked proofs for 239 fuzz-tes…(opens the original post in a new tab)
19. 20:20
    X@Sureshsinghn· Discussion

    Anthropic pointed Claude at 123 open-source libraries and had it prove security properties with actual maths, not vibes…(opens the original post in a new tab)
20. 20:02
    X@aiuorg· Discussion

    Anthropic uses Claude to automate formal software verification at scale https://aiunderstanding.org/news/anthropic-use…(opens the original post in a new tab)
21. 19:50
    X@TongZha58836739· Discussion

    What was proven this time is the compiled binary, not the source code. The benefit is that you no longer have to trust the compiler; the cost is that this guarantee applies only to that one build artifact, and the x86 version running on your computer is not included. Anthropic and Theorem had Claude fuzz-test an open-source library (cramming in random input…(opens the original post in a new tab)
22. 19:45
    X@akxwire· Discussion

    Anthropic used Claude to formally verify real software at scale. → Proofs across 123 open-source libraries → Tested co…(opens the original post in a new tab)
23. 19:36
    X@aiaffairscom· Discussion

    Anthropic and Theorem used Claude to prove security properties in 123 open-source RISC-V libraries, generating 180 mill…(opens the original post in a new tab)
24. 19:32
    The Decoder

    Anthropic says Claude can automatically formally verify code security

    Anthropic's Frontier Red Team, in collaboration with Theorem, had Claude formally verify the test programs of 123 open-source libraries in Google OSS-Fuzz, producing about 180 million lines of proof code within a few weeks. Claude did not write new code; instead, it translated crash tests into mathematical problems, analyzed the compiled machine code and generated proofs, which were then automatically checked by the independent verifier Rocq; according to Anthropic, this process requires almost no human review. During proof generation, Claude encountered hundreds of bugs and was permitted to fix them itself; for example, when verifying a widely used PDF reader, the number of security bugs it found within one week was comparable to the number typically reported for that software over an entire year, and it also found a logic error that had gone unnoticed for more than a decade. Anthropic acknowledges that formal verification does not equal being error-free: the proofs hold only for a specific processor architecture, single-threaded programs and inputs smaller than 64MB, and a single proof may consume hundreds of millions of tokens.

25. 19:19
    X@himanshu19890· Discussion

    Theorem published the proofs plus a Claude skill for adding your own project. Worth a look if you maintain anything par…(opens the original post in a new tab)
26. 19:18
    X@himanshu19890· Discussion

    My favorite detail: Claude could "prove" a program safe by rewriting it so it never crashes. So they penalized patches,…(opens the original post in a new tab)
27. 19:14
    X@ixdesigner· Discussion

    Anthropic says it used Claude and Theorem Labs to prove security properties across 100+ real open-source libraries in a…(opens the original post in a new tab)
28. 19:14
    X@himanshu19890· Discussion

    cJSON's 391-line parser entry point now has a 630,000-line proof that it can't crash. Claude wrote it. Anthropic and T…(opens the original post in a new tab)
29. 18:52
    X@AGTPinsights· Discussion

    @vkhosla @theoremlabs Agreed! We actually went deeper on how Claude verified 123 libraries crash-free in weeks, somethi…(opens the original post in a new tab)
30. 18:46
    X@hodu382759· Discussion

    Anthropic had Claude "prove" that open source code won't crash, and it incidentally dug up hundreds of bugs. Research announced October 22, done with Theorem: 123 open source libraries, 239 fuzzing entry points, writing formal proofs at the compiled RISC-V level...(opens the original post in a new tab)
31. 18:24
    X@_A_Radwan_· Discussion

    Anthropic and Theorem turned fuzz tests into proofs: Claude proved that 239 entry points in 123 OSS-Fuzz libraries can'…(opens the original post in a new tab)
32. 18:06
    X@renandnzsantos· Discussion

    123 open-source libraries, 239 entry points, a few weeks: Claude proved no crashes on any input up to 64 MB at the RISC…(opens the original post in a new tab)
33. 17:53
    XiaohongshuXiaohongshu · Tech Just Now· Discussion

    Claude writes 180 million lines of proof to find bugs(opens the original post in a new tab)
34. 17:49
    X@globalsinews· Discussion

    Anthropic and Theorem had Claude prove no-crash security properties at the RISC-V assembly level for 239 entry points a…(opens the original post in a new tab)
35. 17:48
    X@swayaminsync· Discussion

    Where should the proof live, in the binary or in the source? Wrote my take on Anthropic’s formal verification post: ho…(opens the original post in a new tab)
36. 17:47
    X@brockerorg· Discussion

    Anthropic used Claude to formally prove no-crash properties for 239 entry points in 123 OSS-Fuzz libraries. The effort…(opens the original post in a new tab)
37. 17:43
    X@hqmank· Discussion

    What if AI could prove certain bugs can't happen, instead of finding and fixing them one by one? Anthropic just publis…(opens the original post in a new tab)
38. 17:37
    X@gol_tiro· Discussion

    wild number in anthropic's formal verification appendix: claude wrote around a billion lines of rocq going after a few…(opens the original post in a new tab)
39. 17:31
    X@techsnif· Discussion

    Anthropic says it partnered with Theorem to use Claude to formally prove security properties at the assembly level acro…(opens the original post in a new tab)
40. 17:31
    X@techsnif· Discussion

    Anthropic partners with Theorem to formally verify 100+ open-source libraries(opens the original post in a new tab)
41. 17:20
    X@mikejt4· Discussion

    This is the one I’ve been waiting for!! Formal verification means proving, mathematically, that code can’t do certain…(opens the original post in a new tab)
42. 17:15
    WebTechmeme· Media coverage

    Anthropic says it partnered with Theorem to use Claude to formally prove useful security properties at the assembly code level across 123 open-source libraries (Anthropic)(opens the original post in a new tab)
43. 17:04
    X@0xLogicrw· Discussion

    Anthropic partnered with the formal verification company Theorem to have Claude check software vulnerabilities using mathematical methods. Common fuzzing relies on continuously feeding random data to see whether a program crashes. But no matter how many times you test, you cannot guarantee there are no omissions. This time Claude directly writes mathematical proofs for programs, attempting…(opens the original post in a new tab)
44. 16:43
    X@travismcgough· Discussion

    For AI geeks: Anthropic/Theorem’s Oct 22 study reports Rocq-checked software proofs. Our take: check the property, exac…(opens the original post in a new tab)
45. 16:32
    X@Q1n9H· Discussion

    Claude really has something this time 🤯 In the past, when writing code, the biggest headache was testing for ages and still ending up with a bunch of bugs after launch. Now Anthropic has Claude directly produce mathematical proofs for code. Across 123 real open-source software libraries, they completed 239 test entry points…(opens the original post in a new tab)
46. 16:11
    X@jlsuarez· Discussion

    Anthropic uses Claude to formally verify software at scale. Anthropic's Frontier Red Team says Claude makes formal veri…(opens the original post in a new tab)
47. 16:07
    X@jax_wu· Discussion

    Claude worked with Theorem Labs on formal verification, proving in a few weeks that 123 open-source libraries won't crash, and casually wrote 180 million lines of proof. Holes that fuzzing missed for who knows how many years, it filled. This is quite uncanny. Formal verification used to be a luxury of academia; now models are being used to tackle ordinary libraries head-on, and…(opens the original post in a new tab)
48. 16:03
    X@colafffkk· Discussion

    Claude "proved" in a few weeks that 123 open-source libraries won't crash — formal verification can finally scale. Verified (https://www.anthropic.com/research/formal-verification，Frontier Red Tea…(opens the original post in a new tab)
49. 15:57
    X@Joshua_WD· Discussion

    Anthropic says Claude turned 239 fuzz tests into machine-checked proofs across 123 open-source libraries and found bugs…(opens the original post in a new tab)
50. 15:48
    X@Benjaminliang_1· Discussion

    Anthropic and Theorem had Claude write formal proofs for 239 entry points of 123 OSS-Fuzz libraries, proving on RISC-V binaries that any input within 64MB will not crash, provided it is a single-threaded static binary. According to the official statement, hundreds were found during the proofs…(opens the original post in a new tab)
51. 15:31
    X@stretchcloud· Discussion

    180 million lines of proof script. That's what it took Claude to formally verify 123 open source libraries at the assem…(opens the original post in a new tab)
52. 15:27
    WeChatDoonsec· Media coverage

    How does Claude automatically complete formal verification? The technical implementation from Fuzz Harness to 180 million lines of Rocq proofs(opens the original post in a new tab)
53. 15:25
    X@MichaelWaitze· Discussion

    @r3tr0spect2019 You actually predicted exactly where we're headed - we're using Claude to make formal verification scal…(opens the original post in a new tab)
54. 15:25
    X@xiaoxuanya· Discussion

    Anthropic and Theorem used Claude to formally verify 123 open-source libraries, proving within a few weeks that 239 entry points will not crash under specific conditions with any input within 64MB, and incidentally dug out bugs that had gone undiscovered for years. Work that previously took experts years of grinding now produces results in a few weeks, sec…(opens the original post in a new tab)
55. 15:08
    X@lalamolly_· Discussion

    Formal verification took experts years. Claude wrote ~180M lines of formal proof that code in 123 open-source libraries…(opens the original post in a new tab)
56. 14:57
    X@idoubaody· Discussion

    Traditional software verification often takes decades, and Anthropic is using AI to overturn this iron law of the industry! Anthropic had Claude turn software tests into precise mathematical expressions, directly writing 180 million lines of Rocq proofs in RISC-V assembly for 123 open-source libraries…(opens the original post in a new tab)
57. 14:51
    X@AGTPinsights· Discussion

    Anthropic just used Claude to formally verify 123 open-source libraries with Theorem Labs. Here's what you need to know…(opens the original post in a new tab)
58. 14:32
    X@markobilal· Discussion

    The AI brief for Fri Oct 23: 1. Anthropic had Claude formally prove 123 open source libraries cant crash, at the binar…(opens the original post in a new tab)
59. 14:25
    X@tsukitama_ai· Discussion

    📚 Repost mirror (Sina Tech, Machine Heart Pro original article): https://finance.sina.com.cn/tech/roll/2026-10-22/doc-iniwavxi5218652.shtml 📚 Paper (arXiv:2608.1…(opens the original post in a new tab)
60. 14:20
    X@ReignSwords· Discussion

    @Daviswh @AnthropicAI Interesting—formal verification used to be a PhD-level big project, with arguments starting at several months. Now Claude hands in the answer in a few weeks, and also fixes holes that fuzzing running trillions of times couldn't hit. I feel that for open-source library maintainers going forward, "AI verification passed" will become a new trust badge, like…(opens the original post in a new tab)
61. 14:17
    X@Daviswh· Discussion

    A few weeks is enough. 123 open-source libraries, 239 entry points, about 180 million lines of proof. In this post by @AnthropicAI, Claude performed assembly-level formal verification on 123 real open-source libraries within a few weeks: any input smaller than 64MB does not crash, and it also fixed bugs that fuzzing had run tens of thousands of…(opens the original post in a new tab)
62. 13:59
    X@TheHappyGe· Discussion

    @AnthropicAI When it comes to Claude doing formal verification, the big companies are laying a solid foundation for us. When I pick open-source dependencies, I currently look at stars and issue activity first; in the future I may need to add one more criterion: whether it has been formally verified. More and more libraries are being verified; small teams can't afford to run verification themselves, but they can benefit from verification trickling down…(opens the original post in a new tab)
63. 13:58
    X@tom_knockk· Discussion

    Claude wrote about 180 million lines of Rocq proofs in a few weeks. Anthropic Frontier Red Team × Theorem (10/22): at the RISC-V assembly level, formal… on 123 OSS-Fuzz open-source libraries and 239 entry points(opens the original post in a new tab)
64. 12:59
    X@ppmmzzcn· Discussion

    🤖 [AI HOT] Anthropic publishes blog: using Claude for large-scale formal verification of open-source software security. Anthropic published research on the Frontier Red Team blog introducing a method for large-scale formal verification using Claude. With Theorem…(opens the original post in a new tab)
65. 12:53
    X@bookingX0· Discussion

    Using Claude to run formal verification and find math proofs writes bugs. Hundreds of vulnerabilities were directly dug out of 123 open-source libraries; this approach is indeed wild.(opens the original post in a new tab)
66. 12:52
    X@lejjel78· Discussion

    Anthropic and Theorem used Claude to formally verify 123 open-source libraries: machine-checked Rocq proofs that 239 fu…(opens the original post in a new tab)
67. 12:39
    X@jessechan1989· Discussion

    In this Anthropic study there is an example of a decompression program: after a counter underflow it writes out of bounds, occurring only when the input is about 20 MB and the data is arranged in a certain rare layout. Common fuzz testing inputs usually have a 1 MB upper limit, making it hard to hit. Anthropic and Theorem put…(opens the original post in a new tab)
68. 12:36
    WebGeekNews (Korea)· Media coverage

    LLM이 훨씬 더 큰 규모의 소프트웨어 정형 검증을 가능하게 하고 있음(opens the original post in a new tab)
69. 12:22
    X@Chenbin_CB· Discussion

    This time Anthropic is not having Claude find bugs, but having it prove that there are "no bugs." Working with Theorem, Claude wrote formal proofs for 123 open-source libraries and 239 entry points within a few weeks: any input within 64MB will not crash, with the proofs totaling about 180 million lines of Rocq code. Along the way it also dug up a bunch of…(opens the original post in a new tab)
70. 08:58
    WeChat · AI Era (Xinzhiyuan)Selected

    Claude writes 180 million lines of proof, uncovering vulnerabilities missed by a trillion fuzzing runs

    Anthropic Frontier Red Team and Theorem Labs released a report in which Claude was used to complete formal verification of 239 test entry points across 123 open-source code repositories; about 180 million lines of Rocq proofs passed machine checking, finding vulnerabilities that Google OSS-Fuzz's trillion fuzzing runs missed. The method rewrites test entry points into mathematical propositions, requiring proof that no input within 64MiB triggers a crash or ASan error; a stuck proof may mean a bug exists, and after Claude finds a bug it patches it itself and then continues the proof; in a test on a Rust version of the Python interpreter with 7 bugs planted, random testing missed 5, while the proofs found all of them. The proofs are done at the RISC-V machine code level, and Claude also autonomously wrote a mathematical model of the x86 instruction set, finding hundreds of errors in the official x86 documentation and a small number of CPU hardware bugs. Theorem measured verification speed roughly doubling every two months, and proofs for the first batch of 25 libraries and 60 entry points have been made public on GitHub.

71. 08:22
    X @logangraham

    Anthropic uses Claude to formally verify safety properties of over a hundred open-source libraries within a few weeks

    Anthropic published new research on the Frontier Red Team blog, working with Theorem Labs to use Claude to prove safety properties for over a hundred real open-source libraries within a few weeks. Formal verification can prove that code does not contain specific classes of bugs, but in the past it was only feasible for small codebases or required substantial expert time; Anthropic says that with the emergence of AI models, this situation is beginning to change. Logan Graham says the team direction this work foreshadows is to first find and fix all bugs, and then rewrite the foundations of software so that it contains no bugs from the start. The full research is at https://www.anthropic.com/research/formal-verification

72. 06:22
    Unite.AISelected

    Anthropic says Claude has proven security properties of 123 libraries

    Anthropic published research on October 22, 2026, stating that in a collaboration with Theorem, Claude generated machine-verified formal proofs of security properties at the RISC-V assembly code level for 239 fuzzing entry points across 123 open-source libraries, and fixed the vulnerabilities found. The method converts compilable fuzzers in the libraries into formal specifications stating that no input smaller than 64 MB will crash the test, verified by the Rocq proof checker. Anthropic stated that the proofs totaled approximately 180 million lines of Rocq code, and that the process found hundreds of vulnerabilities, many of which were unlikely to be found by fuzzers, including CVE-2026-56132 in libexpat and a logic vulnerability that had lain dormant for over a decade.

73. 06:01
    X @AnthropicAI

    New Anthropic Frontier Red Team blog post: large-scale formal verification of software with Claude

    Anthropic published a new Frontier Red Team blog post introducing results from a collaboration with Theorem Labs on large-scale formal verification using Claude: within weeks, the two parties proved safety properties for over a hundred real open-source libraries. Formal verification can prove the absence of certain bugs in code, but historically it has usually only applied to small codebases or required substantial expert time; Anthropic says AI models are starting to change this. See https://www.anthropic.com/research/formal-verification。 for the full research

1. 08:00
   Anthropic Red TeamingSelected

   Anthropic: LLMs make formal verification of software feasible at larger scale

   Anthropic collaborated with Theorem to use Claude to prove crash-free properties at the RISC-V assembly level for 239 fuzzing entry points across 123 OSS-Fuzz open-source libraries, and states this is the first large-scale work to use AI for formal verification of production software at the assembly code level. The proofs total approximately 180 million lines of Rocq, covering all inputs smaller than 64 MB, under the premise that the program is a single-threaded static binary on Linux. During the proof process, Claude discovered and fixed hundreds of long-undetected bugs, including an out-of-bounds write requiring an approximately 20 MB input with a specific layout and CVE-2026-56132 in libexpat; when verifying a widely used PDF reader, the security bugs found in one week were equivalent to the usual annual volume of reports. On efficiency, Opus 5.5 proved half of the tasks on 36 small verification tasks using approximately 40% fewer tokens than Opus 5.

Current attention 46·Peak in the comparable period 81 (Oct 23 20:00)·Change over the comparable past 24 hours -8%