What’s up engineers? Andy Devdan here. Today I’ve got an absolute banger agent system to share with you. But first, let’s set the stage. April 2026 had the highest velocity of model releases ever. We got Opus 4.7, GPT 5.5, Deepseek V4, GLM 5.1, Kim K 2.6, and the Quinn series. The pace has been incredible. But for us engineers, model performance is no longer the bottleneck. It’s you and I. It’s our ability to extract value out of Agentic Systems at scale safely. If you look closely at any one of these benchmarks, you’ll see something that’s missing. Have you noticed it? It’s hiding in plain sight. And once you realize it, every benchmark looks incomplete. So instead of rehashing yet another model release which we know will keep coming over time, let’s talk about what we can do with combinations of models with every release moving
[00:01:00] forward. Here I have two specialized PI coding agents each running state-of-the-art cracked models. We have Opus 4.7 on the right and we have GPT 5.5 on the left. I’ve customized these agent harnesses to deliver unique value. But you’ll notice something weird here. This harness takes no input. What is this? How does it work? And what’s missing from every benchmark? Let’s break it down with the verifier agent. One of the highest leveraged things you and I can do is increase the information density per action for agents in our production code bases. OpenAI’s new GBT image 2 model is exceptional at this. So let’s use this new image generation model to showcase how the verifier works. And our builder agent on the right here, I’m going to prompt run prime then run skill GBT image 2
[00:02:00] generate arch.jbg JBG to concisely describe the architecture of the verifier 2 agent system. The prime command gives our agent essential context about this codebase. You can see this customized PI agent going through the process. It’s going to study the codebase, understand how this works, and you can see here it’s reading this GBT image 2 skill I’ve created to teach the agent how to generate and edit images with this new model. It’s kicking off that script with a highly highly detailed image prompt. This is one of the great parts about Claude Opus 4.7. It understands agents. It understands models. It knows that it itself can prompt other models. And you can push this ability by templating and teaching exactly how you want your prompts to be written. This is super super key for prompting other models and agents, which is key for scaling our work beyond a single agent, which you’ll see here. So, this will take some time. You can see here 70 seconds already, but the image quality coming out of the new GPT image 2.0 model is insane. It’s worth the wait
[00:03:00] and it’s worth the price. Image generation is complete. The agent’s checking its work and now it’s marking it done. Now watch what happens here once our builder agent completes. Excellent. And now our verifier agent has kicked off unprompted. We did not prompt this. I’m not doing anything here. My hands are off the keyboard. The verifier agent is now taking over. We have this very simple two agent system where on completion of any prompt that executes the verifier is kicking off and doing work. Now the big question is what is this agent doing? What is the work that’s being accomplished here? You can see that it’s reading the image that was generated. And now what’s going to happen is it’s going to validate a few things. The first thing it’s going to do is validate the individual claims the builder agent has made. And then second, it’s going to make sure that what we asked for is what it built. So if we just hit up here on the builder agent, you can see exactly what we asked for. What’s going to happen here is our verifier is going to walk through every single claim. There we go. Check this out. And if it needs to, it’s going to
[00:04:01] prompt the primary agent. So this is really incredible. I didn’t prompt this. My verifier agent just prompted my builder agent. Let’s make this super clear. This prompt here from the verifier kicked off a prompt in our builder agent. The verifier agent found something that was incorrect. Let’s go ahead and see if it’s written up its report here. Okay, it has. Fantastic. So, let’s go ahead and let that image generate. And let’s break down the feedback here. You can see that our input here is prompted builder. This is feedback mode. Our verify agent here has given our primary agent feedback completely unprompted. Again, I did nothing here. The system is acting on its own. So, what happened here? Right on every prompt on the stop hook, the builder agent sends an event through a Unix socket. Actually, we should take a look at this image before it gets updated. So, we’re going to open up VS Code and let’s look at this architecture diagram. You can see here a very detailed image generated by GBT image 2.0. The text styling and pretty much everything coming out of this model is very very state-of-the-art. You can ask
[00:05:00] for exactly what you want to see and it’ll generate it for you. But you can see a solid description, a solid understanding. And in fact, before this gets overwritten, I’m just going to clone it here so we have it as a backup. What’s happening in this report? Status failed. Our agents work was not successful. Stats failed. Confidence is feedback. What did you verify? GBG image 2 was used. It ran the right script from the right skill. The image was generated. It validated that it existed. Right file size. It is a JPG image as asked. Validated the claims, everything the builder said that it did. And then the model is looking visually at the image to make sure that it describes the verifier 2 agent system, which is the code base that we’re generating the architecture diagram for. Readability and text density looks good. It could verify everything it needed to. Very important. But check this out. Our agent gave feedback. And you can see here the work is completed. Our builder agent violated one of the rules. Okay. And so we were just getting into that. Let me just pause this. Scroll back up. You can see that next stop hook is coming over. What feedback did you give? Arch JBG
[00:06:00] existed visually shows the verifier 2 agent system but violates the readability contract by exceeding 10 distinct blocks inside of the verifier agent for image generation. We have a rule that we should never have more than 10 blocks of text inside any image. So this is just a great rule for building out diagrams. This looks good but it is overloaded with information. There’s a lot going on. It takes time to digest this. Right? An image should be worth a thousand words. It shouldn’t force you to work through things and read a ton of text. That’s what text is for. It really simplified that for us. And so this is one of the rules we have that we directly built into our verifier. And so that was feedback that our verifier directly gave our verifiable agent or just the builder agent. So if we scroll down here, we can see that that second prompt was completed and now it has an updated status. Right now we have a clean green bar here. We have a successful bar. Verify image verified. Perfect. In the bottom section here in its report format, we’re being very consistent. Return index one. We have
[00:07:00] our total atomic claims. And then we have our claims verified, claims failed, claims unverified. And we got seven out of seven verified. So everything was successful. Our verifier agent did not reprompt our primary agent. You can kind of see the value proposition of having an agent that just observes, that just watches, and only gives feedback when necessary. And speaking of feedback, we have a couple really important key sections here that is going to help us improve this system. What could you not verify? As you can imagine, this will be very important for us improving our verifier agent. This verifier agent has a lot of special properties built into it. So, let’s go and check out that image that was generated. You can see here this second version much better, right? A lot less text overloaded. This is an image, not a markdown file. So, we want it to be super clear, super concise. And this is the PI verifier agent architecture builder agent and we have a verifier. They communicate through a local Unix socket. It has a few guard rails and constraints that
[00:08:02] we’re going to talk about in a moment here. And the verifier takes in the session file thanks to the PI Asian harness. We have full access to everything our builder agent has done. And our verifier can just look at that at any point in time. And if it needs to, only if it’s violated a rule of the verifier does it actually reprompt. This system looks good. I want to add something to this image. Let’s go and push this new GBT image to model a little bit. It’s missing one thing. It’s missing us in this picture. I’ll say this are the ones prompting the verifiable also known as the builder. So, we’ll fry that off and another round is going to occur. This is one of the keys of this system. I am just working on a single agent harness, a single agent decoding tool as you do. Check out the compute I’m spending here on the left to verify all the claims and to write the prompts that I would have had to write myself anyway. Here we go. Opus getting to work doing the building. And after it builds, GBT 5.5 is going to get its back. It’s going to check its work.
[00:09:00] It’s going to make sure that it’s doing the right thing. We are pair programming. Let’s be super clear about this. We have two agents working together in a very, very simplified multi- aent system. On the channel, we’ve talked about teams of agents. We’ve broken down a three layer architecture where you have an orchestrator, leads, and worker agents. Very powerful, very complex. Here we’re simplifying. We’re focusing on one of the first most important multi- aent systems that you can probably build. And I have to tell you, you know, many of the ideas I share with you here are experiments. Many of the ideas are trial and error. This is one of the systems that as soon as I found this, I put this in my pocket. And u this is the system I’m using a lot right now. And this is a good time to start talking about the benefits of the system. What problem does the verifier agent solve for you? What does this unlock for you? Let’s talk about this. Whenever you can, you should be spending tokens to save time. As you saw here with my image generation system, people don’t like noisy images with a bunch of
[00:10:02] text that you have to reason through. So, I built it into my image verification agent that for every image you see, it cannot be bloated with text. 10 blocks of text is the limit. And so, this is a very, very powerful system. I’m spending more tokens. And you can see here, 4% on Opus, 23% on GPT 5.5, quite literally spending 5x tokens to make sure that I spend less of my time. And this is an interesting equation you can do. How much is your time worth? If you ask me, your time is worth a ton. You should not be trading your time for anything you don’t have to or for anything that you don’t want to. And so one of the key value propositions of the system is that we are scaling our compute to scale our impact. We are directly spending more tokens to save time. What are we spending more tokens and saving time on? That’s the next big value proposition. And let me go ahead and write these out, right? Let’s be super explicit about the value that we’re actually getting out of the system. So what’s the value of the verifier agent? Spend tokens to save
[00:11:00] time. And so what are we saving time doing? Review constraint. Time is worth more. So what are we actually spending our tokens on? We’re spending our tokens on breaking through the review constraint of AGC agent coding. Right? Let me just spell this out. In agentic coding, there are two constraints. If you’re agentic engineering properly, you have already noticed this. Planning and reviewing. If you’re doing things right, you’re spending your time planning and reviewing. With the verifier agent, we can improve our review constraint. How? By teaching an agent exactly how we verify by adding these rules by making them read the files that you would read. This is a very very clear concise example for you. When this agent runs and I’m generating images, I’m always going to run a validator behind it to make sure that it didn’t violate any of the rules for image generation that I have set. And this allows me to do something really special. We’ll talk about this at the end, but I can just continue to stack up these verifier agents to focus on one specific thing. We’re hitting on this key tactic of agentic coding. Once again, one agent,
[00:12:00] one prompt, one purpose. A focus agent is a performant agent. These validators, these verifiers just focus on one thing. They make sure that that one thing is right. You can see here, you know, we’re working through image generation as a concise example. But now every image I generate is going to run through a check, a series of constraints that are validated nondeterministically and as you’ll see in our upcoming example, deterministically as well. And so this is another advantage of this system. We’re spending tokens to save time. And what do these tokens do? They help us break through the review constraint. We’re teaching our agents how to review and verify the work. And you can see everything that our agent verified by hand. We have nine sets of text blocks here. and it spelled them all out individually which is fantastic. You know GBT 5.5 is one of the best image reading models. There was no feedback to give so it just stopped right and it wrote this report for us. It didn’t give any feedback and it doesn’t need anything from us to verify this next time. This leads us into the next huge
[00:13:01] huge huge value proposition of this verifier agent specifically. You’ll notice here we have a feedback loop. this field here, this report section that this agent always reports in because I prompt engineered the system prompt. If there’s ever something the agent can’t actually verify, it will tell me. It will say it right here. And guess what I can do with this? This is a positive feedback loop. It’s a flywheel. I can then if I need to take the information it’s given me here on what it could not verify and I can encode this. I can template this into the agents system prompt. And let’s go and just take a look at this one. We have an entire customized system prompt. This is not an average system prompt. I am adding things into the front matter of this prompt to override and get special behavior. This is what you can do when you own the agent harness. More on that in a moment. But you can see here that I have a bunch of rules and verification steps that are verifier follows. We can just search this max text elements right here, right in our instructions. Okay,
[00:14:00] so it’s super clear. If we look at the report, we are teaching our agent how to respond as well, right? We have this clean, clear report section. What could you not verify and what do you need from me to verify this next time? Super, super important. Why do we care about the verifier agent? It’s because we have builtin positive feedback loops. I always advocate that you get out the loop, but it’s important to be in the loop for certain work. And since you’re there, you might as well be compounding the advantages of the agents you’re working in and working on. This is one of the ways you can do this. Last but not least, template your engineering as a habit. Let’s be super clear about this. The most important piece about this verifier agent is that we have templated our engineering into the system prompt of this agent and then we’ve wrapped it inside of a custom PI agent harness where I actually cannot do anything but follow the rules of this system. Right? I can’t prompt this. I cannot fall to the lowest hanging fruit of the generative AI age. There’s no vibe coding this stuff. I cannot just
[00:15:01] fire a one-off prompt. I can’t say do XYZ. I cannot even interact with the verifier. That means that if something goes wrong here, if the verifier isn’t verifying something, if it’s missing something, if I need to add something to the system, there’s no one-offs. I am forced to template my engineering into my verifier agent. This is very, very important. There’s an increasing gap between the two key sets of engineers. engineers who are stuck in the loop prompting back and forth with their agents. You’re here. You’re prompting back and forth. And then there’s a second set. They’re starting to build systems like the verifier agent. They’re starting to build multi- aent systems that scale. They’re building AI developer workflows, a key topic we talked about in tactical agent coding. They’re building something like Stripe’s blueprint system, which we covered in a previous video. They are stacking up code plus agents to outperform either alone to run longer threads of work. If you’re stuck prompting back and forth, you will not get those advantages. And here, we are forcing oursel to get that advantage. Okay? We’re building it into
[00:16:01] the tool we’re using. This is very important. These tools haven’t emerged into the true form of what it means to be an agentic engineer. They don’t fit the shape of what we are becoming yet, of the new role that we are adopting and and creating. But this is a step in that direction. I can’t prompt this. I’m forcing myself to get out the loop. This is super super powerful. So this forces me to template my engineering if something goes wrong. I don’t just fire off another prompt. I’m effectively forced to improve one or more of the core four context model prompt or tools. So this is the other big advantage as a habit by force. That’s kind of the other thing, right? Um thanks to the Asian harness. And I’ll be super specific here. This is a customized agent harness, not just any agent harness. I have a dedicated workflow that is built in here. Now that you understand the benefits of a verifier agent, a simple two agent system, let’s go ahead and dive a little bit deeper here. Right, let me show another example and an additional key attribute of this system. And if we quickly check the architecture
[00:17:01] diagram created, you can see that this looks great, even better from our original version. We ran two prompts and we got a nice improved hero image. This looks great. I’m going to use this for this application as a hostess. And I’ll be giving away two versions of the verifier agent. So stick around to the end to figure out which version will be available to you. As an engineer, you’re never just reviewing one thing. You’re reviewing sets of things. And that’s the great part about this system. If we type J, we can see all the commands. This is just it is a simple command line runner. I use this in every single codebase now. And we’re going to boot up JVSQL. We’re going to show off one more key example here. And here we’re using the GLM 5.1 model. Find all SQLite DBs in this repo. Break down tables, columns, and relationships. Now we have a verify SQL light agent and one of the key things you maybe notice here is that the verifier is independent of the verifiable and this means that you can do whatever you want. You can run however many agents. You can set up whatever PI agent harness this primary
[00:18:01] agent however you want to. What we’re doing here is creating an extension that is layered on top of whatever your primary agent is that adds serious customized specialized validation. All the relationships, all the tables, all the SQLite databases in the system were found and were reported. The agent, right, this is Cloud Opus 4.7. It’s an absolutely correct model. It did the work. But there is no harm in having an agent validate that that is true. And so once again, the verifier agent is getting to work. We have a nice powerful yet cheap GLM 5.1 model here doing something really powerful. So how this system works is is super important. You can see here the agent broke up the work into atomic claims. Everything you prompt into your agents, they’re all small axioms. They’re small claims. They’re units of information that can be proven true or proven false. For instance, find all SQLite databases in this repo. So, this is something that is validatable. Did the builder agent actually find all the SQLite databases?
[00:19:01] Break down the tables. That is another thing that can be validated and proven. Did the agent break down the tables and the columns and the relationships? There are several claims and provable steps, right? Provable pieces of information that the verifier can work on. And this was part of the system prompt of this customized agent. This is a custom agent. It is built to break the prompts and the work done down into individual claims, right? Individual atomic claims, individual units of truth or false. And so you can see that here, right? What did you verify? Look at all these atomic claims. Look at all these individual things the agent has proven very very powerful. Everything’s true. This is a simple find and report. And if you scroll up here, you’ll see that the agent is also doing something really interesting. I have restricted this agent. Once again, we have one agent, one prompt, and one purpose. This agent is restricted to running just this one script. We can see that inside of its system prompt here. So, inside of PI, verifier agents. Of course, when you’re
[00:20:00] building your own customized PI agents, you can set up whatever directory structure you want. You’re in full control when you control your agent harness. When you’re not, you can’t. We’re doing something really special here. We’re giving access to several sets of tools here. But also, we have a bash policy. Not sure if you noticed, the number of security vulnerabilities is hitting the roof. It’s going parabolic. And also, not sure if you noticed, but the number of times an agent is losing control, hallucinating, or just ignoring instructions is going up as well. If you’re harness engineering properly, and less controllable agent harnesses like Cloud Code, Codeex, Gemini, Open Code, yada yada yada. If you’re using those, you can control what your bash tool can do. Let me make this super clear. The bash tool is the most dangerous tool you can give your agents. I’m going to talk about this more in the channel. Make sure you like, make sure you subscribe. But this tool is a ticking time bomb. And so what I’ve done here in my verifier agent is I’ve restricted it to using just one script. This is the highest level of control you can give. And so if at any time this model calls
[00:21:02] anything with the bash tool other than my script, it’s blocked fully blocked. And so this is one of the things I’ve built into the system. SQL light agent. Think about this. This can be your Postgress agent. This can be your whatever cloud DB agent, your MongoDB agent, MySQL agent, whatever backend SQL blah blah blah you use. Replace this with that. Right? That’s the idea here. And with this, it’s very, very powerful, right? Especially for data manipulation related activities your agents are taking. Having a verifier is extraordinarily powerful because your agent might only find some of the data. It might only report some of the tables. With a verifier, they can come in and just double check. And and once again, notice Obus spent 1% of its tokens. So something like, you know, 10K tokens. GLM 5.1. This is a 200k token context window model. Uh so what is that? 10% that’s 20K. So so this model spent two times the tokens verifying this agent than the actual agent execution. I’m spending 2x compute. Once again, I’m spending tokens to save time. And what I’m actually doing here is a little more
[00:22:01] important than you might see. I am increasing the trust I have in my agent system by having this verifier agent validate the atomic claims that the builder agent has performed. And so once again, same prompt format, same verification set, same set of confidence levels it can report, nothing it can verify, no feedback, and no improvements for the verifier agent to improve for the next run. This is a compounding system. This is a system that’s going to improve with every prompt I write. And hint hint, as I mentioned, you can stack more than one of these verifier agents. Not going to show that here. Don’t have enough time. But this is one of the patterns I have been using a lot and I’m getting a lot of value out of this. So that’s the core of this system. We have a two agent multi- aent team. One is a verifier and one is whatever your normal agent is. And this could be running anything you wanted to. This is just your primary pie coding agent. on the left here though as mentioned in the beginning we’re validating all the claims that the builder agent made and we’re making sure that what we asked for
[00:23:00] is what was built okay we are directly attacking the review constraint of agentic coding and this is where most engineers spend their time let me make this even clear if I can here thanks to this two agent system I’m spending less of my time reviewing work this is the problem to solve multi- aent orchestration is the solution so let’s come up right I’m not going to spend too much time in this code you’re going to have this available to you to kind of break down and understand and you’ll be able to throw your agents at this with some really clear architecture diagrams. You know, in the beginning I said something’s missing from all these benchmarks. What is it? As you can see here, every single model benchmark you look at, they’re all making the exact same mistake from the perspective of us engineers. Every one of these benchmarks is running a single model in isolation. Now, you might be thinking, yeah, obviously we’re testing the individual models. But my point here is that to get maximum intelligence out of these models to get the true capabilities, you don’t just run one of these models. You run multiple models.
[00:24:00] And most importantly, you know, we’re not just kicking off sub agents. I’m not talking about delegation. I’m talking about multi- aent orchestration. I’m talking about setting up systems of agents. I’m talking about setting up teams of agents that operate better together than alone. We’re not just talking about simple delegation. We’re talking about coordinated agents. We are talking about multi- aent orchestration. We’ve been talking about this on the channel week after week after week and I will be continuing to hammer on this idea because every benchmark is missing the true capability of what you can really do with these models. It’s not about GPT 5.5 or Opus 4.7. It’s GPT 5.5 and Opus 4.7. Right? It’s an and not an or. Once again, you got to get out of this simple competitive mindset. stack intelligence, orchestrate intelligence, and a key part of this is owning your agent harness. This is why I’ve been such a fan of the PI coding agent. Looks like we got a website update. I’m not a huge fan of this itallic font. Kind of
[00:25:01] hard to read, but anyway. You know, the idea here is simple. There are many coding agents. There are many agent harnesses, but this one is yours. Fully customizable, adaptable, and it doesn’t change underneath your feet. As soon as a new update rolls out, you can control it. It’s yours. This has been one of the most valuable and simplest ones. So, I wanted to come to the channel and share it with you here. As mentioned, I’ll be sharing two versions of the verifier agent. One is going to be available for free for you on my GitHub repository. I’m going to make this public for you. And the other one is going to be a souped-up version with a couple additional bells and whistles. And that’s going to be available exclusively for Tactical Agent Coding and Aenta Horizon members. What is this? I’m going to quickly pitch this. If you’ve already seen this, you know, good time to sign off. This is my take on how to scale far beyond AI coding and vibe coding with advanced agentic engineering. So powerful your codebase runs itself. A lot of what you’re seeing right now with multi- aent orchestration. We have covered we have foreseen inside of this course. There are thousands of engineers
[00:26:01] inside this course. And let me be super clear here. This is for engineers that ship to production. If you’re a vibe coder, if you’re a new newbie engineer, this is not for you. This is not simple. This is not for beginners. I built this for the top 20% of actual software engineers. Okay, but there are a couple things here that we cover. Let me just cover a couple facts. A coding was just the beginning. Phase one vibe coding is the lowest hanging fruit. 95 of all code bases are now outdated and inefficient. As we discussed, you the engineer are the bottleneck. It’s not the models. It’s not the tools. It’s not the agents. It’s you and I. It’s what we can do with this technology. There’s a new role and it’s getting talked about more and more and more by top engineers. This new role is called agentic engineering. The ability to build these kind of pseudo living intelligent systems, right? That’s what we’re doing here. We’re building systems that build systems. And that’s the key idea inside of tactical agentic coding. We ask the question, what if your codebase could ship itself? And we build the system that builds the
[00:27:01] system. You don’t want to be working on your application anymore. If you’re still doing this, you’re wasting time. I’ll just be really blunt with you. Someone has to. Instead, you work on the agentic system. The system that builds the system. This is what matters now. All the engineers getting the highest leverage. They’re doing things like controlling their agent harness. They’re controlling the core four context model prompt tools. They’re making it safe, secure. They’re locking down the bash tool. They’re adding more agents. They’re adding custom agents. And then they’re orchestrating their agents. What are they doing? They’re operating on the agentic layer of their codebase. the agentic system. They’re not operating on the application. This is low leverage activity. You can prompt against your primary codebase and fix things oneoff super super slowly over and over and over. Waste all your time. That’s fine. You can do that if that’s you. Click away. The video’s done. You know, GG, good to see you. But um for everyone else that understands that we’re in the age of agents. This is the highest
[00:28:01] leverage opportunity that’s ever existed for us engineers. And everyone’s so afraid that vibe coders and their mom and their brother are going to take away engineering jobs. Guys, that’s just not true. Okay, vibe coding is the floor. Agentic engineering is the ceiling that no one has even imagined the capabilities of yet. If you’re interested in advanced agentic engineering, so powerful that your codebase runs itself, this course is for you. All that to say, I’m going to be adding this codebase. Uh this is the full kind of version of the codebase where I’ll be sharing all the verifier specialists, not just the generic verifier. And I’ll also be sharing my GPT image 2 image generation skill with you there. In fact, I’ll be honest with you, the additional membersonly code bases that you’re going to get inside of Agenda Horizon is just a trick to get you inside the course. And by trick, I mean the real value is in the lesson. So let me make this super clear. There’s been confusion about this in the past. There are two courses here. Tactical Agentic Coding and Agentic Horizon. If
[00:29:00] you want the full verifier agent, you need to get both of these. You need to get Agentic Horizon. If you think it’s too much, if you think it’s too expensive, it’s probably not for you. Okay? And that’s okay. All right? Don’t complain in my comment section. If it’s not for you, it’s not for you. And on that note, there’s a full no questions asked 30-day refund. If this is not for you, if you don’t get value, you can get a refund by lesson 4 of tactical agent coding. I don’t want you in here if you don’t want to be in here, okay? This is not a ploy or some scam. This is serious agentic engineering. I’ve been with the genera industry since the beginning and I’m going to be here until it’s all over. And so eight lessons in the first course and then six lessons in the second course. We talk about big hitting ideas, agentic prompt engineering, building custom agents. We talk about multi-agent orchestration, agent experts, and then the codebase singularity. The moment you want to strive toward where your agents can run your codebase better than you can. Here’s what the course looks like. Let me just go ahead and show you this. Once you sign up, you’ll get access to all the lessons like this tactical agenda coding on the top, agenda horizon on the bottom, and then you’ll be able to click into member assets. And here you’re
[00:30:00] going to have access to premium multi- aent orchestration systems that we’ve been working on some on the channel and some that you haven’t seen. So these are all here. I’m going to be adding the verifier agent as a fourth member onlyly asset for you here. And once again, you’ll want both courses to gain access to that. Enough pitching. Again, I’m going to have a basic version of this on my GitHub repo for you to check out. The core ideas are going to be there for you as well. All right, so I hope this all makes sense. This is just one more reason to own your agent harness. Okay, the number of custom agents, specifically the number of custom agent harnesses I’m building in 2026 is growing very, very rapidly. I mean, it’s catching up with the number of skills prompts and custom agents I’m building, which is a crazy thing to say. It’s because I’m getting full control over the experience that I’m having with my agents. And this comes down to once again two things. Trust and scale. I said it at the end of 2025. 2026 is the year of trust. Do you trust your agents to do what you asked them to? And then
[00:31:00] how much at what scale? That’s what we’re dialed into here. This is just one of many ways you can scale your compute to scale your impact. The verifier agent is a very unique agent, though. Don’t ignore this. Don’t skip over this. Dial into this. Really think through this with your agents. The verifier sits at a very important middle ground between trust and scale. Most agents increase trust or scale, not both. The verifier does both by validating the claims that your primary agent has done in an atomic way and then helping you improve it with every prompt it writes. What could it not verify? What feedback does it need? What does it need from you? This feedback forces you out the loop. It forces you to template your engineering into the fabric of your agent harness. Where are we going on the channel? What’s next? As you can tell, it’s these two things. The winning formula is often much more simple and less hype-filled than you realize. All the top performers do two or three things over and over and over and over. We’re increasing the
[00:32:00] trust we have in our system and we’re scaling the out of our agents. That’s it. That’s what we’re going to do on this channel for the rest of the year. If that interests you, like, subscribe. To be super concrete, there is a big hole in everyone’s agent right now. And that hole is the bash tool. This is the most dangerous tool every engineer is running right now. And it is going to cause massive cataclysmic damage at some point to you. So, we’re going to get ahead of that. Again, make sure you like, subscribe so you don’t miss that video. We’re going to be talking about agentic security. And I’m not talking about prompt injection. I’m talking about damage from within, damage from systems that you think you trust, but you don’t. All right? And again, this focuses on our trust theme. You know where to find me every single week. Stay focused and keep building.