DSS 2026 — Why is AI missing these bugs? Robert Reith Source video: https://www.youtube.com/watch?v=5J8c-q3pOv4 Automatic captions — not human-reviewed. Complete spoken-audio coverage is unverified. Source language tag: en (English). Source export SHA256: afeca7694a194bfeb89cf3eaa1616ce04b8d1586ac664bcbb826585cdec59e59 [0:02] All right. Hi. Uh I'm Roberts, also [0:05] known as Rob B. [0:07] Um I'm from Hack Hack and Accretion. So [0:10] we do [0:11] AI audits with Hack Hack and Solana, [0:15] human [0:16] traditional audits basically with [0:18] Accretion. And I wanted to share [0:21] our learnings about AI audits over the [0:24] past year, specifically [0:27] about bugs that we've been finding when [0:30] the human team does an audit that like [0:33] an AI run [0:35] missed either like in the same audit or [0:36] like in the benchmark. [0:39] And yeah, this should help us improve [0:42] our auditing [0:44] agents. [0:45] So first of all, [0:48] if we look at the trajectory of AI, how [0:51] it's been improving over the past year, [0:54] it's very clear it's just going up and [0:56] to the right. [0:57] It's just getting better and better. [0:59] And [1:00] the message is clear. I don't think it's [1:02] going to stop. It's going to just keep [1:04] getting better. And if you think you're [1:05] still smarter than AI, [1:08] at some point it will overtake you. So [1:10] basically we should generally think [1:13] about [1:15] a paradigm where the models are smart, [1:19] smart enough to find all bugs or like to [1:21] will be smarter than us. And if we think [1:23] we we're smart enough to find bugs, then [1:25] they will probably be able to find these [1:26] bugs as well. [1:30] However, this graph obviously is not [1:32] about bug finding, but it's like just [1:34] generally, I don't know, [1:37] some benchmark that they that artificial [1:40] analysis came up with. So from our own [1:42] audits, [1:44] we've [1:46] run Solana audits for like two years and [1:49] [snorts] also even more than two years [1:51] outside of Accretion. [1:52] And in that time, [1:55] AI has been getting better and better. [1:57] And um [2:00] during [2:01] current audits and when we benchmark [2:03] older audits against our current AI [2:05] setup, [2:06] we see that AI consistently finds like [2:08] 80 to 90% and sometimes even better, in [2:11] some cases even 100% of the higher [2:14] critical findings that we find with the [2:16] humans. [2:17] Um so [2:20] the question here is obviously, okay, [2:21] why is it not 100% and what's what is [2:23] this 10 to 20% of bugs [2:25] that creates this gap? [2:28] And this is basically what this talk is [2:29] about. [2:30] Um [2:33] let's see. So the [2:35] auditing process we use at the moment is [2:39] generally a loop. So we start with a um [2:41] a human audit where we audit the [2:44] codebase, the AI audits the codebase. We [2:46] have a a list of findings and the AI has [2:48] a list of findings. We can compare [2:50] um and then figure out, okay, these [2:52] findings were found by both of us. These [2:54] findings were only found by AI maybe. [2:56] These findings were found only by [2:58] humans. [2:59] Um we analyze that um [3:02] that result. We figure out, okay, what [3:05] happened here and then basically we just [3:07] try to improve the AI auditor. Also [3:09] maybe we try to improve our human [3:11] approach to auditing um and then we just [3:13] repeat. So that's basically the the the [3:15] cycle we've been running for the past [3:17] year or so. [3:18] Um and what has come to our um attention [3:23] is usually the failure points where AI [3:26] doesn't find bugs is mostly about [3:27] context or consequences or like [3:30] impact. [3:32] So first small detour to that I also [3:36] wanted to mention um AI definitely also [3:38] finds bugs that humans missed. And for [3:40] me generally the the shape is something [3:42] like this. Um [3:45] if you look at this code, I don't know [3:46] if you can see everything. [3:48] Um [3:50] it's a lot of words and those words look [3:51] very similar and it's for a human it [3:54] takes a long time to realize what could [3:55] would be wrong here. Um the mistake here [3:58] is that in the last line we have [3:59] liquidita a provider uh fee BPS. [4:04] However, that should be liquidity [4:06] protocol fee VPS. [4:09] You could say, okay, I will find this [4:10] during audit as a human, but it's super [4:12] easy to to miss something like this as a [4:14] human. While for an AI, this stands out [4:16] like a sore thumb because the tokens are [4:19] just [4:20] different than what it expected. [4:23] So yeah, I mean this is the typical [4:25] shape for what an AI would find that a [4:26] human doesn't. [4:29] And now back to what a human finds that [4:32] an AI doesn't. [4:34] When we first started doing AI audits, [4:37] the simplest shape of these bugs that [4:39] humans found that AI didn't find was [4:42] just missing dependencies. So you would [4:46] give [4:47] your codebase to an AI auditor and the [4:50] AI auditor would [4:53] try to find bugs in there, but it didn't [4:55] have the context of maybe the programs [4:57] that you would be calling from your [4:59] program. [5:00] So obviously to close that gap, the [5:02] first thing that you do is you add the [5:04] dependencies that your program is [5:06] calling to the context. [5:10] So now you have maybe instead of one [5:12] program in the context, you have three [5:13] programs in the context. [5:15] Now if you think about it, oh, this is [5:16] potentially recursive. So what if the [5:18] bug that we have is really complex and [5:20] it's somewhere at the intersection of [5:22] our program calling another program, [5:24] calling a third program. So if you want [5:25] to have all that in our context, now we [5:28] have like a context explosion. So [5:31] now we would would have in this case [5:33] what seven programs. [5:36] Obviously this would go potentially even [5:38] further. So [5:40] this is basically the first main gap, [5:42] just dependencies. [5:44] What we currently do is we just provide [5:45] one level and that [5:47] works quite well, but sometimes you want [5:49] even more. [5:51] A concrete example here is we had an [5:54] audit for Meta DAO [5:57] where an admin instruction would call [6:00] the Meta DAO program here is called [6:01] future key. That's what the program is [6:02] called. And the future key program was [6:04] called the squads program on Solana. [6:07] Everything worked fine. [6:08] Uh it works in the tests. The AI is [6:10] like, okay, that's fine. However, um we [6:13] realized later on [6:15] that [6:17] if the admin is actually not a regular [6:18] wallet, but it's squads program itself, [6:21] so a multi-sig wallet, [6:23] um and the multi-sig admin [6:25] calls the future key program, and then [6:27] the future key program tries to called [6:29] called squads again, this is going to [6:30] fail on Solana because we have like a [6:32] ABA type of reentrancy, which is not [6:35] allowed on Solana. [6:37] Uh so AI was missing this in basically [6:41] all our test runs simply because AI [6:43] didn't consider [6:45] that the admin could be squads itself [6:50] because the definition of this audit was [6:52] simply not explaining properly in the [6:54] context that [6:55] this admin could also be squads. [6:59] Um so another version of this [7:03] is [7:04] um [7:05] we had a AI audit bridge [7:08] and it came up with [7:10] one type of issue related to token 22 on [7:13] Solana. So what happened is [7:15] um whenever you transfer funds to the [7:18] bridge and there's a transfer fee [7:20] attached to the token, let's say a 10% [7:24] yeah, a 10% transfer fee, [7:26] the bridge only receives 90 tokens [7:28] instead of 100 that you sent, and then [7:30] the bug was that the the bridge would [7:32] mint 100 tokens on the other chain. [7:35] So um [7:38] we saw, okay, that's that's an [7:39] interesting bug, but I went and looked [7:41] manually at that issue and realized, [7:43] okay, that's actually not located just [7:46] to the transfer fees, but it's [7:47] completely ignoring um all this nasty [7:50] stuff you can do with token 22 [7:52] um and specifically [7:54] with token 22 [7:56] Is that the next slide? Yeah. [7:58] What you can do is you can create a [8:00] closable and a permanent delegatement. [8:03] So what we came up with basically on the [8:05] same bridge, [8:07] um you could create a new mint [8:10] call that mint ABCD with pump at the end [8:13] because that's going to be what we use [8:15] later. We make it closable and permanent [8:17] delegate. [8:18] We mint a billion tokens. [8:20] [snorts] We bridge those tokens from [8:22] Solana to Ethereum for example. Now we [8:24] have a billion wrapped tokens on [8:25] Ethereum [8:27] and a billion tokens held by the bridge [8:30] on Solana. Now because [8:33] we have permanent delegate enabled on [8:34] that mint we can burn all those tokens [8:38] without owning them because we're like [8:40] the super admin on of that mint [8:42] and the supply becomes zero of that that [8:44] burn but the wrapped tokens still exist [8:46] on Ethereum. [8:48] Um [8:49] and what we can also do now we could [8:51] close the mint completely [8:54] and now that mint is basically as if it [8:56] had never existed and what we could do [8:58] is we could take that ABCD pump mint go [9:01] to Pump Fun and create a new Pump Fun [9:03] token under the same mint account [9:06] and Pump Fun would just accept it [9:09] because it's a fresh mint and you can [9:11] you know do your Pump Fun launch or [9:12] whatever [9:13] um [9:14] and the problem now is that anyone who [9:16] buys the token on Pump Fun and then [9:18] later tries to bridge those tokens with [9:20] that same bridge to another chain [9:23] we can just take our previously bridged [9:25] tokens and unbridge them back to Solana [9:27] and basically steal all the tokens that [9:29] anyone tries to bridge. [9:32] Um [9:33] so the problem here is [9:35] if you look at the bridge by itself [9:38] AI will not realize that you can do this [9:41] ecosystem type of attack. If you look at [9:43] Pump Fun by itself it will also not [9:45] realize that you know you could do this [9:47] ecosystem type of attack but if you give [9:50] it the context of the bridge and Pump [9:52] Fun together then AI could figure that [9:55] out [9:57] but the problem is [9:59] it's not like they're directly related. [10:00] So [10:02] the the the bridge will not mention Pump [10:04] Fun directly in in its code anywhere and [10:06] Pump Fun will also not mention that [10:07] bridge directly. So if you want to [10:09] prepare that audit automatically, you [10:11] can't be like, okay, look for any [10:13] protocol it mentions anywhere and then [10:14] include that in the in the context. No, [10:16] you have to like kind of realize, okay, [10:18] this is a whole ecosystem [10:20] and we kind of have to give um the [10:22] context [10:24] more um stuff about the whole ecosystem, [10:27] not just about this specific program. [10:31] Um so [clears throat] this was like a [10:32] also a relaunch type of attack and [10:34] here's another relaunch type of attack. [10:36] Uh we had a light protocol audit where [10:39] they were trans transitioning from [10:41] Anchor to Pinocchio [10:43] and we were auditing this new Pinocchio [10:45] version. [10:46] Um and if you feed that only that [10:48] Pinocchio version to uh the AI to [10:50] review, [10:52] it [10:53] finds some bugs, but it didn't find this [10:54] bug [10:55] specifically because it involved a state [10:58] transition between the old version and [11:00] the new version. [11:01] So basically what you could do because [11:03] the program already exists on chain in [11:05] the old version, you could create an [11:07] account on the old version of the [11:08] contract [11:10] using a Anchor specific feature [11:13] um and then upgrade the contract and now [11:15] you could use that account that you [11:17] created in the past in an unrelated or [11:20] like in the old version of that program [11:22] to [11:23] um [11:24] yeah, to steal funds from the new [11:26] program. So if you only look at the new [11:28] version of the program, it doesn't even [11:30] know about this existing history. [11:32] Um so it doesn't even know you could do [11:34] that. [11:35] Um more specific, you could create an [11:38] account, have a zero like in the middle [11:40] and in reinitialization it would think [11:42] that zero means that the account is not [11:44] initialized [11:45] and uh you could also have amount [11:47] somewhere else so you could basically [11:48] you could basically steal a lot of money [11:50] like all the funds. [11:52] Um [11:53] but yeah, the main part of it is [11:56] if you're [11:58] just giving it the current state, it [12:00] doesn't have enough context to consider. [12:02] Uh [12:03] like if it's an update audit, there's [12:05] also a past that exists on chain that we [12:06] might want to have in the context. [12:08] So I mean all that stuff was basically [12:12] uh we just need to the AI more context [12:14] and more more what we're trying to do [12:17] more like more dependencies we give it [12:19] all the consumers all the inherited [12:21] states so it just has everything that we [12:23] could imagine. Obviously we run into a [12:25] bit of a problem there because context [12:26] is limited we can't just give it [12:28] everything. [12:29] So yeah this is basically one of the [12:31] main problems here. [12:34] One further thing is that [12:37] Solana specifically is [12:40] developing quite quickly so [12:44] the knowledge cutoff for a model might [12:46] be six months ago but in those six [12:48] months Solana might have introduced like [12:49] three new features [12:51] and even though the model might be able [12:53] to research those things it's completely [12:56] biased during the audit to not consider [12:58] these things. [13:00] So a human auditor here has a bit of an [13:01] advantage if they're following recent [13:04] changes to the chain so for example when [13:06] Solana introduced reducing slot times [13:08] from 400 milliseconds to 200 [13:10] milliseconds [13:11] in human audits we were always reporting [13:13] hey if you're measuring time with slots [13:16] then this time is halving basically but [13:19] the AI basically didn't really report [13:20] these things yet because it didn't [13:22] consider that this change just happened [13:24] last week. [13:27] Yeah so another version which is not [13:29] really context but just [13:31] AI maybe being a bit dumb [13:34] is that sometimes it tends to find bugs [13:37] but not reported at a proper severity [13:41] and because of that it might even make [13:43] that bug invalid or we might not even [13:45] consider it. So just one example we had [13:48] like one audit agent [13:51] finds a valid critical bug but it taught [13:53] it informational because [13:56] it taught you need 18.4 billion [13:59] USDC to exploit it but actually you [14:00] needed only 18 18,000 USDC to exploit it [14:04] because it didn't really consider the [14:06] decimals correctly. [14:09] So because of this [14:11] real bugs can sometimes surface [14:14] but they might surface like as a [14:16] incorrect severity or like incorrectly [14:18] incorrectly [14:23] yeah ranked. So whenever you continue [14:26] doing that audit maybe you will not [14:28] realize that there is a real bug and you [14:29] might skip it. [14:32] So basically to conclude here [14:35] all these issues we can theoretically [14:38] solve quite easily by giving more [14:40] context to the models. However, as I [14:43] said context is limited and we can't [14:45] just give give give them everything [14:48] because if you give them too much [14:49] context they get also overwhelmed. So at [14:52] the moment the way we see it is [14:56] it's a quite difficult task to kind of [14:58] weigh how much context to give to the [15:00] models, which context to give to the [15:02] models and also figure out which context [15:05] to give to the models. [15:07] For example, if you if you look into a [15:09] protocol [15:11] and you try to figure out what might be [15:13] a weird part part of context to give to [15:14] the model, you might already be auditing [15:16] the code to some degree. [15:19] Yeah, that's kind of the that's kind of [15:21] it. [15:22] So [15:24] yeah, you can find me here [15:26] hack hack and a Christian and [15:29] thanks for listening.