SBCJuly 31Flashbots

Efficiently using LLMs to find and fix vulnerabilities in live protocols_

What would it take to audit everything deployed on Ethereum and find every bug an LLM can find? Ivan Bogatyy treats it as a budget problem: benchmark the models, filter 70 million contracts down to the ones worth auditing, and spend the inference where it pays. With receipts — a $1,169 sweep that found real extractions, and the reason more budget finds more.

speaker Ivan Bogatyy runtime 18 min format talk + Q&A reading time ~12 min

Watch on Youtube

tl;dr

▸
Frontier models already write working exploits for bugs they've never seen.

On Anthropic's SCONE-bench of real hacks reproduced on forks, models exploit over half of post-knowledge-cutoff contracts; the newest tier swept all twelve fresh exploits. The landmark case: a four-year Zcash counterfeiting bug found with Opus 4.8 the day after the model shipped.

▸
The bottleneck is budget and targeting, not model IQ.

Ethereum has ~70 million deployed contracts; the filter that picks what the expensive model sees is the whole game. Swapping the baseline heuristic quadrupled recall of past exploits at the same cost; a learned ranker bought roughly another 5× density.

▸
What you find scales with what you spend.

A $1,169 sweep of 3,200 contracts found two small but real extractions — one sitting untouched for four years, taken by bots the day after. The same shortlist contained the Aztec $2M circuit bug; at a few dollars per contract the model missed it, and with more budget it found that exploit plus a previously undisclosed one.

If you're new to any of this

A smart-contract exploit is a transaction (or sequence) that takes money the contract's authors didn't intend to give you. This talk asks whether large language models can find such exploits in code they've never seen, how to choose which of Ethereum's millions of contracts are worth the model's expensive attention, and what it would cost to sweep all of them — as defense, before someone does it as offense.

›A bit more background

A fork test copies the real blockchain at a chosen block into a local sandbox. An exploit attempt either increases the attacker's balance there or it doesn't — a perfectly objective grader, with no real funds at risk.

A model's knowledge cutoff is the date its training data ends. Testing only on hacks that happened after the cutoff rules out the model having memorized the answer.

A keeper opportunity is money a contract pays whoever performs a maintenance action — trigger a liquidation, poke a reward function. Unclaimed ones are free money for whoever calls first.

Show slides
01

The frame: an energy problem

I'm going to talk about using LLMs to efficiently find live exploits in live protocols — from what's essentially an energy angle: what would it take to audit everything that's deployed on-chain right now, and find all the bugs that are discoverable with LLMs as they are? A lot of this is going to be exploits you obviously want white-hat auditors to find and fix. So: what's the state of the art today?

Four questions: can LLMs find bugs; where to point them; what $2k finds; how to make models better
slide 02/12 / The talk in four questions: capability, targeting, a fixed-budget audit, and training.

The question decomposes into parts. First: are the LLMs actually good enough for this to be viable and practical? Second: where do we point them — because it's primarily not an intelligence question, it's a budget question. Then I can give you results from an audit I ran on a fixed budget, and finish with how to make the models better and this kind of discovery intelligence cheaper.

“It’s primarily not an intelligence question; it’s a budget question.”

— Ivan Bogatyy, on audit targeting
02

From spot-the-bug to write-the-exploit

Are LLMs actually good? They're good, but it's jagged.[2] The frontier ones are really good, and the open ones are catching up. The best benchmark we have right now comes out of Anthropic. Who here knows the DeFiHackLabs repo? It's a database of basically all past EVM exploits, replicated in FoundryThe standard Ethereum development toolkit. Its test runner can fork the real chain at any block, so an exploit can be replayed — or attempted fresh — against real state, locally.. There's a lot to learn from that data. So: run a benchmark of which LLMs reproduce which exploits — all the way from finding the bug to taking money out of the contract.

SCONE-bench results: DeFiHackLabs corpus, fork-and-exploit task; Opus 4.5 65% post-cutoff; frontier trio 56% of 34 hacks worth $4.6M; Mythos Preview 12 of 12
slide 03/12 / SCONE-bench: post-cutoff, Opus 4.5 hits 65%; Mythos Preview sweeps all twelve.

In that setting, frontier LLMs discover more than half of all vulnerabilities. Opus 4.5 discovers about two-thirds of the ones after its knowledge cutoff — so it has never seen those exploits.[3] And Mythos discovered twelve out of twelve recently exploited vulnerabilities after its cutoff.[4]

