Talk by Tariq Shaukat (CEO, Sonar) arguing that as AI agents take on complex development tasks, the critical challenge shifts from code generation to verification. Covers the risks of hallucination and human "cognitive surrender," a three-stage agentic development discipline (Guide, Verify, Solve), why clean codebases matter more in agentic workflows, and how technical debt compounds at machine speed. Timestamps show segments on AI adoption, distinguishing AI utility from "AI slop," agent performance data, a productivity paradox after three months, the Agent-Centric Development Cycle framework, systems-level thinking, and enterprise AI impact. Topic inferred from title and description. # Channel Presentation Observations — Tariq Shaukat (Sonar) Keynote ## Video Context - **Format**: Conference keynote/featured talk, hosted at an AI engineering conference (speaker: *"I'm at the AI engineer conference"*). - **Speaker role**: CEO of Sonar, introduced by a host: *"the chief executive officer at Sonar, Tariq Sha[kat]"*. ## Explicit Self-Description by the Creator - **Company scope claim**: *"We are in the code verification space"* — Sonar positions itself in code verification for software development. - **Customer base claim**: *"we work almost exclusively with enterprises around the world"* — enterprise focus, defined as *"people with existing code bases... with millions of lines of code already"*. - **Product announcements referenced**: A newly launched product (*"We've just launched a product... called sonar vortex"*) and a marketing-mandated product slide (*"I'm required by my marketing team to put up a version of this that has our products on here"*). - **Call to action**: Booth presence — *"It's the big red booth downstairs"* — plus *"doubleclick sessions"* for follow-up. ## Claimed Scope of Topics - Verification as the central problem for enterprise AI value: *"you can treat verification as an afterthought or you can bake verification into the process."* - A proprietary framework: the **AC/DC "agent-centric development cycle"** built on **guide, verify, solve** across three loops (agentic loop, CI verification loop, code maintenance loop). - Concept of **"zero trust multi-layered verification"** combining algorithmic and agentic verification. ## Intended Audience - **Primary**: AI engineers and enterprise engineering leaders — evidenced by references to the conference audience (*"I'm sure many of the people here in the room"*) and anecdote of a large customer's CTO. - **Secondary**: Enterprise decision-makers skeptical of AI reliability — *"the conversation that we have more is the question mark version. Is AGI here?"* ## Observable Presentation Patterns - **Evidence-driven argumentation style**: Cites third-party data (METR-style benchmarking on Mythos models, a Carnegie Mellon study on agent productivity decay) and own benchmarking (*"over 4,000 problems"*). - **Quantified claims tied to product framing**: - *"...over 30% reduction in tokens being used to solve a given problem"* - *"AI derived production outages being 44% less frequent"* - *"they can get a 92% reduction in issues"* (large bank case) - **Balanced framing**: Positions as AI-positive but reliability-focused — *"This is not me saying AI is fake... but it is trying to address this question of how do you really get value in a production setting out of AI?"* - **Named-failure examples used cautiously**: KPMG, EY, and law firms cited for AI hallucination failures, hedged with *"I'm not trying to name and shame here."* ## Claims vs. Demonstrated Patterns — Distinction - **Creator claims** (channel self-description): enterprise focus, verification expertise, framework efficacy, quantified outcome improvements. These are asserted by the speaker, often attributed to unnamed partners/customers. - **Demonstrated**: The talk shows a vendor-led, conference-keynote presentation style — technical framing with benchmark citations, product integration, and marketing touchpoints (booth, sessions) — consistent with a B2B enterprise software company presenting thought leadership. # Delivery Observation: Tariq Shaukat, Sonar — "In the Land of AI Agents, the Verifiers Are King" ## Tone - **Conversational and confident**, with frequent fillers ("um," "uh") suggesting an off-the-cuff rather than fully scripted delivery: "Um, you particularly love the end the being unreasonable part." - **Self-aware humor**, especially about the marketing role: "I'm required by my marketing team to put up a version of this that has our products on here." - **Direct address to the audience** at open and close: "Morning everyone," "have a great conference. Thank you all." ## Recurring Phrases and Verbal Habits - **Repetition for emphasis** is a stable pattern: - "They're getting a lot better very quickly." - "It's a big problem in professional services... It's a big problem in legal... it's a big problem in every sector." - "Software is complex. Software is very messy." - **"Big problem"** as a recurring framing device (at least four instances in the opening section). - **Rhetorical question-and-answer structure**, used repeatedly: - "But are they correct?" - "How do you know that they're correct is a big problem." - "how do you actually know if it's true?" - "do agents care about clean code... and what we find again is they absolutely do." - **"By the way"** as a recurring aside marker (multiple uses, e.g., "And by the way this is still at 80% accuracy," "and by the way the velocity of this has to go up massively"). - **"If you ask why"** as a recurring pivot to explanation: "And if you ask why, it is because of the two pieces in red," "And and if you ask why it's because you're actually making the life of the agent easier." ## Teaching Habits - **Data-anchored argumentation**: repeatedly grounds claims in charts and studies — METR benchmark data, Sonar's own "over 4,000 problems" testing, a Carnegie Mellon study, customer statistics ("44% less frequent," "92% reduction in issues"). - **Caveats and transparency about evidence**: flags limitations explicitly — "full disclosure, we have not yet uh done this benchmarking on the Fable models," "at least per the benchmarking which was done a month or so ago in the preview mode." - **Anecdote to humanize data**: quotes a customer CTO — "his response was, '...I would still put someone who gave me 80% accurate information on a performance review probably.'" - **Named framework with a memorable acronym**: the "agent centric development cycle... we call it AC/DC sometimes." - **Triadic structure** for his core framework: "guide the agents, verify the outcomes and then solve the problems," and later "guide, verify, and solve." - **Pre-empting objections**: "this is not, you know, I'm at the AI Engineer conference. This is not me saying AI is fake," and "this is not stop doing it. This is be aware." ## Audience and Context References - **References the prior talk** multiple times, tying his content to it: "to borrow what Tar was just talking about," "the fusion of these things the the deliberate multi-layered fabric that you put in place" (crediting the previous speaker). - **Conference-aware meta-commentary**: "the agentic loop, which I think is the key buzzword of the conference," "eval may be the buzzword of the um conference." - **Calls to action at close**: booth visit, "doubleclick sessions," "please do join those." ## Pattern vs. Isolated Moments — Uncertainty Notes - **Stable patterns** (well-supported by repetition): rhetorical questions, "big problem" framing, data citations with caveats, the guide/verify/solve triad. - **Isolated moments**: the KPMG/EY/law firm examples ("I'm not trying to name and shame here") — a single occurrence, not a habit. The "T following Tar" odds joke appears once; no evidence it's a broader habit. - The transcript appears to be auto-generated (e.g., "Tariq Sha," "mythos models," "mer," "Butic"), so exact names and some quotes carry uncertainty; quotations above are faithful to the transcript as supplied. # Observation Record: "In the Land of AI Agents, the Verifiers Are King" — Tariq Shaukat, Sonar ## Speaker - **Tariq Shaukat**, CEO of Sonar (code verification space), speaking at what he calls the AI Engineer conference. ## Central Thesis - Models are impressive at generating plausible output, but the hard part is **getting value from AI** — knowing whether output is correct. He argues **verification must be baked into the software development process**, not treated as an afterthought ("code review"). ## Claims and Reasoning ### 1. Enterprise skepticism about AGI - Conference attendees largely believe AGI is here or coming; enterprise customers ask the "question mark version" — **"Is AGI here?"** - Evidence cited: **KPMG retracting reports due to hallucinations**, **EY doing the same**, **law firms in trouble over fabricated citations and case law**. - He frames "AI slop" as pervasive across all sectors (professional services, legal, marketing, finance). ### 2. Coding agents: rapid capability gains, accuracy caveat - Cites **METR data** on "Mythos" models (speaker's rendering): coding agents completing increasingly long tasks — latest at **16–18 hours of human-equivalent work**. - **Critical qualification**: that figure is at a **50% success rate**. - At **80% accuracy**, capability drops to roughly **3.5 hours** of task length. - Anecdote: a large customer's CTO said he'd "put someone who gave me 80% accurate information on a performance review" — i.e., not enterprise-grade. - **Qualification**: Sonar has not benchmarked the just-released "Fable" models. ### 3. Sonar's own benchmarking (4,000+ problems) - Models do well on **functional correctness**. - But even state-of-the-art models show: - **High and variable complexity** - Continued **bugs** (not massive amounts, but present) - Continued **security issues** - **GPT-5.5** noted as doing "particularly well" on complexity. ### 4. Carnegie Mellon study on productivity - AI coding agents yield an initial **3–5x productivity/velocity boost** that **dissipates within three months**. - Reason stated: concurrent increases in **security issues, maintainability issues, reliability issues, complexity** — "you're building the technical debt as quickly as you are generating the code, or maybe even more quickly." ### 5. Core argument: verification must be structural - **Code is provable, but software is not** — large codebases are complex, messy, dependency-laden. - Proposed framework: the **agent-centric development cycle (AC/DC)** — verification-powered agentic loops built on three disciplines: 1. **Guide** (preemptive verification) 2. **Verify** (zero-trust, multi-layered) 3. **Solve** ### 6. Guide: context and constraints - **Context**: architectural awareness, semantic navigation, helping agents understand large codebases. - **Constraints**: guidelines, approved/unapproved dependencies, coding standards, guardrails, **intended architecture** (not just existing architecture). - Claimed results: "massive improvement in agent effectiveness" and **over 30% reduction in token consumption** (their internal testing). - Product mention: **Sonar Vortex**, launched "yesterday." ### 7. Verify: zero-trust, multi-layered - **Zero trust**: every model has biases/personality; use **different models and different techniques**. - **Multi-layered**: combine **algorithmic verification** (data flows, control flows, known patterns, secrets) with **agentic verification** (intent, business logic, "unknown unknowns"). - Claimed result: customers using multi-layered verification report **AI-derived production outages 44% less frequent**. ### 8. Solve: code maintenance matters - Technical debt "does explode" as AI generates code — "this is not stop doing it; this is be aware and control it." - **Agents do care about clean code** because they must understand the codebase to operate on it. - Claimed: same agentic tasks on **cleaned codebases** require materially fewer tokens, reasoning, and energy — a compounding effect. ### 9. Three-loop system - **Agentic loop**: context/constraints plus in-loop verification while the agent works. - **CI verification loop**: PR review via combined algorithmic + agentic verification, evals, quality gates; velocity of review "has to go up massively." - **Code maintenance loop**. - The system **reinforces itself positively or negatively**; neglecting verification leads to a "downward spiral pretty quickly" (ties back to the CMU study). - Claimed result: a large bank using cutting-edge agentic tools saw a **92% reduction in issues** with the guide-verify-solve approach — **qualification**: this is *compounding across loops over time*, not each loop being 92% better. ## Tone and Disclaimers - Explicitly disclaims being anti-AI: "This is not me saying AI is fake or incorrect." - Notes he is "required by my marketing team" to show a product-version slide — self-aware acknowledgment of promotional content. - Positioning note: he attributes the "territory/maps" and "fusion" framing to the previous speaker ("Tar"), whom he references repeatedly. # Speaker Attribution & Provenance Record ## Video - **Title:** In the Land of AI Agents, the Verifiers Are King — Tariq Shaukat, Sonar - **ID:** `01a15ca8-712b-7b48-9a93-d4a80ab50a13` ## Speakers & Roles | Speaker | Role | Evidence | |---|---|---| | **Unidentified introducer** | Presenter/MC (not named in transcript) | "Please join me in welcoming the chief executive officer at Sonar, Tariq Sha." | | **Tariq Shaukat** (transcribed as "Tariq Sha") | **Creator / Keynote speaker**, CEO of Sonar | Self-introduction: "I am with Sonar. We are in the code verification space." | **No guests or narrators identified.** All substantive content is delivered by the single keynote speaker. ## Referenced Third-Party Claims (as attributed by the speaker) - **KPMG** — reports retracted due to hallucinations (speaker's characterization). - **EY** — speaker states "doing the same thing." - **Law firms** — trouble from "made-up citations, made-up case law" (unnamed). - **Meter** — benchmark data on coding agent capability ("data from um meter"), showing ~16–18 hour tasks at 50% success; ~3.5 hours at 80%. - **Carnegie Mellon University study** — productivity boost from AI coding agents (3–5x velocity) dissipating in ~3 months due to security, maintainability, reliability, complexity issues. - **Sonar internal benchmarking** — 4,000+ problem suite measuring complexity, bugs, security issues; notes GPT-5.5 performance. - **Unnamed CTO of a large customer** — quoted remark about 80% accuracy not being enterprise-grade. - **Sonar customers/partners** — reported 44% fewer AI-derived production outages with multi-layered verification; an unnamed **large bank** — reported 92% reduction in issues. - **Prior speakers referenced:** "Fable" model presentation and a talk by "Tar" (identity not stated in transcript). ## Promotional Segments — Flagged - **Product announcement:** "Sonar Vortex" — "launched a product yesterday I think." - **Marketing slide:** Speaker explicitly flags — > "I'm required by my marketing team to put up a version of this that has our products on here." - **Booth/session promotion:** "We have a booth. It's the big red booth downstairs... We have some doubleclick sessions coming up." ## Source & Availability Notes - Speaker discloses Sonar has **not benchmarked the "Fable" models** yet: "full disclosure, we have not yet done this benchmarking." - Customer testimonials (CTO, large bank, outage statistic) are **attributed but unnamed**; no published sources cited in transcript. - **No curated metadata supplied** — no comment availability, no external source links beyond those spoken. - Frameworks and statistics ("AC/DC agent-centric development cycle," token reduction >30%) are speaker/Sonar claims, not independently verified. Please join me in welcoming the chief executive officer at Sonar, Tariq Sha. Morning everyone. Did you enjoy that last talk? That was amazing. Um, you particularly love the end the being unreasonable part. I thought that was awesome. Um, I also want to just I'm trying to calculate the odds of t following tar as the first two sessions in the morning. Uh, I think the odds are pretty low on this one, but uh, thrilled to be here today. Um, as as we just mentioned, I am with Sonar. We are in the code verification space and I'm here today to talk about verification. And I think we're all here uh in large part because we believe to some extent that AGI is here. It's coming. The models we just heard about Fable. It's really incredible what is going on in the world today. And yet we work almost exclusively with enterprises around the world. And the conversation that we have more is the question mark version. Is AGI here? And why are they asking these questions? It's because you can read the news every day. And I'm not trying to name and shame here, but if you look at KPMG putting out reports that they have to uh retract because of hallucinations, uh EY doing the same thing, law firms getting into lots and lots of trouble because of madeup citations, madeup case law, things like this. I think we can really start to question how do we get value out of AI? The models are amazing as we just heard, but the hard part as the other target just said is getting value out of it. The struggle is that AI slop is everywhere. I'm sure you all see this inside of your organizations. I'm sure you see this in your everyday life. That AI is amazing. The models are incredible at generating very plausible output. They're incredible at generating things that sound correct. But are they correct? And how do you know that they're correct is a big problem. And it's a big problem in professional services as we saw. It's a big problem in legal. But really, I think if we're honest, it's it's a big problem in every sector, in every field, whether it's marketing or finance or you name it. You have this question of how do you actually know if it's true? How do you know if it's good or if it is slop? And the question that we we deal in the coding space in particular, we deal with software development. And the question we get as we talk to I'm sure many of the people here in the room and a lot of our customers is, isn't software development different? And we can look at the data on this and uh the mythos models. Um this is data from um meter. Uh you may have seen this mer. Um the coding agents are getting better uh very quickly. They're getting a lot better very quickly. And you can see uh the progression, the exponential curve here. What this shows on this chart is how capable are the models at completing tasks that humans would take. So can they complete a task that takes 1 hour, 2 hours, whatever it is. the latest Mythos model, at least per the benchmarking which was done a month or so ago in the preview mode was you're getting to 16 to 18 hours. So they're actually able the agents are able to complete longunning tasks and it really is starting to transform how work is happening. But the critical caveat when you read the data is this is at a 50% success rate. Okay. So it is again able to complete tasks but is it able to complete tasks correctly is the question. So if you start looking at let's dial up the accuracy rate you dial it up to 80%. And there's still progress but it is much slower progress. Instead of 18 hours you're at about 3 and a half hours or something along these lines. And by the way this is still at 80% accuracy. And as I was presenting this to the CTO of one of my uh large customers, his response was, "Butic, I would still put someone who gave me 80% accurate information on a performance review probably, right? This isn't necessarily enterprise grade. The problem is that the models themselves, and full disclosure, we have not yet uh done this benchmarking on the Fable models obviously because they are just being released. But as you look at the models, the models are getting smarter, but they still produce a lot of problem problematic code. This is benchmarking that we do. We give the models a series of over 4,000 problems and we basically ask it to generate the response to the problems and then we analyze both the functional correctness which is critical and they all do extremely well on this notion of functional correctness, right? Um, but then we look at how complex is the code, how buggy is the code, how secure is the code. And what you see with even the state-of-the-art models is that complexity is still high. It's actually quite variable as you can see here. Um, GPT55 has done particularly well on the complexity side of things. It still generates bugs. It doesn't generate massive amounts of bugs, but it still generates bugs and it still generates security issues. So this is the output of the models that are going into the agentic workflows. And again, this is not, you know, I'm at the AI engineer conference. This is not me saying AI is fake or or um incorrect, but it is um trying to address this question of how do you really get value in a production setting out of AI? This is a study that was done in Carnegie Melon uh University and it looked at what is the actual productivity benefit that you see from the use of AI coding agents. And what you see I think really resonates with a lot of what I see firsthand in the market which is you have a initial just amazing boost of productivity of velocity in particular. what you see is a three to 5x boost in productivity or in in velocity. Um that dissipates in three months. At the end of three months, it starts to come back to the the normal before you were using the agents. And if you ask why, it is because of the two pieces in red here that you start to see there's an increase in velocity, but there's an increase in security issues, there's an increase in maintainability issues, there's an increase in reliability issues, and there's an increase in complexity. So essentially, you're building the technical debt as quickly as you are generating the code or maybe even more quickly. And that creates a different set of work. it creates a different bottleneck. And so to us, this is now the critical question in AI, which is in a world in which code is provable. And there's sessions that um I'm actually very much looking forward to attending about formal methods and proofs and things like this, code is provable, but when you start dealing with large code bases, software is not. It's still very complex. It is still very messy. there's lots of um dependencies. There's lots of uh technical debt already in most code bases. And so this question of verification is actually key. And what I'm going to be arguing is that you can treat verification as an afterthought or you can bake verification into the process. And if you bake it into the process of generating code, of doing software development, you can actually start to get materially better outcomes from the coding agents than if you view it as an afterthought. If you view it as just the old school code review. So as we've been thinking through this, we basically have constructed a framework and there's lots of competing frameworks around this, but I'll just talk you through uh ours. We call it the agent centric development cycle. for shortand we call it AC/DC sometimes and the idea here is how do you get verification powered to Gentic loops at the center there's a lot of focus on the code generation piece like how do you actually get the models and the agents to generate the code that you need to solve the problem and what we argue is that you should surround this with the right disciplines the right tools the right processes to do three things to guide the agents and t is talking a lot about different aspects of this actually. Guide the agents, verify the outcomes and then solve the problems. And you have to make this part of the discipline, part of the process, part of the new software development life cycle if you want to be successful in the AI world. So if I double click on some of these pieces, what do we mean by guide? We've done a lot of experimenting around guide. We've just launched a product um yesterday I think called sonar vortex that starts to get into this area. What we find is critically important is to think about guide as context and constraints and we separate out context and constraints very deliberately because context is you have your code repositories. How do we make it easier for the agents to understand for the models to understand what is in your codebase? If you have a million lines of code, if you have a hundred million lines of code, you have a billion lines of code, the agents work better if they understand your codebase. So, how do you give it architectural awareness? How do you provide uh semantic navigation uh maps um and uh and help them understand the territory to borrow what Tar was just talking about and we find it equally valuable and I don't think this part is talked enough about to provide the constraints as well. You have guidelines that you want your code to follow. You have dependencies you are okay using. You have dependencies that you are not okay having. You have coding standards. You have guardrails. You have intended architecture. We spend a lot of time talking about existing architecture. But what about where you want to go? And so this idea of context and constraints uh we've found in our testing generates a massive improvement in agent effectiveness and a massive uh improvement in token consumption o over 30% reduction in tokens being used to solve a given problem. And and if you ask why it's because you're actually making the life of the agent easier. You're helping it navigate better. So then we get into the heart of this and we really think of guide as preemptive verification. How do you make sure there's less to verify, less to fix, this sort of thing. Then you get to the heart of verification and what we believe quite strongly and what we've seen work in practice is this idea of zero trust multi-layered verification. Zero trust. Every model has biases. Every model produces has a character has a personality. So, let's make sure we use different models and different techniques to make sure your code is safe, to make sure it's reliable, to make sure it's secure. And multi-layered really speaks to the earlier point that software is complex. Software is very messy. Software has lots of of of intricacies involved with it. And so what we believe and again have found to be quite um impactful here is that a combination of algorithmic verification looking at things like data flows, control flows, known patterns, secrets, these areas combined with what is now possible with agentic verification looking at intent, business logic, the unknown unknowns. Actually again to borrow from the last uh presentation the fusion of these things the the deliberate multi-layered fabric that you put in place can actually you can see the results of this in production. So as we look at our partners and customers who use a multi-layered verification approach they are reporting AI derived production outages being 44% less frequent than the ones who do not. So you can start seeing a material improvement in reliability, in security and in maintainability. And then the last point I mentioned is technical debt does explode. Right? As you generate code, technical debt is also generated. And again, this is not stop doing it. This is be aware and let's start controlling it. And so what we um have seen be super effective is to have an active process to have an active discipline again around code maintenance and thinking about how you do verified code maintenance. Um I won't walk through every step of this but a the agents whether that is a set of remediation agents whether it's a strong discipline around verification does keep your codebase clean and a lot of people have asked me all right but do agents care about clean code human developers care about clean code do agents care about clean code and what we find again is they absolutely do because the agents have to understand the codebase if they're going to operate on it so this is a oneshot view. Um, we think this is something that compounds. But if you just do the exact same agentic tasks on a typical codebase and then one that has been cleaned, you see a material reduction in the amount of tokens, reasoning, energy, etc. needed for those cleaner uh code bases versus the typical code bases. Right? If you make the life of the of the agent easier, if you maintain your codebase, then you'll actually see compounding effects. Now, the important thing in our mind is to construct the system. This is how I started is saying, you know, I'm sure all of us do code reviews, you may use static analysis tools, you may use AI code uh review tools, a whole range of things. And we believe that you have to put this in a system. And again, uh, we're happy to in our booth downstairs talk through what this looks like, but we really believe that the construction of the software development life cycle in an AI world um, needs to embed this notion of guide, verify, and solve inside of it. And you need to do it in three loops. And you need to think about these three loops. There's the agentic loop, which I think is the key buzzword of the conference. Um now but how do you provide the agents as it's generating the code as it's doing the work with the context and constraints with the inloop verification so that the agent is getting verification as it's working and how do you fix problems that's that's the blue loop here what we what we talk about is the inner loop verification piece. There's a second which is your continuous improvement process and how do you really combine the power of algorithmic and agentic to generate your your pull request review the code and by the way the velocity of this has to go up massively so to review the code using agents and to do this multi-layered verification and then you have your evals and I think the opening speaker talked about how eval may be the buzzword of the um conference you have your EV valves and you have your quality gates to check are you actually passing. So you have your your code maintenance loop, agentic loop, CI verification loop and deliberate design of these loops with verification at the center is a compounding system. It's a system that reinforces itself and it reinforces itself in the positive and it reinforces itself in the negative. And we've seen customers who uh have kind of neglected as they've rolled out AI coding tools, they've neglected verification, they've neglected this idea of code quality, of code um maintenance, things like that, and you get into a downward spiral pretty quickly. This is what the Carnegie Melon uh case study uh or study actually shows is that you actually have all the benefits start to dissipate or you can get into the self-reinforcing loop. And one of the tests we did with one of the large banks who are using some of the cutting edge the folks who are all around here today um cutting edge agentic coding tools they can get a 92% reduction in issues if you actually take this guide verify solve approach inside of those agentic loops. If again this compounds it's not that each loop is 92% better. that as you go through solving the problem over minutes and hours that you actually see a compounding benefits. So that is uh essentially how we see the benefit here. The how we see the controlled um value creating use of AI in enterprise settings and when I say enterprises people with existing code bases people with with you know millions of lines of code already. There's the agentic loop, there's a CI verification loop, there's the code maintenance loop. I'm required by my marketing team to put up a version of this that has our products on here. So these are our products and you can come and see us later. But the most important thing is really to say our recommendation is this agent the AC/DC agentcentric development cycle. The core part is deliberate verification built into the system. So if you'd like to learn more um we have a booth. It's the big red booth downstairs. We'd love to talk more. We have some doubleclick sessions coming up. So, please do uh join those and uh have a great conference. Thank you all. \>\> \[music\]