As engineers, there's just one idea you and I need to win in the age of agents. Scale your compute to scale your impact. The goal is clear, but the path is less clear. The big open question the best engineers are asking is how exactly should you orchestrate your agents for maximum impact? And there's no shortage of options. Boris and Peter are saying loop engineering is the future and prompt engineering is already dead. I completely disagree with this. There's the Ralph style to-do list to keep your agents focus on a massive list of work. Fable is going to love Ralph. Then there's classical sub aent delegation and many many more patterns. I've been engineering for over 15 years and building with agents since it was first possible. And we have to call out the fact that these AI labs have massive incentives to keep you and I spending tokens, token maxing, when the truth is there's a dozen different agentic
[00:01:00] patterns you can use to ship with agents. One of my favorite patterns is three tier agent orchestration. Orchestrators prompt the leads. Leads prompt the specialized agent experts. But every multi- aent approach has similar problems. The big three being how do you start, interact, and improve your growing fleet of agents. If you're vibe coding or token maxing, this doesn't matter at all. You can spin up 20 agents in a loop and look the other way. On this channel, we don't vibe code. We agentic engineer because an agent you can't monitor is an agent you can't improve. I have three multi- aent orchestration problems I'm going to solve and I'm looking at CMUX as a potential solution to this problem. As we work through the feature set of CMUX, I want to share with you how I'm continuing to learn new tools and technology with agents. If these ideas interest you, smash the like button, lock in, and let's improve our agent
[00:02:02] orchestration. Whenever I sit down to learn a new tool or technology, I have a state-of-the-art agent build out a comprehensive HTML file that I can use to visually understand, study, and master new tools. So, that's how we're going to learn CMOX right now. Let's start with the problem. What problems are we going to solve? I don't start with tools. Problems come first, tools come second. I know I'm late to the Semox game, but I don't really care outside of experimentation. If I don't need a tool, I don't pick it up until I have a problem. First, I have three problems surrounding multi-agent orchestration that you likely have, too. Let's see if can solve three popular multi- aent orchestration problems. So, first off, no programmatic access to your agents. This is a massive problem because it means you're the bottleneck and it keeps you in the loop all the
[00:03:00] time, meaning your agents can never move at the agentic speed. The big question is, can Semuk solve this? The answer is of course yes. The core value proposition of tools like CMUX and the triedand-true T-M is this exactly. They give you agentic access to every single terminal. An agent you can't see is an agent you can't improve. This is going to be increasingly controversial. A lot of engineers are turning off their brain. They're not studying what their agents are doing. They're spinning up fleets and they're ignoring the journey, all the mistakes, all the successes, all the things that they would want to emphasize, reproduce, and cut out of their workflow is completely ignored. This is one of the key differences between vibe coding and agentic engineering. An agent you can't see is an agent you can't improve. I need to be able to see everyone of my agents. Okay? It doesn't matter if it's cloud code, pi, open code, codeex. I need to be able to see it, monitor it and understand when things are going right so I can re-emphasize that behavior in the agent via the core 4 or I need to know when
[00:04:00] things are going wrong so I can present negative rewards. Okay, so can Semox solve that problem for us? Yes, it can. We have per workspace color roll icons, identity, we have tabs, we have banners. We have everything we need to quickly jump into an agent and see it. Quick teaser here. I have semox ready to go and you can see here we have a great breakdown the kind of fundamental pieces of a tool where we can quickly see observe and therefore improve everything right we have a cloud code agent we have a codeex agent we have two pi agents running the minimax m3 and the jm 5.2 too. We'll get back to this in a second. Let's fully understand every single problem. And this is a big one. It's increasingly becoming a problem as I deploy more and more agents and set up new teams to do specific sets of work extraordinarily well. If you're building custom agents, you're running into this problem, too. If you're deploying 5, 10, 20 plus agents, you have also seen this problem. Booting an agent team by hand kills the agentic speed. It just takes too much time. So, can T-book solve this? Of course, yes, it can. and it has
[00:05:00] reusable session files. But more importantly, this tool has agentic access. If a tool has agentic access, that means you can move at the agentic speed and solve problems in natural language with well- constructed prompts. Okay, so these are the problems we're going to solve. CMOX has solutions to all of them. I think the question is, do you have to use CMX or is something like T-Max going to get you all the way there as well? So, let's dial back into CMOX and understand what this tool can do and see if it can help us solve these three key problems. Agentic access, monitor to improve, and quick agentic launch for your thousandth agent run. Not your first, not your 10th, not your hundth. So, what is our agent teaching us about CMX? Let's understand the mental model that really builds the foundation of understanding CMOX and other terminal multiplexes as well. You have the window which is going to be this entire window here with control shift N. We can boot up a brand new window. And then we have
[00:06:00] our workspace. Workspaces, you know, we can boot up with command N. And this is going to give us a new workspace to set up teams of agents to set up groups of terminals to do whatever you need to do. Then we have PES. The pane is going to be the actual window. We have a pane here. We have a pane here. We have one here, here, and here. It's important to mention if we do commandt, this opens a new surface inside of this existing pane. So we have individual windows. You can separate and group your agent teams, your terminals, you can have production, you can have staging, you can have dev, we can have workspaces. So for me, I'm going to put my agent teams on the workspace level. And then inside of the workspace, you have your individual panes. So we have a pane here in my multi- aent orchestration workflow. I'm going to put my lead here. And then the workers go over on the right. So I can look at the level that I need to to get the job done while not losing the depth of visibility into the low-level worker agents. This is super key, right? Prompting in a black box in sub agents
[00:07:00] is a great place to start. Terrible place to finish, right? We can do a lot better than that with the right agentic tools. That's why we're trying to see if we can really improve our multi- aent orchestration abilities. Okay, so that's the mental model of cmox. And so how do we control it? Uh it's pretty simple. Thanks to the programmatic access, we do four things. We can send information like send key. We can then read the screen after the action has been completed. And then we can open and close surfaces and the loop repeats. Okay, so this is how you control it. We're going to walk through concrete examples of how you can use semucks in just a moment here, but here's an example of the API, right? Send, read, close surface. You specify the surface and the exact text you want to send in. Another powerful part about CMX, we can build an orchestration agent around pushing and pulling specific events from the CMX life cycle and therefore our agents life cycle. Okay, so there's a lot of customizability here. When I sit down to learn a tool, I
[00:08:00] use agents the entire time. Learning is the killer use case for agents. Coding comes next. in these HTML rich guides. I want an incremental tier-based explanation of how I can best use these tools to solve my specific use case. And that's exactly what my agent has done here. A lot of really smart engineers are turning their brains off. I want to push back against that. We want to rise with the ceiling of agentic engineering, not the floor of vibe coding. Okay. So, um let's run this, right? Let's understand CMOX at a deeper level. You see here, this tool can get very, very complex. It can help you orchestrate and do a lot of work. They even have like a mobile app here. You can access browsers. There's a lot of cool stuff you can do with this tool. We're not going to cover all that. We're going to focus on the problems we need to have solved. Whenever I'm learning a new tool, I like to start super simple, understand the foundations of the tool, and then move to more and more complex scenarios. All right, so let's go ahead and start from scratch here. I'm going to open up a terminal, boot up a cloud code opus window here. If you're working in the future, you have access to Fable. I am jealous of you right now. Can't
[00:09:00] wait for that model to be turned back online. Although, it looks like there's going to be massive delays with getting that back online. So I have a semox skill that was built that just makes the agent aware of the tool. Open a workspace in a fresh temp directory. Create 63A files lsla read the output back and then continue from there. All right. So we're just having our orchestrator agent operate on cmox windows. So let's see how this looks and I'll hold them both open here at the same time. So you can see here our existing agent team window is open. My agent is operating this window. Okay. So we have a new workspace here. Inside the window, we have a pane with a single tab. You can see there's that ls. You know, I'm not typing anything here. This my agent operating a workspace to be clear. This is bigger than a terminal. It's done. Right? So, we had an ls all these mock files it created. Right? If we close this, do ls ourselves, we can see them exactly. The great part about tools like cmox and t-mox is that you can jump in whenever you need to. Right? The agent stopping black boxes when you can actually touch and jump in to the terminal window. Aentic access here is
[00:10:00] super super important. very simple, great place to start when you're learning a new tool. Just show a basic use case of the app. So, let's split into a grid. I want to see a grid here. So, I'm going to close our throwaway 60 and we'll work our way up to, you know, a full multi- aent orchestration example here. We're just setting the groundwork. Always start with the fundamentals. So, this is going to open a 2x two grid in a new workspace. There we go. And in each workspace, it's going to run specific commands. On the right here, it's just an empty terminal. Here we have the date being updated per second. And then we have a tick in the bottom left. And then in the top left, we have h top running. Each one of these clearly documented in the workspace name. You can see how this can be very very powerful for agents. Right? So, not only is this tool helping us move at the agentic speed, it's giving us access to quick start commands to run repeat workflows. All right? So, boot up your front end, boot up your back end, boot up all your services, boot up your database. Let's keep pushing to see how
[00:11:00] this tool is differentiated from a tool like T-Mox because T-Mox is the OG of this. Let's go and tidy up. Let's have our agent clean everything up. Take the dash workspace, rename it, flash it, and then start closing it. Okay, so this is where we start pushing into the value prop of CMX. It can control the PES and the windows in a very, very precise way. There's the flash. It updated the name to retired. So we have live updates happening at any point in time that we can agentically program. We can prompt engineer into the system to really control the experience of agentic engineering. And that's really where this all goes, right? The ultimate user interface for agentic engineering, the DX for agentic engineering, it is not set in stone yet. As much as everyone's talking about loop engineering and building these new DXs, there are no winners yet. Okay? only experimenters, only researchers, only those pushing what they can do with agents. So, keep looking for the optimal developer experience for your work, for your agent, so on and so forth. Right? And
[00:12:00] that's what we're doing here. We're just understanding the state space of the available agentic tools. Okay? And as you'll notice here, building blocks, extensibility, adaptability, pluggability is a key part of great agentic technology, right? which is why I'm drawn to CMOX in the first place. Great. Agentic access renamed Flash. Close the whole workspace. Great, you get the picture. Let's get more complex here. Let's boot up Cloud Code and the PI coding agent side by side. We're going to do this in a brand new workspace. That's the mode I like to work in here with CMU. So far, I'm getting into this nice pattern of creating new workspaces, not Windows. Two columns here side by side. And one is PI and one is Claude. And so, another great piece about this, you can orchestrate any agent coding tool you want to. If you're a cloud code guy, scale up your cloud codes. If you're a Codeex fan, scale those up. If you're an open code scrub, go for that. Just kidding. Just kidding. If you're a PI coding agent, elite agentic engineer plugging and playing with your own custom agent harnesses, then you'll go for that, right? Opus 4.8, one of the
[00:13:00] best orchestrator models in the game until Fable supersedes it. You can see here we are orchestrating multiple coding agents with the orchestrator agent. Okay, very, very powerful stuff. I'm using IPI for my PI coding agent. This is my customized PI coding agent with several different extensions built into it. This a specialized developer experience as an agent harness. So we've just asked a simple question here about processes versus threads and they both answered, right? So nothing special there, but the value proposition is obvious. You can boot up agents and you can prompt agents using cmox and we can continue to scale this. Okay, so let's do exactly that. Let's start orchestrating fleets of agents. Okay, so let's do a 2x2 fleet. And a really important piece here that you'll also notice is that these agents have completed. They then send a notification to this top window. Okay? So, say you're working over here getting things done on another branch of work, another set of work. CMU is going to notify you when this set of agents or single agent if you want to do one workspace per agent.
[00:14:01] It'll let you know when that work is done. Okay. But here we go. We have a new fleet. This is our security fleet. Send up four coding agents. Cloud Code, Codeex, Pi with Minamax and GLM. Create a fleet. List the top three security vulnerabilities you can find in this repository. So this is a simple mock repository. This is a waste for these agents. Not really going to do anything. But you can see here this is a simple important idea of literally scaling your computer to scale your impact. Say you were looking for security vulnerabilities in your codebase. You can spin up one agent and have sub agents under it run. Or you could set up different agentic coding tools with their own unique advantages running different agents to run the exact same validation pattern, the exact same security checks across your codebase. Okay, this is the simplest clearest example of scaling your compute to scale your impact. The big difference here with a tool like CMX or T-Mox is that this is fully visible. Okay, so we have Minamax M3 giving a shot at this GLM 5.2 and of course the state-of-the-art
[00:15:00] models GPT 5.5 and Opus 4.8. They're all applying their opinions, their perspective, their expertise, their specific model advantage against this problem of checking for security vulnerabilities, a big topic right now in the age of agents. One of the key pieces of this is now inside of our orchestrator because remember the way I'm looking at this tool is any point to be able to use my orchestrator to drive results in any one of my windows, any one of my workspaces and then the individual panes, but also have the ability to go into any individual agents and really just prompt out and dial into any details we need to on an agent level. Okay, so this is important. We want to be able to jump into the process at any point, understand what every agent is doing, who's got the advantage, who's running patterns we want to replicate, and who's doing stupid we don't want to do again. Okay? And that's on a agent coding tool level, all the way down to, of course, the model level. And then further on down, right?
[00:16:00] Context, model, prompt, tool, system prompt, context. So great, these are all done. And the orchestrator is reading it back out. This is now in idle mode because the orchestrator has read the response. It's read the surface, right? It knows that things are done. This is where we start getting out of what T-Max can do, right? We're working on multiple problems. We're scaling our computer scale impact and we can see everything and we can understand everything. Okay, fantastic. So, we are doing multi- aent delegation, but of course, one of the key things here is any agent can prompt any other agent. So, I'll just try to do something random here. Inside of this cloud code worker, I'll type cmox to activate the skill. Ping your other fleet co-workers. So very powerful stuff here. It's going to read the screen of each surface. I've been seeing really really great success with this three tier architecture with my agents, right? You have a top level orchestrator. You then have team leads and then the leads have workers that actually do the work. Okay, so we're replicating traditional hierarchy structures without the true cons and true problems with hierarchies,
[00:17:01] right? This is not a top- down structure. Any agent can prompt any agent. You can see that here thanks to this skill here. We're going to do a nice simple prompt coming into every single agent from inside CMX, right? So, our agents can prompt our agents. This is a flat hierarchy even though there is one orchard is at the top. And so, I like to put my team lead on the left as you'll see in a moment, but we can just drag and drop this down here or we'll move it over here. And this very quickly kind of shows you the organizational structure that you can build. Lead here, workers here. And you can build any structure you want. The point is is that the communication channel is flat. All right. So, fantastic. What else can we do with this tool? Let's scale into workspaces. Let's really push what we can do with this. So, I'm going to copy this larger prompt here. Going to have my agent do this here. We're going to showcase like the importance of organization inside the workspace. You can see here we're starting to already have a lot more organization than normal if we were just in a single terminal or if we were using a single terminal with tabs. We're getting notification events which are pretty pluggable. You can do a lot more with them than we are. You can see here, imagine you're booting up
[00:18:01] multiple teams to solve multiple problems. We have gamma, beta, alpha. We can jump into these and we can see our let me pull up the orchestrator so we can see what's going on here. Our orchestrator getting work done booting up sets of agents programmatically. Let's close our security fleet here. Okay, so we have gamma, we have beta, and we have alpha booted up. Okay, so you know, imagine any multi- aent orchestration set of teams you want. That's a key value proposition here. You have multi- aent coordination at a massive scale, right? Just an absolutely massive scale and you're in control and you have visibility into it. Okay, super super important. If you hold command, you can see all the hot keys for each workspace. This is clearly the unit that CMX sees as the most important to be navigating. It's at that workspace level. But of course, we can quickly move through all of our surfaces as well, right? So again, just expressing the idea here. You can scale agents across multiple workspaces as well. So let's look at the scenario where you
[00:19:01] need to fix a bug right away. Say production's going down. Your customers and your users are completely blocked. So you're losing money by the second. Okay. So I'm going to hit new here just to reboot everything and then paste this in here. There's a longer prompt, but we're going to have agents race toward a solution. Okay. So I'm going to close all these windows here. Say there's a production issue and you need to resolve it yesterday. This is going to be a differentiating agentic engineering pattern that you can use. It's super simple. Throw more compute at the problem. Have your agents race toward a solution. We're going to do a needle in a haystack search. In reality, this will be a hot fix. You'll need to deploy, but you can just throw a bunch of agents at a problem at the same time in parallel. You want the first available answers so you can deploy the fix back into production. Okay. So, in this scenario, we're going to boot up an eight agent race to just race toward a solution. So, there we go. All the windows popping open here. And we're going to deploy a variety of compute to get the job done. This is needle in a hay stack. Capture the flag. first agent to the goalpost
[00:20:00] wins type of task. Okay. And multi- aent orchestration lets you do this really really well. Every context model prompt, every agent coding tool is going to have their unique advantages, strengths and weaknesses. And so when you need to deploy something quickly, when you have a hot fix you need to deploy, throwing different types of intelligence at the problem is going to get you the better result pretty much every single time if you're willing to of course pay for the compute. And so you can imagine, you know, you have your red team agent race here and then you might have another set of agents in a, you know, your infrastructure agents or your deploy agents here. And then you might have your review set of agents here to at scale quickly review the issue so that you can then hand it off to your infra team of agents, right? Your deploy agents. And now we have a bunch of compute thrown at the problem. We've got Opus, we've got Sonnet. And another advantage here, you can see a couple of my PI agents didn't even fire. It looks like an environment variable setup problem. That's fine. My local agent, my local Quinn is working. All the codecs
[00:21:01] and all the Sonnet models quickly found the solution. That's done. And now this issue can be reported. And now we're waiting for that notification event for my orchestrator and needs input. There we go. Okay, so it finally triggered there. And now our orchestrator should pick this up. Let's go and see if it does pick it up cuz all the agents are complete. Maybe this is a good time for us to transition a little bit and talk about the pros and cons of this tool, right? And maybe my agents just don't don't understand the tool properly. That's fine. It could be a mistake on my part. When you're using tools like this, these new tools, tools that are just kind of appearing overnight, and I know CMX deserves more credit than that. This is a solid tool that's been around for a while. There's a whole wave of agentic tools coming. And you're always going to want to compare that against tried and true technology. So, when I sit down to solve problems and learn with agents, I'm always comparing against what else exists. For a lot of the capability we've looked at here, T-Max can do the job. The thing is that it's not going to be as customizable and aesthetic, and the developer experience, I think, with T-Max is a little harder to get right.
[00:22:02] That's what CMOX does really, really well. It's made for the modern era of building with agents programmatically on Mac devices. Okay, so yeah, probably should have mentioned that earlier. If you're on Linux, Windows, WSL, you know, you're going to need to use a tool like T-Mox. This is Mac only. The big problem with this is just maturity, right? These brand new tools have issues and it could be me. But you can see here, you know, in our red team response here, our orchestrator has done nothing. Check and understand why you stalled there, right? Because really we wanted to ping on the first completion of our tool, right? Our first completion of any window. Okay, so foreground 10 minute. Okay, very weird. So we did get a notification event. uh it just seems like our agent didn't register it. This is one of the things I need to spend more time on to make sure I'm getting right and it's just one of the things that you'll have to understand when you're building and teaching your agents how to use the tool. Something can be improved there, but the high level is still there. There are notification events you can plug your agents into to wait for responses
[00:23:00] from your agents. We're going to stand up eight agents across four workspaces, two agents in each. Give them each a two column layout. The left is the agent and the right is going to be a browser. Now, this direction is fine. CMX is, you know, trying to grow as a product, so it has inapp browsers. That's really cool. The real killer feature here is programmability. This is the most important thing. It's nice that it's lightweight. Of course, open source is super important, but customizability is what comes next. And there's a whole slew of customization you can build out into your CMX application that we're going to gloss over because these are extra features. You can change the theme and feel. You can add custom action buttons. That's all well and good. The most important thing here by far is a gentic access, right? This is a huge theme. This is one of the key pillars of agentic engineering, right? is making sure that you have a gentic access to every tool to every service to every
[00:24:00] product that you want to interact with at the speed of agents not the speed of humans. I think we can just say that right in the digital world eventually the physical world too we move very slowly now and there are advantages to moving slowly coding is not our domain anymore that is the domain of agents okay but orchestrating intelligence is our domain this is one of the five pillars of agentic engineering we've covered this in a previous video I'll link that below if you're interested here's the kind of high level of the five pillars I'm really really focusing on right now over 2026 and aentic access is number five Even your agents should have agentic access, right? You want that meta level of control. And this is all to raise the ceiling of your agentic engineering, not the floor of vibe coding. When these mythos class models come out, a lot of engineers are just going to sit. They're going to get lazy. They're going to stop thinking and just hand the wheel to the agent. On this channel, we're not going to be doing that. If you agree with that ideology, like, follow, subscribe, all that good stuff. The kind of oneliner is if a tool
[00:25:01] does not have programmatic access, I just completely ignore it. Now I don't give it another second of my time. Okay. Agentic access gives you the agentic speed. Let's see where our team is. FS delta gamma beta alpha team. Imagine these are you know the names of features the names of bug fixes the names of things you are actually building against. We have a nice browser on the side. And we have a two agent team per workspace to work on that browser. Okay. So you get the idea here, right? We have a little custom theming here to help us get back in the loop when we need to be in the loop to orchestrate our agents. So again, you know, having visual identifiers improves your developer experience, lets you focus on what matters the most and then you can just move on. The biggest risk with CMX is that this is a new relatively fastmoving tool. I'm going to be using both of these tools side by side, not so much using warp anymore, but CMX and T-Mox I'm going to be spending some time on. And that leads us to the kind of final problem. I need to be able to quickly launch agents for the thousandth time.
[00:26:01] So, let me show you really concretely how I'm using a tool like this. So, I have a just file inside of my code bases and this lets me give a really quick onetap command to boot up new agent teams. Okay, so I'll just type jfast cc. If I hit enter here, I need to pass in a feature. So, what's the focus of this agent team? Okay, so I'll type fast CC and then we'll call this SSC. Let's assume we're adding server sent events into our web server. Okay, so we'll hit enter there and this is going to pretty much instantly boot up an agent team and this is a unique agent team in the multi- aent orchestration pattern that I like. This is three tier multi- aent orchestration and it looks like this. The orchestrator here, team leads here. Every one of these is a team lead in my workspace. And so this specifically is the team lead. Right now I'm using a GLM 5.2 two and then every team lead gets access to worker agents. Okay, so here's my plan agent, here's my
[00:27:00] theoretical build agent, here's the build front end, and here's the testing agent. Might seem complex to add one additional level of agent, but it helps a lot. And I've needed a tool like CMX. T-Max wasn't cutting it for the right organizational structure. And so I'm picking up a tool like CMUX to kind of help me solve this multi- aent orchestration problem. these sets of problems. It's starting agents. It's monitoring agents so you can improve them. And then it's being able to scale your orchestration to whatever level you need to. And so, as mentioned, this is not top-down agent communication, right? Any agent can prompt any agent. I also have my specialized comsnet PI agent coding extension, but CMOX lets me push outside of the extension and have any agent decoding tool talk to any agent decoding tool. Thanks to the semox skill, birectional flat agent communication is super important while maintaining an orchestrator, a lead, and then a worker level setup. And I'll link the video where we go into multi-tiered agent orchestration. This isn't for
[00:28:01] everyone. A lot of engineers are going to look at this and say, "Why do I need this? It's slop. This isn't useful." That's fine. It just means it's not for you. Okay? As I mentioned in the beginning, there's many ways to do this. You can use the Ralph to-do list. You can use the new loop engineering patterns. And you can just use classic cloud code subbasation delegation that's fine right they have the slashworkspaces they have slashloop they have slashgoal right use whatever works for you my goal here is just to show you the optionality of what's available to you and to reemphasize a gentic access and full control over the primitives of agentic engineering right context model prompt tool once you have an agent up and running you can scale it right now I have a team here that has let's say these are each 1 million contacts each specialized, that gives me 5 million tokens of context to work with, quite literally, right? That's not an exaggeration. When you put together your agents in a way where they can all communicate, you're getting a bigger team of intelligence to work on your behalf. Okay, so um you know, what's the
[00:29:00] verdict? I like CMX. I'm going to be using this tool. It stands up to T-Mox pretty well. I'm going to be keeping my eye on any glitches or bugs with this tool, but so far, I'm a big fan. It's the scriptable service API, the agentic access that really matters with this tool. There are a bunch of other features here I didn't mention. I'm sure some CMOX hardcore users are going to be flaming me for this being so relatively simple. But the key here is it's programmable, right? That's the most important thing by far. Aentic access is a requirement for agentic engineering. And this is going to compound. Every single thing you set up here from this five item list is going to give you a compounding advantage for agentic engineering. Once again, we want to be moving up with the ceiling of agentic engineering, not the floor of vibe coding. All these ideas are big ideas we talk about and really break down in tactical agentic coding. I'll leave a link in the description for that if you're interested in paying a little bit to get a massive advantage. If you're
[00:30:00] not though, that's totally fine. I'm going leave my entire guide code base here to really break down Semox capabilities. If you made it to the end and you want to see more agentic engineering content like this, drop a like, share the video with a friend, with a co-orker, and then comment down below. How are you thinking about multi- aent orchestration? Do you have any unique experiments or tools you're running to better scale your computer to scale your impact? You know where to find me every single Monday. Stay focused and keep building.