DSS 2026 — AI-FV: Slop or Prop? Explorations in Agentic Formal Verification Jonathan Mevs Source video: https://www.youtube.com/watch?v=QRURiESp5TA Automatic captions — not human-reviewed. Complete spoken-audio coverage is unverified. Source language tag: en (English). Source export SHA256: 6145dc50240426d431cfd4126b2d2574aca2809814c95bf00db010656e35c3e7 [0:00] Um, well, hello everybody. Uh, thanks [0:03] DeFi Security Summit for having me here. [0:05] I'm John. [0:06] I'm a senior engineer with Quantstamp, [0:08] and the topic I'll be talking about [0:09] today is like formal verification and [0:12] how far can AI support such uh and some [0:16] experiments we did uh surrounding a [0:17] couple different tools. [0:21] Click. [0:24] Okay, great. So these are the guiding [0:26] questions that inspired the talk and [0:27] like what we'll be focusing on today. [0:30] And we wanted to see like to what extent [0:32] does AI make existing formal [0:34] verification tools accessible to [0:36] experienced smart contract auditors? [0:39] And to do such, we like ran some [0:40] experiments on three prominent tools, [0:43] like AutoProver by Certora, Control by [0:46] Runtime Verification, and the SMT [0:48] Checker by the Solidity team. [0:50] And then ultimately we wanted to [0:52] conclude where does formal verification [0:54] fit in the audit cycle and like some [0:57] takeaways that we can have as smart [0:58] contract auditors. [1:01] Next please. [1:04] So this was sort of like the starting [1:06] idea, right? Like over the past year um [1:09] with like LLMs and like agents getting [1:12] really really good, [1:13] we've seen like non-technical people be [1:15] able to produce like some legitimate [1:17] technical output. So this is like your [1:20] typical business guy like sitting down [1:22] with Claude and being like, you know, [1:24] build me 100 million ARR SaaS, make no [1:27] mistakes, and actually getting a website [1:30] output. So there's like um [1:33] this non-technical person doesn't really [1:35] need to understand anything about [1:38] websites in order to like actually get a [1:40] website [1:41] um out there and sort of running with [1:44] it. [1:45] So next slide please. [1:47] So then uh we wanted to take that step [1:49] further and see like with us as like [1:52] pretty technical people, bug hunters, [1:54] reading a bunch of Solidity code, um you [1:56] know, breaking apart systems, stuff like [1:58] that, could we make a similar leap to [2:01] the extremely technical realm of formal [2:03] verification? So oftentimes people that [2:06] are like experts in formal verification [2:07] may be studying mathematics at like the [2:10] PhD level or [2:13] having like many years of this like [2:15] targeted study. [2:17] So if [2:19] we spent like years doing smart [2:22] contracts, can AI help us get that leap [2:26] similar to like the BD guy to the [2:27] website, the smart contract auditor to [2:29] the formally verify expert? [2:33] So if Thread Guy can do it, maybe I [2:35] could do it, right? [2:37] Now that's just a meme checkpoint. [2:39] Okay, so a slight primer on formal [2:42] verification. So let's say we have a [2:45] spec like a deposit never decreases [2:47] total shares. So if you were to write a [2:49] unit test for such, you would just like [2:51] do something like deposit 100 and make [2:54] sure that the assets you got back [2:57] was greater than or equal to 100. [2:59] If you were to fuzz that spec, you would [3:01] probably [3:02] you would run it through a fuzzer and [3:04] then it would test a deposit of 100, [3:06] test a deposit of 1,000, test a deposit [3:08] of [3:09] 1,001, so on and so forth, thousands of [3:11] random deposits. But with formal [3:13] verification, you want to mathematically [3:17] prove that for every deposit from any [3:20] state [3:21] the shares will never decrease. [3:25] So now let's take a look at to what [3:27] extent did these tools actually make [3:31] formal verification accessible to [3:33] experienced smart contract auditors. [3:37] So this sort of sets the stage for how [3:39] we went about this experiment, like just [3:41] sitting down at the computer, hey [3:43] Claude, formally verify this [3:45] believe in yourself, make no mistakes, [3:47] right? [3:49] So in order to do so, we needed an ideal [3:51] codebase. So this was one that was like [3:54] simple for the point of like [3:56] experimentation, so if and when we [3:58] needed to look under the hood, you could [4:00] go read the code. It was like uh had [4:03] manageable line of code so that the [4:04] prover didn't run forever, which was [4:06] actually something that I underestimated [4:08] how long those things take. Um and then [4:11] we This was really important here is we [4:12] needed like a public human formal [4:14] verification report that actually had [4:17] some real bugs in order for us to catch. [4:20] So what we landed on was this Aave vault [4:23] that Certora audited both with formal [4:25] verification and a manual code review in [4:27] 2023. [4:29] It's a simple ERC 4626 vault where [4:32] deposits are in yield. The owner can [4:34] take a fee and it's just shy of 700 [4:36] lines of code. [4:38] And there were 11 known bugs uh to see [4:40] if the formal verification tools [4:42] actually caught it. [4:45] So now how do we pick the tools? Well [4:47] the ideal tool um was tailored [4:49] specifically to Solidity smart [4:51] contracts. It was open source so we can [4:53] use it and download it or um tinker with [4:56] it. [4:58] It was already like adopted by the [4:59] community in some extent um and had [5:01] already undergone several client [5:03] engagements um and it was thoroughly [5:06] documented so that we could basically [5:08] build agents uh to use the tools without [5:12] uh having the agent to figure too much [5:14] out. [5:15] So we ran each of these tools on their [5:17] own EC2 instances so they had tons of [5:19] resources and didn't need to share [5:21] anything um and they could sort of just [5:24] run the provers on and on and on. [5:27] So the first tool that we uh took a look [5:30] at was Certora's auto prover which came [5:32] out this past summer in July. [5:34] Uh this is the only tool that we looked [5:36] at that was agentic out of the box. So [5:39] Certora has had their prover out for [5:41] some time but in July they actually [5:44] released this agentic solution. [5:46] Um what's unique about this tool is that [5:49] it's written in the Certora verification [5:50] language uh so that's their own language [5:53] where you write the specs. They're [5:55] verified at the bytecode level and they [5:56] support [5:58] uh several different solvers. [6:00] And the technique that they approached [6:02] to formal verification is verification [6:04] condition generation where per rule you [6:07] build one formula and ask the solver, [6:09] oh, is any input going to break this [6:11] rule? [6:14] So this is an example of like what the [6:16] agent would actually create. Um, this is [6:18] the tool or a spec written in uh Certora [6:22] verification language, [6:23] never decreasing shares. [6:25] Um, so this is what would actually get [6:27] fed to the solver. [6:29] And humans don't usually read this part, [6:31] but it's just good to sort of like [6:33] get a look at what's actually being fed [6:35] into the solver, um which which is this [6:39] assert statement [6:40] is trying to be proven holding true for [6:42] all inputs. [6:52] Could you go next? [6:53] Thank you. Uh, [6:55] the next tool is really interesting. [6:58] It's controlled by runtime verification. [7:00] Uh, what's cool about this is it runs on [7:02] the bytecode in the KVM, which is a [7:05] mathematical definition of the Solidity [7:08] EVM according to the yellow paper. [7:11] So it verifies bytecode. [7:14] Uh, it uses the Z3 solver and what this [7:17] tool focuses on is symbolic execution, [7:20] which is running each test with like [7:23] these symbolic inputs at each branch in [7:26] the test. You traverse each path and [7:29] you're either going to get to an error [7:30] that's going to show that the spec [7:33] doesn't hold or you're going to get to a [7:35] terminating condition and see that the [7:36] spec does indeed hold. [7:39] Uh, I think this might be out again. [7:42] If you could go next. Thank you. [7:44] So this is what um you would get from [7:48] or what the agent created for running [7:50] the control test. [7:51] We see that it's extending this control [7:55] test library and actually running [7:58] the test within the KVM directly. [8:03] Next, please. [8:08] And [8:09] yeah, this an example of what was being [8:11] uh fed to the solver. [8:13] Um and it's not too important, but you [8:16] could see that like there's actually a [8:18] different question being asked to the [8:20] solver versus what uh Certora asked. [8:24] Next, please. [8:27] So this one uh SMT Checker is actually [8:29] just built directly into the Solidity [8:31] compiler. So this tool is actually like [8:33] most native to Solidity and probably [8:36] like easiest for like a Solidity smart [8:38] contract auditor to jump straight into. [8:41] Um so this is provided by the Solidity [8:43] team. It uses uh constrained Horn [8:45] clauses model checking, which is just [8:48] asking um a solver for [8:51] an invariant that holds for like all [8:53] deployments for every call. And then if [8:56] that holds, it rules out the bug. [8:58] Please go next. [9:02] And like I mentioned, this is like most [9:04] native to Solidity because it's in the [9:06] compiler itself. So there's no extra [9:08] libraries. There's no um other languages [9:11] that are used to write the spec. [9:14] You can just extend a vault, [9:17] uh make a call to the contract or the [9:19] function that you want to test and add [9:21] an assert afterward. [9:23] So uh we know that like usually as [9:26] Solidity devs, you aren't too keen to [9:28] having asserts like within uh the [9:31] contracts or the functions themselves. [9:33] You usually tend towards require [9:34] statements, so you would usually just [9:36] extend and put in the assert for the [9:38] condition that you're looking for. Um [9:41] and then run it through the compiler. [9:43] And then yes, it will create uh an [9:46] output that you can ask the solver. [9:49] Next, please. [9:51] So this is just kind of wrapping that [9:53] all up. I'll invite you to take a look [9:56] um [9:57] a diagram like comparing all three of [10:00] the tools that we looked at. So all of [10:02] them are open source, all of them [10:04] generate counterexamples, and all of [10:06] them support the Z3 solver, which is [10:08] like the main solver being used here. [10:11] Um, as I mentioned, Certora's is the [10:13] only one that's agentic out of the box [10:15] and the only one that has a um [10:18] separate language used, the CVL. [10:21] Both Control and SMT Checker are written [10:24] in Solidity, [10:26] and they each have their own uh separate [10:29] technique for verification. [10:31] Next, please. [10:33] Okay, so now for the exciting part, uh [10:36] harness development. [10:37] Could you go next? [10:39] Thank you. [10:40] So the idea when we started to write the [10:43] harnesses to test the formal [10:44] verification tools [10:46] was we assumed like, okay, Certora's [10:48] AutoProver, that's like sort of the [10:50] template, right? Uh that's what an [10:52] agentic solution to formal verification [10:54] would look like right now. [10:56] So we extracted the properties and the [10:59] architecture from Certora AutoProver, [11:01] and then basically in conjunction with [11:03] the documentation on a specific tool, [11:05] either Control or SMT Checker, [11:08] we fed them um into Claude to actually [11:11] write the harness. [11:12] And then [11:15] Hold on, let me not get uh let me not [11:17] lose my train of thought here. So [11:20] like with AutoProver, we wanted to [11:22] basically like take what they were doing [11:24] and see if it could also work with [11:26] Control and SMT Checker, um and then [11:28] like compare the results of such. [11:31] So that wasn't just enough to write the [11:33] harness. Each Control and SMT Checker [11:36] came with their own like example code [11:38] and test cases to work with. [11:40] So Control, I think they had uh like a [11:44] simple counter contract and a WETH9 [11:47] contract uh that we could fine-tune the [11:49] harness on. [11:51] And SMT Checker, I think it was like a [11:53] mutex, like a lock [11:55] uh contract [11:57] and ERC777 that we got to fine-tune on. [12:01] So SMT Checker was actually fairly [12:03] straightforward with fine-tuning, but [12:06] what we found with working with Control, [12:08] if you read the Control documentation [12:10] for like that formal verification tool [12:12] specifically, A lot of it is focused on [12:15] um [12:17] it's written so that there's a formal [12:19] verification human expert like [12:21] frequently in the loop. So a lot of the [12:23] control documentation talks about [12:25] writing a test, okay, it fails, go back [12:28] and like tweak it a little bit, add a [12:30] lemma, so on and so forth. Um so that [12:33] actually didn't do too well with the [12:35] agent, which we'll see in a little bit. [12:37] But after we basically fine tuned it to [12:40] actually solve the example contracts or [12:43] example tests that were provided within [12:45] the documentation for the tool itself, [12:47] it sort of graduated to move on to the [12:49] data set. [12:51] Next please. [12:52] Okay, now the exciting part. So how did [12:54] each of these tools actually perform [12:56] when driven by state of the art models? [12:59] Next please. [13:02] Uh so actually one thing on the models [13:04] before I talk about the metrics, um for [13:07] Sertora's AutoProver, [13:10] there's the ability to uh change what [13:13] models you were running it on, [13:16] but [13:17] we so like out of the box it's running [13:19] on Opus 5 and Sonnet 5. [13:22] And then once I wanted to go tweak the [13:25] models uh a little bit, [13:27] they have like a high like a high power [13:29] model and a low power model. So their [13:31] high power was Opus 5 out of the box and [13:33] their low power was like Sonnet 5. [13:36] When I bumped them up to the newer [13:37] generation like 5.5 and Sonnet 5.5, uh [13:40] for some reason Sonnet 5.5 like didn't [13:43] extract the properties the right way [13:45] that Sonnet 5 did. So then I was like, [13:47] all right, let's not mess with this, [13:49] just test AutoProver out of the out of [13:51] the box. So Control and SMT Checker are [13:54] checked on Opus 5.5, but AutoProver is [13:57] just coming right off the shelf. So [13:59] perhaps if I had more time I could tweak [14:01] and try to figure out what's going on [14:02] with Sonnet 5.5, but for the sake of [14:05] experimentation we just let it run. [14:07] Uh just a small note before we look at [14:09] some of these metrics. So we wanted to [14:11] test like recall. So of those 11 bugs [14:14] that were in the original report, like [14:16] how many did the tool actually catch? [14:18] Precision. So like we know with like AI [14:21] scanning tools, one of the worst things [14:22] you could have as an auditor is like [14:24] noisy results that like end up wasting [14:26] more of your time. So we wanted to see [14:28] like out of everything that the tool [14:30] ended on, how many of them actually hit [14:32] a known uh hit a known bug. [14:36] Soundness is a really interesting one. [14:37] Like can the finding actually happen? So [14:40] we extended all the provers to actually [14:41] ask an agent to write POCs in Foundry [14:44] saying, oh, based on like this Aave [14:46] Vault deployment, is this bug actually [14:49] feasible within like uh the execution of [14:51] the contracts? [14:53] And rule recall was like, okay, out of [14:55] all the rules that the provers [14:57] themselves checked, how many were [14:58] actually also written by a human? And [15:01] then we have some cost and runtime [15:02] metrics we'll look at. [15:04] So yeah, I I talked about this a little [15:07] bit, but it's just basically like uh [15:10] recall [15:11] of the [15:12] bugs caught by the tool, how many were [15:14] actually in the report. [15:15] Next, please. [15:18] So this is a really interesting slide [15:19] here. It sort of highlights like uh the [15:22] medium, low, and informational bugs that [15:24] actually made it to the report and how [15:26] each tool did. So Auto Provers tool off [15:29] the shelf actually did pretty well as [15:31] compared to their human teams that [15:32] reviewed the Aave Vault. [15:34] It caught two of the four um medium bugs [15:37] and um one of the informational bugs and [15:39] scored the highest among the other two [15:41] um [15:43] tools. [15:44] Uh [15:45] SMT Checker got one of the mediums, [15:47] actually one of them that Auto Prover [15:49] didn't. [15:50] Uh and Control [15:52] scored a couple of the info findings, [15:54] which was like good. [15:56] Uh next, please. [15:58] So uh this one was like [16:02] trying to see how noisy things were, [16:04] right? Uh could you go next? [16:09] So this shows like all of the findings [16:11] like after the tools completely ran [16:13] through, this was like Auto Prover gave [16:16] us nine findings, Control gave us five [16:18] findings, and SMT Checker gave us five [16:21] findings. [16:22] Two out of the nine of Autoprover [16:24] actually made it to the final report. [16:26] Two out of the five for Control made it [16:28] to the final report, and only one [16:30] uh of from SMT Checker made it to the [16:32] final report. [16:33] What's really interesting here is [16:35] actually like you could see in [16:36] Autoprover and an SMT Checker like one [16:40] formal verification break or spec break [16:42] actually led to two separate bugs in the [16:44] finding or in the report, which I [16:46] thought was pretty interesting. [16:48] Um and also speaks to the fact that like [16:50] the human is still very involved in this [16:52] because you as the auditor would have to [16:54] see the formal verification expert and [16:56] that uh [16:57] formal verification um output and sort [17:00] of determine okay like what more can I [17:02] break with this? If this spec doesn't [17:04] hold, what contracts are really going to [17:06] go wrong or what problems are really [17:08] going to go wrong in the contracts uh [17:10] once they hit production? [17:12] Um and then this like [17:15] the Autoprover doesn't have this out of [17:17] the box and um [17:20] like it just sort of came to my uh mind [17:22] when I was uh like developing these [17:25] tools kind of like [17:27] just to like Lazy Max, right? Like just [17:30] to be as lazy as possible and see like [17:33] give as much to the uh [17:34] AI as possible. [17:36] So after like the formal verification [17:39] actually found some breaks in the spec, [17:42] it got fed to another agent and like I'd [17:44] mentioned earlier, I had the um agent [17:46] write a POC [17:48] um in Foundry to see like oh can this [17:50] actually happen [17:52] from the forked block like from the [17:54] Aave's test suite? [17:57] Um so surprisingly all the tools were [18:00] actually producing sound bugs. Um so all [18:03] of the things well like they have high [18:06] percentages for like what could actually [18:08] happen in the code. So [18:10] these things weren't like very noisy. It [18:12] was actually very valuable input to like [18:15] guide the uh smart contract audit [18:17] itself. Um we know sometimes that if [18:20] you're like a smart contract and you're [18:23] going back and forth with Claude, [18:25] you can waste hours being convinced that [18:27] there's a bug somewhere where it's not. [18:29] So this was actually pretty cool to see. [18:32] Um, you could go to the next slide. [18:35] And [18:37] the caveat here is that like [18:40] some bugs Well, many bugs are sound in [18:43] the report, but it was actually like you [18:45] wouldn't want to bring it to the client [18:47] because it actually like doesn't mean [18:48] much to the client. [18:50] One very simple example here is like [18:52] abuse of owner privilege. Like when [18:54] you're working with a client, you're [18:55] probably going to assume that they want [18:56] their protocol to do well and um that [18:59] you know they're going to be treating [19:01] owner functions uh with like at least [19:04] some responsibility. I'll let the OpSec [19:05] guys talk more about how you can make [19:08] sure those owner functions are working [19:10] the way they should, but there wouldn't [19:11] be any blatant abuse of owner privilege. [19:13] So that's why some of the bugs were [19:15] sound, but didn't actually count to [19:17] being in the report itself. [19:19] Another thing is like unrealistic [19:21] deployment conditions. This one vault [19:23] that was um [19:25] being reviewed by these tools was an [19:28] upgrade. Um, so you would assume like [19:30] the proxies in place and some of these [19:31] things are already in place. Um, and [19:34] some things were sound [19:36] in the context of what the agent saw, [19:38] but they were actually just handled by [19:39] the dependencies or elsewhere. [19:41] Um, so [19:46] if you could go to the previous slide [19:47] actually. [19:48] Thank you. So like yes, many were sound, [19:51] but not all of them made it to the [19:53] actual report because of some of the [19:55] things we talk about. All right, two [19:56] slides forward. Thank you, sir. [19:59] Okay, so now we wanted to see like out [20:01] of all the rules that the AI produced, [20:04] how many of those [20:06] rules [20:09] actually matched what the human did [20:10] versus like all of the rules that were [20:12] in the human report? Okay, hold on. Let [20:14] me say that one more time. [20:16] So like the AI produced a bunch of [20:18] rules, like way more rules than the [20:19] human did. So of those rules that [20:22] actually matched the human. So of like [20:25] the formal verification tool produced [20:27] 100 rules, 10 of those were also [20:30] produced by the human. [20:32] That divided by all the human rules. [20:35] Okay, I hope that makes sense. Next [20:36] slide. [20:38] So they actually performed fairly fairly [20:40] low here. Um [20:43] I think I have some ideas why. We'll see [20:45] like once we actually check um some more [20:47] results later, but on the left side you [20:50] could see like all of the rules that the [20:52] human wrote or at least groups of rules [20:55] that the human wrote [20:56] um and the rules that the um agents were [21:00] actually able to come up with. [21:02] And for time sake I'm going to go to the [21:05] next slide. [21:07] Um yeah, so this is just sort of you can [21:10] go to the next one. [21:12] Yeah, uh [21:13] this is just a breakdown of runtime, [21:16] token spent, and cost. And I think that [21:19] this uh slide is a big takeaway. [21:23] And it sort of shows why Auto Prover [21:26] performed well in uh several different [21:29] of the tests. Um probably because it's [21:32] spending like almost a magnitude of 10 [21:35] more tokens than the harnesses we were [21:38] able to develop. So that's probably a [21:40] testament to Auto Prover being a more [21:43] mature piece of software. Um and there's [21:45] still being work to be done on the [21:47] harnesses uh themselves. [21:50] So what was unexpected to me as an [21:52] auditor was just how long these provers [21:54] take to run, like [21:57] 58 hours um is a long time. [22:01] And yeah, you've got to [22:05] hope your CEO is funding your tokens. [22:09] Next slide. [22:10] Okay, so is the slop or prop? Is like [22:15] can we actually have AI power and [22:18] experienced smart contract auditors [22:19] access to formal verification tools? [22:22] So if we look at the numbers, it's [22:24] tending towards slop. [22:26] But honestly, [22:28] as an auditor that worked on it, I am [22:30] tending towards definitely a value prop [22:32] here. [22:33] Um, at the very least, [22:36] as an auditor, you have like access to [22:40] sort of start to learn this new [22:42] specialized skill, like at the very [22:44] least. Um, on the next slide. [22:47] Uh, actually, could you go to the slide [22:49] after this? [22:52] Okay, I'll go here and then I'll go [22:54] back. Um, [22:56] I think the biggest thing why I think [22:58] it's prop is that you get valuable [23:00] results for edge cases that can just [23:02] sort of further guide your manual [23:04] review. Um, so [23:07] we saw that like the soundness scored [23:09] really high. Um, so you could look at [23:11] some of those bugs and then like see, oh [23:13] okay, like how bad is this really? [23:16] Um, [23:17] another really cool thing you could do [23:19] with this is if you have like the formal [23:22] verification running sort of maybe [23:24] alongside like your manual review, [23:26] um, [23:28] maybe you give the report to the client [23:30] and they come back uh and they fix a [23:32] small part, you could like [23:34] run your specs again and make sure that [23:36] nothing else broke. [23:38] Um, [23:40] I do think that like the results alone [23:42] do not suggest that like LLMs could [23:44] drive a proper standalone formal [23:46] verification engagement right now or at [23:48] least that that could be driven by a [23:50] sole smart contract auditor. I think [23:52] it's still a very, very specialized [23:55] thing that's going to need like practice [23:57] um and expertise. Could you go to the [23:59] previous slide actually? [24:01] Thank you. Uh, so this sort of goes to [24:03] the shortcomings. It's it's hard to [24:04] learn. Um, the results that we got are [24:07] actually dependent on the harness, so [24:09] you could tell me to just prompt better. [24:11] Okay, that's sort of like the next step. [24:13] We'll work on it together. Um, results [24:16] are on the whim of the model itself. So [24:18] you can see a real screenshot that [24:21] Claude gave me. Like this is probably [24:23] the worst thing you could see after like [24:25] 59 hours of proving and hundreds of [24:28] dollars spent on tokens. Um, luckily, [24:32] like [24:33] it was in the conversation history, so [24:35] the fallout wasn't too bad, but like [24:38] there's always this risk of like the [24:40] models going rogue and just sort of [24:42] like, you know, how much can you really [24:44] trust them? Uh, we'll go forward to uh [24:48] two slides or [24:50] Yes. Okay. So like the next step [24:53] uh would be like open sourcing some of [24:55] these harnesses we developed. So once [24:58] that's like out and shared with the [24:59] community, like we can all sort of like [25:02] take a crack at it and like tweaking the [25:03] harnesses. [25:05] Also the workflows um that we did were [25:09] ultimately like prompt output prompt um [25:13] in like a workflow instead of like a [25:15] truly agentic solution. So eventually I [25:17] would want to like develop towards that [25:19] where you sort of had um either like one [25:22] agent or a swarm of agents sort of [25:26] like really really looping through all [25:29] of these different stages instead of [25:30] just like a prompting workflow. [25:33] And then of course, there's a lot more [25:35] work that should be done with like [25:36] testing on multiple models and multiple [25:38] code bases. [25:41] Next slide. [25:42] Okay. [25:43] Well, thank you all for the time. Um, [25:46] and I hope you learned something. I'll [25:47] be around like today and tomorrow uh to [25:50] talk more and I'm interested to hear [25:52] your thoughts. [25:53] Thank you.