{
  "video_id": "RpUTF_U4kiw",
  "channel_slug": "indydevdan",
  "channel_handle": "indydevdan",
  "title": "Claude Code Multi-Agent Orchestration with Opus 4.6, Tmux and Agent Sandboxes",
  "duration_seconds": 1443.0,
  "url": "https://www.youtube.com/watch?v=RpUTF_U4kiw",
  "upload_date": "",
  "transcript": "What's up engineers? Andy DevDan here.\nWe've got a couple mass releases to\ncover. Of course, there is the brand new\nClaude Opus 4.6. It's a fantastic model.\nWhat else is there to say? It's beating\nall the benchmarks. You've already\nheard, you've already seen this. This is\nnot what I want to focus on here. The\nreal big idea I want to cover with you\ntoday is multi-agent orchestration. The\ngame on the field is changing. It's no\nlonger about what the models allow us to\ndo. As of Sonic 4.5, these models can do\nmuch more than you and I give them\ncredit for, than you and I really know\nhow to unlock. The true constraint of\nagentic engineering now is twofold. It's\nthe tools we have available and it's you\nand I. It is our capabilities. It's our\nability to prompt engineer and context\nengineer the outcomes we're looking for\nand build them into reusable systems, to\nbuild them into powerful agentic layers\nthat you and I can wield. The true\nlimitation is you and I. So, let's take\nanother stab at improving what we can\ndo. Front ends, back ends, scripts, it's\ntoo simple for these models. So, what I\nhave here is eight unique applications\nthat I had Claude Opus 4.6 create. I\ntouched none of these, by the way. These\nwere all one-shotted. I like to use E2B,\nuse whatever you want. So, agent\nsandboxes are very powerful, but once\nagain, this is not exactly what I want\nto focus on here. We're going to use\nagent sandboxes as a playground to\nunderstand and to really dive into two\nkey big ideas: multi-agent orchestration\nand multi-agent observability. Once you\nput these two pieces together, you can\ndo much more with your powerful Claude\nCode Opus 4.6 agent.\n[music]\nSo, first things first, we're going to\ncrack open the terminal. If we create a\nnew Claude Code instance on our\nmulti-agent observability, you'll see\nthat we have a new agent joining the\nsession. And we have that session start\nhook captured. We have a rocket and\nwe've officially kick off a new session.\nBut, before we touch our new multi-agent\norchestration capabilities, we need to\nboot up Cloud Code in a different way.\nClose this, and you'll see we got that\nsession end event captured here. And\ninstead of opening this up in a classic\nterminal, we're going to use tmux. And\nso, this is going to give us some\npowerful capabilities, you'll see in a\nsecond. The next thing we're going to do\nis, I just want to make this super\nclear. I'm going to type which and then\ncldyo, so you can see this exact command\nthat I'm running. We're going to export\nthe new Cloud Code experimental agent\nteams feature. Set that to one, we're\nenabling that feature. So, now we're\nrunning Cloud Code inside of a tmux\nsession. You can see we kicked off a\nbrand new agent, and this is where\nthings get interesting. If I type ls,\nthese are the agent sandbox directories\nthat you saw here. We're going to have\nour agents investigate and break down\nhow we can set up these applications.\nSo, this is going to be our first agent\nteam. Build a new agent team for each\ncode base in this directory. Have an\nagent summarize and how to set it up.\nWhat you're going to see here is really\nextraordinary. You can see all of our\nevents getting captured. Observability\nis really important for knowing what you\ncan really do with your tool. You can\nsee here, we're going to start streaming\nin all of our agent events. Let me make\nsure that this is stuck to the bottom\nhere. The first thing our agent does is,\nit creates a task list. We covered this\nin our previous video. What happens next\nis extraordinary. So, we're in tmux, and\nso tmux has panes. Our agent is now\nopening up brand new panes for each\nsub-agent that it wants to run. All\nright, so I'm going to go full screen\nhere, so that we can really take a look\nat this, and I'm going to downsize this\na little bit. can see all eight agents\nthat we kicked off here, okay? So, on\nthe left, our primary agent set up the\ntask list, created a team, and then it\nassigned a task to each member of the\nteam. And you can see our status lines\ngiving us the agent, looks like we have\nHaiku agents. You can see our context\nwindow, and our agents are going to\nfigure out how to run and summarize each\ncode base, right? And so, if we scroll\nback here in our agent observability,\nyou can see a lot of work happening. Our\nHaiku agents are running all the tools\nthey need to accomplish the work and we\ncan dial into an individual agent here\nif we click this. You can see this is\nall the tool calls for one of our\nagents. Looks like this is our primary\nagent here, right? Opus 4.6. You know,\nyou can see here a lot of work is\nhappening here, guys, right? 160 tool\ncalls within just a minute time span,\nokay? We are scaling our compute to\nscale our impact, all right? If we hop\nback over here, you can see all the\npanes are gone now. What happened? All\nof our agents finished, right? They\nfinished their work, so we can go ahead\nand get out of full screen mode and it's\njust our primary agent running now. Uh\nwe can go ahead and get rid of their\nswim lane here. And this is a really\npowerful capability of multi-agent\norchestration. You want to spin up\nspecialized agents that do one thing\nextraordinarily well, right? They focus\non one task and then they finish. So,\nour primary agent now is just putting\ntogether a summary of the work done by\nthe eight agents and, you know, take a\nlook at the context window here. We've\nonly used 31%. So, that means that all\nof our other agents, they explored eight\ndifferent code bases and and to be super\nclear here, guys, these are not just\nfront ends. These are full stack\napplications, okay? Every single one of\nthese are full stack applications. We\ncan fully interact with these and, you\nknow, these are fully built out. They\nwere one-shotted by Opus. Very powerful\ncapabilities here and none of this\nmatters if you can't first trigger these\nfeatures and prompt your primary agent\nto control these powerful workflows and\nif you have no idea what's going on\nunderneath the hood, right? This is\nwhere vibe coders fall apart. They don't\nactually know what's going on. And so,\nthe engineers, the builders, and even\nthe vibe coders that know what's going\non underneath the hood can do so much\nmore. This whole idea that uh engineers\nare going to be replaced by this\ntechnology to me is absurd. And it's\nbecause engineers are the best\npositioned to use agentic technology.\nSo, you can see here that um if I hit\ncontrol B and left bracket, I'm in\nscroll mode now. The annoying thing\nabout tmux is that it does change the\ncontrols a little bit. I'm in control\nmode and if I just scroll up, you can\nsee we have summaries for every single\nagent sandbox application that's stored\nin my local directory, okay? So, you can\nsee here, nice summary of all eight, and\nthe primary agent knows how to spin them\nup. Let's push our multi-agent\ncapabilities further.\n[music]\nHere's what we're going to do now. So,\nI'm going to get out of this mode. I'm\njust going to hit escape, and we're back\nin our primary window here. Let's go\nahead and actually spin up new agent\nsandbox instances with each one of these\napplications, all right? And we'll do it\nin two teams. We'll have a team of four\nmount the first four applications, all\nright? Because we have eight unique\napplications here, if we run ls. And\nthen we'll have a team of four doing the\nlast set of applications, okay? Let's\nprompt engineer this properly, all\nright? We're going to start with the\nmost important piece, build a new agent\nteam. So, we're triggering right, these\nare information-dense keywords that tell\nthe agent we want a specific set of\ntools to execute, all right? And then\nI'll say using agent sandboxes, so this\nis my agent sandbox skill, and backslash\ncommand. This is a special skill that I\nhave to do wacky stuff like this, use\nthe backslash reboot and mount one\nthrough four in their own agent sandbox.\nBe sure to set up every agent. So, part\nof my workflow when I'm doing rapid\nprototyping, what I like to do is just\nbuild it all in an agent sandbox, like A\nto B, as you saw here, right? This is an\nagent sandbox. And then, what I'll do\nis, if I like one of the versions, I'll\ncopy it down locally, and I have prompts\nfor that, of course. So, what we're\ngoing to do now is basically rehost\nthese applications with a specialized\nagent team. So, I'll fire this off, and\nyou can see here right away, our\nobservability system picked up on that\nnew user prompt submit event, and now\nthings are going to get awesome again.\n[laughter]\nOur agent is going to first run the\nagent sandbox skill, and it's going to\nrun the backslash command skill, so that\nit understands what backslash reboot\ndoes. And then it's going to actually\nkick off the reboot for every one of\nthese directories. And so, our agent has\nfigured out all of our tooling, it ran\nour agent sandbox skill, it ran our\nbackslash command skill, and now it's\ncreating that task list again. And so,\nthe task list is the centralized hub.\nThis is where everything gets kicked off\nfrom. There we go. Okay. So, very cool.\nNow, we're kicking off our agent team.\nYou can see we have that new pane. So,\nwe have our primary agent kicking off\nthe first agent, and this agent is then\ngoing to run that skill. So, every\nsingle agent has its own context window,\nright? So, they all need to run the\nskill, they all need to run the setup\ncommands. You can see it's running\nthrough the E2B setup process, and these\nare all Opus 4.6 agents. But, you can\nsee here, all of our agents are getting\nkicked off again, and I'll just go ahead\nand and, you know, downsize this a\nlittle bit and go full screen here, so\nwe can get a good picture of what's\ngoing on, right? All four Opus agents\nare running in parallel. They're each\ngoing to reboot the application. You\nknow, what we saw here in the beginning,\nbasically we're going to recreate these\nagent sandbox instances with this new\nmulti-agent orchestration tool. And so,\nif we hop back to our agent [laughter]\nobservability system, once again, you\ncan see tons and tons of work happening,\nright? If we dial into one of these swim\nlanes, we can get a better understanding\nof the tools and the impact that every\nagent is creating. And, you know, really\nimportantly here, if we search for our\nbrand new tools, you can see we have\nthese new task list tools. Uh we should\nsee some If we scroll up here, you'll\nsee, right, we have task update, and we\nhave task, right? So, this is kicking\noff the generalized agent, and you can\nsee here, this is the exact command that\nwas run to kick off a sub-agent,\nsub-agent that is executing right here.\nAnd, the great part about running this\nin tmux is, of course, the panes. We can\ncontinue to zoom out a little bit, so\nyou can get a better view here. Every\none of our agents has their own context\nwindow, their own model, their own\nsession ID, and you can see they all\nhave their own unique name here as well,\nright? SBX agent, sandbox agent 1 2 3\nand 4, right? So, this is fantastic. So,\nI'm focused in this individual window\nhere. Inside of tmux, we need to hit\ncontrol B and then left to change our\ncursor position. What I want to do here\nis get the the names of the other\nsandboxes that we didn't kick off. So,\nI'm just going to ask the primary agent\nbecause it's actually not doing anything\nright now. The primary agent is sitting\nwaiting for events to come back. List\nsandbox directories we didn't kick off.\nAnd you can see here sandbox agent\nnumber four has completed its setup.\nIt's pinged a command back to our\nprimary orchestrator agent. So, what I'm\ngoing to do here is while this is\nrunning, I'm going to go ahead and open\nup a new terminal and kick these off.\nLet's see if I got a clean paste out of\nthat. We're not going to kick this off\nin our flat window, right? We need tmux\nto get that visualization, to get those\nmultiple panes. So, I'm going to run\ntmux once again, then I'll boot up\nClaude code, and then I'll effectively\nrun that exact same prompt. Then what I\nwant to do is get the names of those\nagents that did not run. So, I'll copy\nthis. And I'm doing a little bit of\ncorrection here on another screen. I'm\nhaving trouble copying this, and so I'm\nI'm just going to ask my agent to do\nthis for me. Uh copy the four sandbox\ndirectories to my clipboard. Should do a\nPB copy. There you go. And then I'll\njust paste this. So, only post these\nfour. There we go. And I'll kick that\noff. Now, we're going to get the\nremaining sandboxes kicked up, and\n[laughter]\nI'm sure you may have noticed this, but\nif I go into scroll mode here and scroll\nto the top, I have run out of my API\nusage for today on my Claude Max plan.\nSo, I'm using API billing, and uh yeah,\nthis is going to burn a hole in my\nwallet. Drop a like, drop a comment\n[laughter]\nuh so that the YouTube algorithm can can\npay for some of this API usage. But,\nI'll hit escape, and I'll go ahead and\nlet this second agent start kicking off\nthis workflow. And so, we're going to\nsee the same thing. And if we look at\nour agent observability, we can see\neverything. We can understand everything\nthat our agents are doing top-to-bottom.\nAnd if we go ahead and look over here,\nyou can see that we have one more agent\nfinishing up its work, right? Sandbox\nagent number two is the last one still\nin progress. So, this is a very powerful\nfeature. We can now observe our agents\nin a more improved way just with tmux,\njust by seeing these new panes open up\nas our primary or orchestrator agent\nstarts to set up and scale up this work.\nThen, whenever we need to, we can just\nscale up and create a brand new team.\nSo, here's that second team of agents\ndoing a whole different set of work in a\nbrand new window. All right, so you can\nsee that same process. Go full screen,\nminimize this a little bit so you can\nget a better view. We have two teams of\nagents working and we have an\nobservability system to trace the whole\nthing. And so, whenever we want to, we\ncan just come in here. It's got all four\nagents running. It's going to mount\nthese applications. We're going to\ncreate a new E2B agent sandbox, upload\nthe app code base, install, get\neverything set up as if it's a brand new\nenvironment. So, we're combining several\nreally, really powerful ideas here that\nwe've been talking about on the channel\nweek after week. We have multi-agent\nobservability, so we know what's going\non, so we know how to improve and\nunderstand our systems. We have spaces\nto place our agents so that they can do\nwhatever they need to to accomplish\ntheir work without jeopardizing our\nlocal machine. And then, of course, we\nhave the new multi-agent orchestration\ncapabilities coming out of Cloud Code on\ntop of a brand new ultra-powerful model\nthat can run long-duration tasks. All\nright, so we're talking about long\nthreads, we're talking about big\nthreads, and we're handing off more and\nmore work to our agents. That is the\ntheme here. How can you prompt engineer\nand how can you context engineer with\ngreat powerful models to get more\nengineering work done than ever with\nconfidence, all right? We want to be\nbuilding systems of trust with our\nagents. Now, scaling up the model is\nalways going to help with this, but this\nis not something we're really in control\nof. Whenever the new model ships,\nwhatever it costs, we are just subjects\nto that. But, what we can control is the\ngreat tooling we use alongside these\nthree powerful capabilities. And so,\nthat's one of the big ideas I wanted to\nshare with you here today. Multi-agent\norchestration, multi-agent\nobservability, so you can dial in to\nanything your agents are doing. And\nthen, of course, we have agent\nsandboxes, a secure location to place\nwhatever you want to have your agents do\nat scale, all right? And so, we have two\nteams of four. To be clear, the agents\nare running on my device, but the work\nthey're doing is operating off the\ndevice. They're using their local\nagentic capabilities, their local\nskills, and then they are creating and\noperating inside their own agent\nsandboxes. Okay, so our first team is\nall set up. And if we go into scroll\nmode here, control B, left bracket, and\nwe do some scrolling, we should be able\nto see everything set up live. So, let's\ngo ahead and open these up. I'll take\nthese existing windows, these existing\nsandboxes, I'll just move them up onto\nmy monitor here, and then we should see\nthem open up in this browser window\nhere. We'll take a look at the the brand\nnew tools that allow and enable these\nworkflows in just a second. But, let's\ngo ahead and just get these opened up,\nso we can see how our agents have done.\nI'll say, open in Chrome. You can see\nthese sandboxes are going to be alive\nfor 12 hours, all right? And it looks\nlike they did open up in this other\nwindow, super annoying, that's fine. I\nwill copy these four newest ones, drag\nthem in. Here we go. So, here's our\nagentic support. It looks like we're\nmissing some data here, and looks like\nwe're missing data here. Let's see if we\ngot our gallery. Nice. Okay, so we did\nget some nice information there, and we\nhave our data here. All right, so very\ncool. And so, we can continue to prompt\nto resolve these issues. I'm going to go\nahead and just give this a shot, and\nI'll say, data is missing from this, and\nlet's go ahead and go here as well.\nBasically, our sandboxes were rebooted,\nbut it didn't reboot with the exact same\ndata, or with any data for those two\napplications. So, we're going to go\nahead and have these agents do this\nwork, and what I'll do here is I'm going\nto stop this, cuz the primary agent\nstarted working, right? You saw that.\nThe primary agent's trying to take over.\nI'll say, spin up a new agent team to do\nthis work for you. Give them all the\ncontext they need, skills, Sandbox\nbackslash command. And so I'm just being\nsuper verbose there with my prompt\nengineering with that agent. You can see\nhere our second team finished. So let's\nsee how this team did. Yeah, open all\nfour URLs in Chrome. Okay. So kick these\noff. All right, so we have these opened\nup. Let's go ahead and get these dragged\nand dropped over here. Okay. We have our\nmission briefings dashboard. We have our\nportfolio application so we can track\nour forecast for our portfolio. We have\na recipe app and we have a ad dashboard\nto see how our ads are performing. Nice.\nSo we got all the data for these. So all\nof these four worked. Love to see that.\nAnd the two issues we had with these\ncode bases are getting resolved here\nwith our two agent agent team. So this\nis an iterative process as well. We're\ngoing to want to be firing off ad hoc\nagent teams to perform specific sets of\nwork. In our previous video where we\ntalked about the task list feature, uh\nlet me go ahead and see if I have that\ndiagram pulled up here. Yeah, so in our\nprevious video we talked about the\nCloudCode task system where you prompt\nyour primary agent and your primary\nagent creates a task list that multiple\nagents, basically an agent team,\noperates on. This is a very powerful\nfeature that is taken to the next step\nwith the multi-agent orchestration\nfeature that you can now tap into. All\nright. But the idea here is really,\nreally important. As you're building out\nreal features, as you're scaling up the\nwork you can do with your agents, it's\nnot just about a single agent or even a\ncouple agents or even parallel agents.\nYou want to be building teams that\ncommunicate together, that are all\ndriven toward accomplishing one specific\ngoal. Think about building out a\nfeature. That's way too much work,\nespecially as you enter real, legitimate\nproduction code bases. Building out a\nfull feature requires organization. It\nrequires communication, right? And so\nthis new agent orchestration feature\nallows us to really tap into that brand\nnew system, that way of thinking. All\nright. And And this is what this feature\nlooks like end to end. We're going to\ncreate a team. We're going to uh create\ntasks which spawn agents. They all work\nin parallel, and then they shut down,\nand then we delete the team. And we'll\nlook at the tools here in just a second.\nBut, a really important aspect of this\nis that when the work is done, you want\nto delete the agents. This forces a good\npattern of context engineering where you\nreset the context and start over. So,\nyou can see here's the agent shutdown\nprocess happening from our primary\nagent. These are shutting down, the\ntasks are gone, the panes are now gone.\nAnd so, apparently, this has fixed the\nissue. You can see here DB wasn't\ntagged. We restarted uh both processes\nwere down, so we should be good on these\ntwo uh applications. Let's refresh.\nStill not good there, that's too bad.\nAnd let's refresh here. It looks like\nthis one did load its data here. Let me\nsee if that actually worked. Loading\npull requests. And still nothing here.\nAll right, so we have issues here. I\ndon't really care about these. You get\nthe point here, right? We got six out of\neight sandbox environments spun up in\nbrand new systems. And you know, just to\nbe super clear and transparent, here are\nthe new environments and the new URLs.\nHere are the old ones. I just want to\nshow that I have these in the These are\nactually different URLs. All right. So,\nthese are all unique agent sandboxes.\nAnd we can be even clearer about this. I\nhave a bunch of these running right now.\nIf I go to a terminal here, and I say um\nI pass in this skill, we should spin up\na new agent for this. We always want to\nbe operating on fresh instances. We\ndon't need tmux for this. It's going to\nbe a single cloud code instance. And I\njust want to show you all the current\nrunning agent sandboxes. So, I'll kick\nthis off. I'll fire off my agent sandbox\nskill. And I'll just say list all\nrunning sandboxes. And so, we should\nsee, I don't know, some 20 or 30\nsandboxes here. You can see it's\nvalidating my EDB key. And then um let's\ngo ahead and see. There we go. Working\nthrough some issues. And of course,\nthat's the sandbox list. You can see we\nhave 24 sandboxes. Let's go ahead and\nget that list. Just to make it super\nclear here how much compute we're\nrunning in parallel. There we go. Looks\nlike that was the command. It's getting\nthe information for each sandbox\nenvironment. I'll link a previous video\nwhere we talked about how you can set\nthis up and how this really works in the\ndescription for you if you're\ninterested. I think agent sandboxes are\nand will be a big, big, big trend as we\nscale up what our agents can do on our\nbehalf. You're seeing this with the\nwhole Mac mini craze. As you can see in\nthe background, I have a Mac mini. I've\nhad this thing for a while and was, you\nknow, decent amount ahead of that trend\nand having my agents run in its own\ndedicated environment. As you can\nimagine, I have multiple sandbox\nenvironments. One like E2B operating\npurely in the cloud and then for more\npersonal workflow where, you know,\nprivacy is important, you can have\nagents run, of course, on your own local\ndevices like everyone is doing with\nMultibot or Cloudbot or whatever it's\ncalled now. But you can see here, you\nknow, I have 24 agent sandboxes running\nand, you know, you can see I have\nduplicates of a lot of these things that\nwe've been looking at here, right? So I\nhave multiple versions of this. Just\nwanted to make this super clear. I have\na skill, I have an agent that operates\nand can manage all of these agent\nsandboxes at scale. This is going to be\nreally important moving forward. When\nyou're scaling your compute to scale\nyour impact, which is the big theme of\neverything we're looking at right now.\nAll right? Here we looked at how to spin\nup teams of agents, okay? And it all\ncomes back to things we talk about on\nthe channel all the time. All these\nfantastic new tools coming out of the\nCloud Code team, all these new\ncapabilities. There is a lot of\nengineering work they put into this, you\nknow, big shout out to the Cloud Code\nteam, but I do want to say that\nunderneath all of it is a concept we\nalways discuss. It's the core four\ncontext model prompt tools. Everything\nboils down to that, all right?\nEverything is the core four. Okay? And\njust quickly, you know, we saw all this\nwork happen. We saw our multi-agent\nsystem track all of this and you can see\nall of these new task tools. Team\ndelete, team create. We have these new\ntask tools. Task create, task get. So\nwhat are all the new available tools?\nLet's go and take a look at this. We\nhave kind of three categories of tools\nthat this, you know, new multi-agent\norchestration system gives us. Team\nmanagement, task management, and\ncommunications. Team create task, team\ndelete task has been around for a long\ntime. This is how you kick off an agent\nin parallel, but then we have all the\nnew task management tools, right? Task\ncreate, task list, task get, task\nupdate. But the most important one of\nall probably is the send message. This\nis how the agents were communicating and\nafter they communicate, after they do\nall the work as we described here in\nthis workflow, right? This is the kind\nof the multi-agent orchestration\nworkflow built out with this new tool.\nIt's it's this, right? Create the team,\ncreate the tasks, spawn the agents, work\nin parallel, shut them all down, delete\nthe team. This is the full workflow of\nthe brand new Claude multi-agent\ncapabilities. So, with every new\ncapability, with every new feature\ncoming out of Claude code, coming out of\nall these agentic coding tools, with\nevery new release of the new model, the\nquestion is always the same for you and\nI, the engineer with our boots on the\nground working with this technology\nevery single day. How can we understand\nthe capabilities available to us to\naccelerate our engineering work. Models\nwill improve, tools will change, and\nthat means that you and I will always be\nthe limitation. It's about what you and\nI can do. So, with every feature\nrelease, make sure you're digging in,\nmake sure you're understanding what's\navailable to you so that you know what\nyou can do. Every engineer is limited by\ntheir tools and their knowledge of their\ntool. So, that's why multi-agent\nobservability is super key. Throughout\nany point in this workflow, we can jump\nin here and we can investigate and see\nthe communication, see the tasks between\nour agents that we kicked off. We see\nall the events. I'm going to leave my\nmulti-agent observability updated to\nsupport all these new tools, link in the\ndescription for you, and I'll also link\na previous video and my agent sandbox\nskill for you to play with. Again, link\nin the description for you if you're\ninterested in taking your agentic coding\nto the next level, check out tactical\nagentic coding. This is my take on how\nyou can accelerate far past AI coding\nand vibe coding with advanced agentic\nengineering so powerful your code base\nruns itself. We're seeing multi-agent\norchestration come out of the Cloud Code\nteam. We have had this documented and\ncovered inside of this course, inside of\nAgentic Horizons specifically. We have\nhad working versions of multi-agent\norchestration for months now. This is\nall here. You know, a lot of the ideas\nwe talk about on the channel are taken\nto the next level inside this course. If\nyou're interested, check this out. I\nknow a lot of engineers on the channel\nhave already checked out this course and\nyou know, to be super clear, there are\nthousands of engineers that have taken\nthis and then have gotten great value\nout of this. So, I'll leave this linked\nin the description if you're interested\nas well. We're going to be covering\nmulti-agent orchestration a lot as we\nmove forward. It's going to be a big\ntrend because it allows us to do what we\nalways do on this channel, scale our\ncompute to scale our impact. Thanks so\nmuch for sticking around. You know where\nto find me every single Monday. Stay\nfocused and keep building.",
  "transcript_chars": 27750,
  "ingested_at": "2026-05-15T04:46:42.761315+00:00",
  "source": "channel",
  "yt_meta": {
    "view_count": 52388,
    "like_count": 1433,
    "channel_id": "UC_x36zCEGilGpB1m-V4gmjg",
    "categories": [
      "Science & Technology"
    ],
    "tags": []
  }
}