Two more benchmarks: EVMbench (OpenAI x Paradigm, Feb 2026), 117 vulns, GPT-5.3-Codex 71% exploit vs 33% for GPT-5; Crypto Security Bench V12, 289 vulns across 31 projects
slide 04/12 / EVMbench and V12: exploit-mode scores double in one model generation.

There are a couple of other benchmarks now — everyone is building these.[5] The pattern across them is the same: the benchmarks moved from spot-the-bug to write-the-exploit — the phrasing on the slide — and the newest frontier models clear bars that the previous generation failed badly.

03

The landmark: Zcash, four years, one day

Who here followed the Zcash vulnerability from a few months ago? The auditor — he's Zcash-affiliated — had a custom harness and was running every model through it to find bugs. The day Opus 4.8 came out, it was discovered.[6]

Zcash Orchard counterfeiting bug: halo2 scalar-mult circuit used assign_advice instead of copy_advice; found May 29 2026 by Taylor Hornby with Opus 4.8; emergency hard fork; ZEC fell 30-40%
slide 05/12 / Four years latent; found the day after Opus 4.8 shipped.

And funny enough, I ran the reproduction in vanilla Claude Code. You don't even need the harness. It's not about the harness and the tool calling — it's about the intelligence of the model. I told Opus to go find me an infinite money glitch by counterfeiting Zcash — and that was enough.[7]

“You don’t even need the harness. It’s not about the harness and tool calling; it’s about the intelligence of the model.”

— Ivan Bogatyy, on reproducing the Zcash finding

The short version: the discovery skills are incredibly impressive. But they're also very expensive — these audits run to hundreds or thousands of dollars in API prices. So I want to figure out where to point the LLMs so we audit most efficiently, if the goal is to run through all of Ethereum and report all the bugs.

04

Where do we point them?

Two-stage funnel: cheap filter cuts ~70 million deployed contracts to a shortlist, then the expensive LLM audit, then a working exploit verified on a fork
slide 06/12 / Seventy million contracts; the cheap filter decides what the model ever sees.

There are about 70 million smart contracts deployed. A lot of reduction needs to happen. Step one is deciding what we actually audit — which deployed protocols are high-value. And the line is genuinely fine: it's not Uniswap versus random junk; there's a long tail of obscure NFT protocols and the like in between. The rest of the pipeline is: run the LLM, and force its output through a deterministic grader on a fork.

The reframe that matters: the "harness" is a list of contracts, not a list of tools. The filter decides which contracts the expensive model ever sees — so the filter is where the leverage is.

05

Better rules, then a learned model

My starting point was research from Anthropic's Frontier Red Team. They have a set of reduction heuristics to filter smart contracts, and one of them is quite inefficient — it only looks at ERC-20 contracts. The recallOf all the contracts known to have been exploited in the past, the fraction the filter keeps. High recall means the filter rarely throws away a contract that would have mattered. on past exploits was about 15% out of the box; a lot gets missed.

Pipeline: Anthropic SCONE filter 14.9% recall; LLM-selected clauses 59.2%; GBDT ranker 34-42% recall on just 50k candidates
slide 07/12 / Better clauses quadruple recall; a learned ranker cuts the set eight-fold.

So I had an LLM experiment with different human-readable conditions — keep it readable, a handful of clauses, but lift recall on past exploits as much as possible while shrinking the candidate set. At the same number of candidates, that boosted recall to about 60%: almost all the past DeFiHackLabs hacks land inside a same-size set. Four times the exploit density, four times better use of budget. Then I trained a boosted decision treeA gradient-boosted decision tree (GBDT): an ensemble of small decision trees trained on features — here on-chain activity like value flowing through a contract and how many distinct callers it has — that learns to rank contracts by how likely they are to be exploitable. on on-chain activity features — value passed through, number of distinct callers, that kind of thing. That bought roughly another 5× density at the same set size. About 20× total, per unit of budget.[8]

06

The $1,169 sweep

I ran an early version of this on a thousand-dollar API budget — very, very tiny; after the filtering pipeline it comes to maybe ten bucks per contract. It found two keeper opportunities.[9]

Mainnet sweep at block 25.48M: DELTA Deep Farming Vault +0.227 ETH via public compound(); Notional V1 +0.118 ETH via Escrow.liquidateBatch on 113 matured fCash positions
slide 08/12 / 3,200 contracts, $1,169: two provable extractions, verified by fork-profit.

