
Built, audited, and led several blockchain protocols to production. Looking for what's next via @untronfi @daimo_com @getclave
Joined July 2020
- Tweets269
- Following1.3K
- Followers1.3K
- Likes65.6K
AI is making cyberattacks far more dangerous, so at @axiom_xyz we formally verified @openvm_org to stay ahead of AI attackers.
Today we’re launching @Intrinsic_HQ to bring the same AI-powered provable security to the rest of software.
At Intrinsic, we apply AI to scale formal verification for software.
As a first result, we end-to-end formally verified @openvm_org, a production zero-knowledge proof system using @leanprover. Our verification shows OpenVM's cryptography is sound and matches its implementation.
Alex Hook retweeted
The bull case for formal verification is "Here is a reusable library of properties/specs you can import in your code" not "Here is a few million LOC of Lean for you to go over, but the model passes!"
Alex Hook retweeted
if you're a cryptographer and your repo doesn't look like this, you're probably cooked.
Alex Hook retweeted
Thrilled to announce that our @GoogleDeepMind team has cracked a major challenge in software engineering and cybersecurity: formally verifying a real-world implementation of the #Signal cryptographic protocol at the machine-code level. This proof was done using AlphaProof Code, our new AI framework for formal specification and verification.
* Paper: deepmind.google/documents/36…
* Lean code: github.com/google-deepmind/c…
* DeepMind blog post: deepmind.google/blog/introdu…
A huge shoutout to my amazing teammates: @tchajed,
@FerrousAndrew, Jonathan Katz, @pushmeet, @antonkovsharov, Karn Seth, Sam Schlesinger, @RandomlyWalking.
I started working on formal software verification 20+ years ago as a grad student. I was persuaded by Dijkstra and other computer science pioneers’ vision of programming backed up by mathematical theorems. At that time, we had to choose between automated code analysis algorithms that scaled but could only prove shallow properties, and deep manual verification that took decades of expert human work.
Thanks to progress in AI for mathematical reasoning, we don’t have to make that choice any more. Over four weeks in October 2026, AlphaProof Code agents generated more than 6 million lines of machine-checked Lean proof. We proved deep computational and symbolic security properties of the entire protocol core of Signal, all the way down to the ARM machine-code level.
This is just the first step, of course, because our goal is nothing short of verifying the world’s software infrastructure. Most cyberattacks, including the AI-powered ones recently in the news, happen because of preventable code bugs. I expect that agents for formal code analysis will eliminate these bugs one category at a time.
As our paper explains in more detail, this doesn’t at all mean humans are out of the picture! Proofs are now largely automated, but human experts will need to decide what is proved with AI assistance. AlphaProof Code offers an early glimpse of what such human-AI collaboration could look like, but many other proposals of this nature will emerge.
We have released all our Lean specs and proofs and plan to work with the open-source community on improving them. If you are building critical software and would like to apply these ideas, come talk to us!
x86 formal verification is coming!
The (first?) published machine-checked proof of a security property for the end-to-end execution of a Linux process running an x86 binary statically linked against glibc.
And we believe it scales!
A joint research project with @zellic_io 🧵👇
Alex Hook retweeted
Small announcement: ✅ formal-git
As an experiment, over the last 2 months we've modelled ~30% of Git in Lean 4, making heavy use of coding agents, and proved >8000 theorems of varying usefulness about the implementation.
In the process of doing this we've uncovered >100 potential defects in Git v2.55, at least two of which may constitute security vulnerabilities. We've also built a DRT (differential random testing) harness and the biggest corpus of relevant pinned differential test cases for Git implementations with >10k unique tests at the moment.
We've used the test cases to test our own small internal implementation of Git in TypeScript. The next step will be to differentially test all notable public Git implementations against this corpus of tests to help improve their correctness and security 🫡 We'll be reaching out to library maintainers in due course.
If you have a Git implementation you'd like us to help you test, please reach out and let me know. We'll open-source all this eventually, after potential security issues that were uncovered are responsibly disclosed and fixed.
Alex Hook retweeted
M4 Pro progress:
🔊 all 6 speakers with Apple's tuning + headphone jack + mics
🔌 USB3 5 Gbps on all 3 USB-C ports
📷 webcam
🎞️ AV1 hardware decode, 4K60 in Firefox
💤 lid suspend
🐧 Linux 7.3
All PRs up at github.com/aurora-silicon/li…, should be in Omarchy soon
Got Linux GPU acceleration working on an Apple M4 Pro
Shoutout to @AuroraSilicon and @tiredkebab for some of their work.
Alex Hook retweeted
Introducing Safe Rollup. Ethereum-anchored, operator-controlled.
Safe as in Safe multisig, not safe funds.
Safe Rollup gives institutions the credibility of Ethereum and the control of a database. Live on Sepolia today.
saferollup.fyi
Alex Hook retweeted
Ultimately, precompiles and EVM are both the wrong place to put most cryptography support into Ethereum. The reason is that precompiles and EVM both operate on data that has to be included into the ethereum chain somehow, which realistically means included in a block as calldata. That space is limited - even with PeerDAS and blocks-in-blobs, there's a practical cap of ~8 MB/s before it starts getting uncomfortable.
Remember: it's not a blockchain. It's a cryptographic world computer. Any data/computation that does not need to be in the "main thread" of data/execution should not be put into the main thread.
Instead, the correct solution is... EIP-8288 maximalism.
If you have any heavy computation that's self-contained, compute it and STARK it client-side (this is quickly getting faster and faster, even on phones), and push the STARK through the EIP-8288 recursive aggregation mechanism. The chain sees the fact that the computation was done and what the result is; it never needs to see the actual data and computation.
This way everyone can use whatever cryptography they want, the Ethereum chain can be lean, and we never need to add more precompiles again.
Replying to @lex_node
> we could still ultimately do Lattice stuff for accounts, wallets, etc. through a precompile if it is proved to be AI-secure
The ideal route to support everyone's cryptography is imo through 8288. You make whatever signature you want locally, then STARK it, and then it gets included through the stark aggregator machine. Don't need any calldata onchain. Ethereum can then never add a new precompile again.
Alex Hook retweeted
CLAUDE FOUND THE SEEDS
anthropic.com/research/ecdsa…
I started writing smart contracts in 2018, and one thing always bothered me: why did running my own RPC mean running a full node, or an archive node if I wanted historical state?
My app only cared about my contracts, a few dependencies and some ERC20s. Why did I need to keep up with everything everyone else was doing on Ethereum just to serve those reads?
The annoying part was keeping that smaller set of state up to date. Reading a value at one block was doable, but knowing what changed in the next block meant executing it or asking a node that had. A transaction could reach my contract through several other contracts, so just filtering transactions by their destination wasn’t enough.
I mostly forgot about it. RPC providers got reliable enough for what I needed, and I had other things to build. I still didn’t love the setup, but it stopped being something I spent time thinking about.
Then over the weekend, I was looking through Glamsterdam’s EIPs and realized block-level access lists might make this practical.
BALs include the state changes made during a block, including the new values, and the block commits to that list. So once you have the initial state you care about, you can follow its changes without re-executing every transaction.
So I started vibe coding it. It’s called skim.
You tell it which accounts and storage slots you care about, or let it discover the state your simulations read. It fetches the initial values from Ethereum’s P2P network through SNAP, checks their Merkle proofs, and keeps them updated using BALs. Your eth_calls then run locally. If a call needs something it hasn’t fetched, it gets that from peers too, just with more latency. No upstream RPC provider for those reads.
It can also keep historical versions of the state you’re tracking. That was another thing I wanted: being able to query my app’s past state without keeping everyone else’s history. It exposes a JSON-RPC interface, so existing tools can use it for the methods it supports.
It still receives full payloads and BALs. The state it maintains is selective, not everything it downloads. There’s also a consensus light-client implementation now, but that path isn’t active on Sepolia yet because the required Gloas light-client data isn’t being served by the peers tested so far. For now, the head is still trusted.
It’s still an experiment, and I’m working through correctness bugs and longer-running tests. I’m not presenting it as a production node replacement.
But it’s pretty satisfying to finally build something around a complaint I’ve had since 2018. I wanted a small client that knows the parts of Ethereum my app actually uses, and that’s what I’m trying to make.
github.com/leekt/skim
Alex Hook retweeted
Introducing Magnetar from Microsoft Research, the first zkVM that is: (1) general-purpose (RV64), (2) post-quantum from standard hashes alone (no curves, no lattices, no Poseidon), and (3) built for recursion.
Despite its conservative security, it is the fastest zkVM: 7.2–8.7 MHz on a laptop, 10–39× faster than existing zkVMs across 15 workloads! An optimized version reaches 9.5–12.8 MHz.
Links in the thread below.
Alex Hook retweeted
Muse Spark Open -- weights releasing today -- runs great on new Mac Studios thanks to work with @johnternus and Apple.
Alex Hook retweeted
Big congratulations to the @zksync airbender team for this milestone.
At this point, I consider the battle for speed to be definitively won, and the top priority for zkEVMs should shift fully to security.
To me that means formally verifying
(i) equivalence of the arithmetization to the ethereum spec
(ii) a hard maximum bound on (prover cost) / (amount of gas in block)
(iii) security of the proof system itself
firefly.social/post/x/211001…
Alex Hook retweeted
Today I call upon the blockchain industry to calmly begin planning for "bunker mode". My personal recommendation is to set in motion a controlled mass migration of assets to fresh addresses, i.e. addresses whose pubkeys remain hidden behind a hash.
Holders, starting with large and sophisticated ones, should consider moving the bulk of their funds to addresses that have never signed a transaction. And when they do sign one, they should also move remaining funds to a new address (possibly generated from the same seed phrase).
Don't rush. While I believe there is cause for action a rushed migration would do more harm than good. Don't panic either. Moving assets to protected addresses is a simple, preventative step which does not require new cryptography or new wallets.
IMO it is now reasonable to brace for the possibility that ECDSA breaks before qday, in the worst case in months not years. By "break" I mean fast private key recovery (e.g. in one week) on available hardware (e.g. a large GPU cluster).
Recent days have been humbling for human mathematical intuition. Long-held, unquestioned hypotheses have fallen. This includes the n log(n) bound for integer multiplication and the 3SUM conjecture. In hindsight, May's unexpected disproof of the Erdős unit distance conjecture was our warning shot.
Yesterday's OpenAI drop made it clear that mathematical superintelligence is upon us. They say there are weeks where decades happen. We are about to live through weeks where centuries of mathematical progress happen. Could our magic 64-byte ECDSA signatures be too good to be true? Was it just security through obscurity all this time?
Elliptic curves feel especially vulnerable to superintelligence. Curves carry rich structure, with room for fancy tricks like Schoof, Frobenius, pairings. (By contrast, hashes are designed to minimise algebraic structure.)
Separately, as Ewin Tang can attest, an efficient quantum algorithm sometimes foreshadows an efficient classical one. We should be open to the possibility of a classical counterpart to Shor that breaks elliptic curves and RSA at once.
Also noteworthy is the striking under-representation of cryptographic breakthroughs among the 722 mathematical results OpenAI published. I've witnessed first-hand the US government censoring academic quantum cryptanalysis results. Backroom interventionism is my base case.
I urge large, sophisticated actors to lead by example. Project11's "risq list" (bitcoin-risq-list.projecteleven[.]com) is a great tracker of exposed BTC pubkeys. Binance, Bitbank, Robinhood, Bitfinex, and Tether have an opportunity to harden their cold storage. Next month I'll address institutions in London in a live Q&A (forum.ethereuminstitutional[.]org/london-2026).
Again, please do not rush. Wallets holding under 50 BTC enjoy partial cover from "Satoshi's shield", i.e. his 20K exposed addresses that hold 50 BTC each. Load-bearing signers like oracles and L2 security councils should consider rotating ECDSA pubkeys with every signed message and/or multi-signing with a hash-based schemes like SPHINCS.
Exiting bunker mode safely will require post-AI cryptography. My inclination is to go all-in on hash-based cryptography and avoid structured mathematical assumptions entirely, whether from curves, lattices, or isogenies. A single battle-tested hash (e.g. from the SHA or BLAKE families) yields plausible post-AI security.
The Ethereum roadmap on strawmap[.]org fully embraces hash-based cryptography with end-to-end formal verification as a response to the quantum threat. Those timelines must now be revisited and accelerated in light of mathematical superintelligence. I'll be pushing for maximum defensive acceleration.
Alex Hook retweeted
The cryptographic world computer:
vitalik.eth.limo/general/202…
My attempt to express in somewhat concise terms the true meaning of basically everything planned to happen to Ethereum starting from the fork after Hegota. It's really not just a blockchain anymore. It's a hybrid architecture that combines together blockchains and modern cryptography, to enable much more powerful properties.
FOCIL, EIP-8288, Lean consensus, state management, formal verification, advanced mempool improvements (including privacy), and the longer-term specter of obfuscation all mentioned.




























