DSS

DSS 2026 / Day 1 / Pearl Hall

Why is AI missing these bugs?

Robert Reith

15:32 · Recording

Watch on YouTube ↗Open recording viewerOriginal programme entry
Download plain textDownload timestamped JSON

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

Source export SHA256: afeca7694a194bfeb89cf3eaa1616ce04b8d1586ac664bcbb826585cdec59e59