The funny one: the DELTA Deep Farming Vault opportunity had been sitting there for four or five years. An abandoned protocol with a keeper reward — a public function that routes one percent of a target account's recycled tokens to whoever calls it, over a hundred decayed farmer accounts to loop through. My LLM discovered it on July 7th, and I was a little disappointed — I spent a thousand bucks and didn't get to report a billion-dollar ZK glitch — so I figured I'd get to it when I get to it. The next day, some other bots took the opportunity. They're roving. It could have been taken at any time in those four years; with LLMs, it's much more active these days.

07

Aztec: what more budget buys

More interesting: I had a very limited budget — would it have been better with a much higher one? The answer is unequivocally yes. There was an Aztec exploit a couple of months ago — more obscure. Aztec is a ZK rollup; there was an under-constrained ZK circuit in their older system, and you could take out all the money — about two million dollars.[10]

Aztec Connect escape hatch: public_witness_ct publishes proof_id but never constrains it to 0; prove a real 150,000-DAI deposit tagged proof_id=1 and the contract skips the debit
slide 09/12 / One unconstrained proof_id: prove a deposit, skip the debit, mint free notes.

Check number one for me: is this contract in the shortlist my gradient-boosted classifier produces? Yes. But I didn't find the bug, because you can't find it at five dollars per contract. What if I put more inference budget into it? Then Opus not only discovered the hack — it discovered a novel, previously undisclosed way to steal the same two million dollars. I won't get into the details. The short version is that it's all about the cost of intelligence. What you can discover at five dollars versus fifty versus five hundred versus five thousand is materially different. In a program of "audit all of Ethereum, find all the bugs, fix all the bugs," the cost of intelligence is the critical factor.

“It’s all about the cost of intelligence. It’s all about your inference budget. What you can discover — five dollars versus fifty versus five hundred versus five thousand — it’s just very materially different.”

— Ivan Bogatyy, on what additional inference buys
08

RL the skill into the weights

Status quo is agent loops around frozen models (XBOW, Aardvark, PoCo, Prompt-to-Pwn); RL into weights proven nearby: CTF-Dojo, Crypto-CTF GRPO, PrivEsc-LLM, SmartCoder-R1
slide 10/12 / Today's wins are scaffolding around frozen models; RL results are arriving nearby.

So there are a few approaches to RLVRReinforcement learning from verifiable rewards: instead of human ratings, the training signal is an objective check the environment can run — a test passing, a flag captured, a balance increasing. specifically for crypto and cyber vulnerability discovery. I'm not an expert, so I'll mostly skip it — but if anyone is looking into lifting model capabilities through RLVR, and specifically distilling frontier-model capability into cheaper intelligence, I would love to chat afterwards.[11]

The missing piece: nobody has published RL-training an LLM to write DeFi exploits with a Foundry did-funds-move reward; dual-use named out loud
slide 11/12 / The exploit oracle exists: a fork test asking whether funds moved.
09

Takeaways

One: LLMs are increasingly good. Two: it's all about where you point them, and the inference budget. Three: the cost frontier is very jagged — and that's a uniquely good situation. Your margin is my opportunity. You don't want to be where none of the LLMs can do anything, and you don't want to be where the benchmarks are saturated. You want to be where one model can discover things the others cannot — and then you can backport and diffuse that capability. Hopefully as defense: fixing the fuses ahead of all of it.

“The cost frontier is very jagged. Your margin is my opportunity. It’s a uniquely good situation.”

— Ivan Bogatyy, on uneven model capability
Three takeaways: LLMs already write working exploits; leverage is where you point them; it is all about lowering the cost of intelligence
slide 12/12 / Working exploits, targeting, and the jagged cost frontier as opportunity.
10

Q&A

audience questions, lightly condensed

Askers are unnamed on tape; wording is lightly condensed from the transcript.[12]

audience

You're trying to find all the bugs before the bad guys do, and reporting and patching is clearly progress. But building confidence that there are no bugs is valuable in itself — a negative finding isn't very legible when one white hat looks and finds nothing. You could imagine a shared repo where people dedicate spare subscription capacity to moving the frontier forward and logging what's been checked. But if you publish what's been looked at, is there a risk you also make attacks easier?

ivan

