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