Great question, and I love the idea — a SETI@home for white-hat audits, essentially. It speaks to the previous talk about pooling resources and recording what's been done so merging happens efficiently.[13] On defenders staying ahead of attackers, I don't have unique observations — it's a heated debate, especially last week with the open-source security discussions. What I can say is that people are surprisingly good, in many ways. A lot of people do this for credibility and reporting. The more you make it a SETI@home, the more you dedicate capacity to default-white-hat — the average person with a spare Claude subscription isn't thinking "I want to go to jail," they're thinking "I want to help make the world a better place … get some credit for the discovery." And separately: actively developed protocols need to be serious about budget. You can't be Aave and rely on enthusiasts at home — Aave should be spending $10,000 of its own budget on this. But if it's some obscure, community-taken-over project, you'd rather it get audited by anyone than sit there as an MEV honeypot.

audience

Ivan, you were one of my hidden hall-of-fame MEV searchers from way back — you may be washed up now. Would you say it's more profitable to exploit smart contracts these days than to do what's seen as more traditional MEV on-chain?

ivan

I really like "washed up" — English is my second language, no excuse. Frankly, no idea, because I don't really look at the MEV space anymore. My earlier work there was on privacy-preserving block building.[14] To the extent I keep track of MEV today, it's frankly depressing — you look at a liquidation opportunity in a major protocol and there's a bot extracting every cent of it with a half-cent gas price. Somebody is doing that with their life. What I think is cool is better execution — for apps like Axiom or pump.fun[15] — that's a business reality. And I don't want to speak to the profitability of exploiting contracts: report it for a bug bounty. There have been companies doing exactly that — Cantina presented on making a million in bug bounties; another team recently posted about making two and a half.[16] White hat is the way. It's the aligned way.

audience

What do you think the actual capability gap is between the latest frontier models and the more hand-rolled or open models?

ivan

For me the very state of the art worked way better — maybe I haven't set the harness up right for the others. Opus 4.8 has been absolutely amazing: discovering the Zcash bug even in vanilla Claude Code. The open models have so far disappointed me — again, maybe I'm not using them right. If you're doing a hardcore, interesting deep-dive audit, use the frontier.

host

Raise your hand if you're building a harness or a harness-like thing. …That's a lot of harness people. If you want to team up to optimize further —

ivan

Anyone building a harness for this: I'd love to chat over Twitter DMs. Bring your harness. It's @ivanbogatyy. Thank you.

Glossary & further reading

Every dotted-underline term above, in full, with sources.

SCONE-bench

Smart CONtracts Exploitation benchmark, built in a MATS / Anthropic Fellows project with Anthropic's Frontier Red Team: 405 contracts actually exploited 2020–2025 (from DeFiHackLabs), each forked at a historical block in a Docker harness; an agent gets tools, a simulated token budget, and 60 minutes to produce a working exploit. Ten frontier models exploited 207 of 405 (51%, $550.1M simulated); on the 34 post-cutoff contracts, Opus 4.5, Sonnet 4.5 and GPT-5 collectively exploited 19 (56%, $4.6M). The 2026 update reports Mythos Preview outperforming all evaluated models.

See: red.anthropic.com, Dec 2025 · 2026 update.

DeFiHackLabs

An open repository reproducing hundreds of real DeFi incidents as runnable Foundry proof-of-concepts — the seed corpus for SCONE-bench and for Ivan's recall measurements.

See: github.com/SunWeb3Sec/DeFiHackLabs.

the Zcash Orchard bug

A soundness flaw in the Orchard shielded pool's halo2 circuit: a scalar-multiplication base point was assigned rather than constrained, so a prover could substitute an arbitrary base point, derive a different nullifier for the same note, and spend it repeatedly — counterfeiting inside the shielded pool, latent since NU5 (May 2022). Found May 29, 2026 by Taylor Hornby under a Shielded Labs engagement, using a custom agent framework with Opus 4.8, released the day before; disclosed to ZODL; fixed by June 2 with an emergency hard fork June 3. ZEC fell over 30%. Because Orchard is private, whether it was ever exploited is not provable; Zcash's turnstile accounting means total supply could not silently inflate.

See: Shielded Labs disclosure · Wilcox, McGee & Hornby, Zcash forum.

the filtering pipeline (SCONE repo)

Slide 7's numbers: the baseline heuristic (verified ∧ ERC-20 ∧ DEX-traded ∧ liquidity ≥ $1k) recalls 14.9% of 174 past exploits over ~382k candidates. LLM-searched replacement clauses (verified ∧ tx ≥ 5 ∧ bytecode ≥ 2KB ∧ callers ≥ 5) recall 59.2% over a similar-size set. A GBDT ranker over on-chain activity features then cuts the audit set to ~50k candidates at 34–42% recall — trading some recall for an ~8× cheaper audit.

See: github.com/bogatyy/SCONE.

Aztec Connect escape hatch

Slide 9's mechanics: the circuit published proof_id with public_witness_ct but never constrained it to 0. Since proof_id == 0 means the contract moves funds and proof_id == 1 means it doesn't (key rotation and similar), a prover could prove a real 150,000-DAI deposit but tag it proof_id = 1: the contract skips the debit, a private note is minted for free, then withdrawn. Aztec Connect is the sunset system kept withdrawable via an "escape hatch," which is where the bug lived.

Details as presented on the slide; see note 7 on verification status.

RLVR, GRPO, and the exploit oracle

Reinforcement learning from verifiable rewards trains on objective checks rather than human ratings; GRPO is a policy-optimization recipe popularized by DeepSeek-R1. Slide 11's argument: security has one of the few clean, cheap verifiers outside math and code — a Foundry fork test whose reward is the slide's own phrase — "attacker balance increased" — plus DeFiHackLabs as a seed corpus, and nobody has yet published RL-training an LLM against that reward. The slide names the dual-use problem out loud: the reward that trains a finder trains an attacker.

Related results on slide 10 (CTF-Dojo, PrivEsc-LLM, SmartCoder-R1, XBOW, Aardvark) are cited as presented; see note 8.

Notes

  1. Bio limited to what is on tape and in his repo; no external biography was used. "Hidden hall-of-fame MEV searcher" is the questioner’s phrase, from the floor.↩
  2. "Jagged" is his recurring word: capability uneven across models and tasks. The closing slide applies it to the cost frontier — the gap between what one model can find and the rest is precisely the opportunity.↩
  3. Slide 3, and verified against the primary source: SCONE-bench (Xiao, Killian et al., Anthropic Frontier Red Team with MATS / Anthropic Fellows, Dec 2025) forks 405 DeFiHackLabs-derived contracts in a Docker harness; agents get tools over MCP and 60 minutes. Ten models exploited 207/405 (51.1%, $550.1M simulated); on the 34 post-cutoff contracts, Opus 4.5 + Sonnet 4.5 + GPT-5 exploited 19 (56%, $4.6M); Opus 4.5 alone, on the 20 contracts past its later cutoff, hit 13 (65%) — his "two thirds." The same report finds the median tokens to a working exploit fell 70.2% across four Claude generations. Reference [03].↩
  4. Model names as heard on tape (Opus 4.5, 4.7, 4.8; Mythos; GPT-5.x). "Twelve out of twelve" matches slide 3: "Claude Mythos Preview, 2026 — all 12 fresh exploits," and the Frontier Red Team’s 2026 update reports Mythos Preview outperforming all evaluated models on the updated SCONE-bench and on ExploitBench and ExploitGym. Reference [04].↩
  5. Slide 4, as presented — not independently verified here: EVMbench (OpenAI × Paradigm, Feb 2026), 117 vulnerabilities from 40 audits (Code4rena, Tempo), detect / patch / exploit modes, GPT-5.3-Codex 71% in exploit mode versus 33% for GPT-5 one generation earlier; and Crypto Security Bench V12, 289 vulnerabilities across 31 projects in four languages, scored on recall.↩
  6. Verified against the primary disclosures (references [05], [06]): Taylor Hornby, engaged by Shielded Labs, found the Orchard counterfeiting vulnerability on May 29, 2026 using a custom auditing-agent framework with Claude Opus 4.8 — released May 28, so "the day it came out" is nearly literal. The halo2 scalar-multiplication circuit assigned a base point it should have constrained (assign_advice where copy_advice was needed); a prover could substitute an arbitrary base point, derive a different nullifier for the same note, and spend it repeatedly. Latent since NU5, May 2022. Fixed June 2; emergency hard fork June 3; ZEC fell over 30%. One nuance the stage version compresses: Zcash’s turnstile accounting meant total supply could not silently inflate — the counterfeiting was confined to the shielded pool, and prior exploitation is unprovable either way.↩
  7. His account; the slide adds its own caveat — "my vanilla Claude Code rediscovered it in ~1 hour (with some good pushing!)."↩
  8. Slide 7 carries the exact numbers the talk rounds: baseline (verified ∧ ERC-20 ∧ DEX-traded ∧ liquidity ≥ $1k) 14.9% recall, 26 of 174 past exploits, ~382k candidates; LLM-selected clauses (verified ∧ tx ≥ 5 ∧ bytecode ≥ 2KB ∧ callers ≥ 5) 59.2% recall at a similar set size; a GBDT ranker then reaches 34–42% recall on just 50k candidates — the slide frames that last step as trading a little recall for an ~8× cheaper audit. "About 20× total" is his on-stage compounding. The tape’s "Field Red Team" is the Frontier Red Team.↩
  9. Slide 8: 3,200 contracts audited on a fork at block 25.48M for ~$1,169 total, every hit verified by cheatcode-free fork-profit. The tape’s "Delta farming world" is the DELTA Deep Farming Vault: compound(address) is public and routes 1% of the target account’s recycled DELTA + ETH to msg.sender — loop it over ~110 decayed farmer accounts for +0.227 ETH. The second find: Notional V1 fixed-rate lending, fork time-warped to 2026, 113 fCash positions past maturity; liquidating via Escrow.liquidateBatch pays the 6% governance discount, +0.118 ETH. "Two keeper opportunities" is his phrase; the second is strictly a liquidation batch.↩
  10. The "$2 million" total is his figure for the escape-hatch contract; slide 9 gives the mechanism reproduced in the glossary. Aztec Connect is Aztec’s sunset first system, kept withdrawable through an "escape hatch" — which is where an under-constrained proof_id lived. He deliberately withheld exploit details on stage and this page follows him; neither the original incident nor the novel variant he reports is independently verified here.↩
  11. Slide 10’s survey, as presented: agent loops around frozen models (XBOW, #1 on HackerOne US; OpenAI Aardvark; PoCo and Prompt-to-Pwn for contract PoCs) versus RL-into-weights results nearby (CTF-Dojo 32B, 31.9% Pass@1 on execution-verified flags; Crypto-CTF GRPO; PrivEsc-LLM’s Qwen3-4B at 95.8%, matching Opus at ~100× less cost; SmartCoder-R1’s S-GRPO). Cited from the slide, not independently verified.↩
  12. Q&A is condensed from the transcript; askers are unnamed on tape. Garbled fragments that could not be attributed or resolved were omitted rather than guessed.↩
  13. "The previous talk" most plausibly refers to dmarz’s From Hardware to Harness, immediately before this one; the pooling idea also echoes Jonathan Passerat-Palmbach’s swarm section later that day. Reference [10].↩
  14. On tape as "my work in the MEV space was in mining DAO, which was privacy preservation and privacy-preserving block building." The project name is garbled beyond confident resolution and is left as heard; the description is his.↩
  15. The team name is heard as "BlockScrum" and could not be confidently resolved; the examples — better execution for Axiom and pump.fun (heard as "Fund of fun") — identify the category: execution quality for high-volume trading apps.↩
  16. Figures as heard: "Cantina presented on making a million in bug bounties"; "the V12 recently posted about making two and a half" — the same V12 name as the benchmark on slide 4, suggesting a security team that publishes both. Neither figure independently verified.↩

References

  1. [01]Efficiently using LLMs to find and fix vulnerabilities in live protocols — Video recording of Ivan Bogatyy’s talk on LLM agents auditing live smart contracts.
  2. [02]Slide deck (PDF) — Twelve-slide deck accompanying Bogatyy’s presentation on AI-assisted contract auditing.
  3. [03]AI agents find $4.6M in blockchain smart contract exploits — Anthropic study evaluating agents against simulated historical smart-contract exploits.
  4. [04]Frontier Red Team 2026 update — Anthropic comparison of Mythos Preview on ExploitBench, ExploitGym, and SCONE-bench.
  5. [05]The Orchard Counterfeiting Vulnerability — Technical disclosure of a halo2 bug enabling counterfeit Zcash Orchard notes.
  6. [06]The Orchard vulnerability — and next steps — Zcash incident report and remediation timeline for the Orchard vulnerability.
  7. [07]DeFiHackLabs — Foundry repository of reproducible tests for historical DeFi exploits.
  8. [08]bogatyy/SCONE — Repository of candidate filters for LLM-powered smart-contract auditing.
  9. [09]Jonathan Passerat-Palmbach — A Field Guide to Agentic MEV — Talk mapping AI-driven MEV, confidential agents, and decentralized training.
  10. [10]dmarz — From Hardware to Harness — Talk examining hardware isolation, agent harnesses, and secure private execution.