I built a free AI coding platform that lets you create a 20 person dev team in under sixty seconds. Plus you can switch devices mid sentence, move, and control everything from your phone when you go out. You never have to slow down. I've been coding for thirty years and all that work was building up towards this moment. The end of this video, you'll be able to launch your own coding team working for you twenty four seven. Let's do it. Alright. So we're gonna jump right into cluster mode and I'm gonna demo the PopeBot. This is an AI agent a lot like OpenClaw and I just developed this new clusters feature which allows you to create a cluster of AI agents.
And just for some context, I have fully integrated the Popebot with Cloud Code and what I'm showing you here is the interactive mode. So I can type directly into Cloud Code from within the Popebot and this just uses my Anthropic subscription. Now I'm gonna show you more about the interactive mode in just a bit but first I'm gonna start with cluster mode. So I'm gonna come over to clusters and this is where you're gonna be able to manage all of your clusters. You can create new ones, you can edit, delete. I'm gonna jump into the PO Bot. It takes you directly to the console. Now this is where you're able to see all of the active containers
that are running. So if I were to
start up a few agents right now, we're gonna see those pop up right here on the screen. I just want to show you how that pops up. You can see what they're actually doing. You can see their tools that they're calling. You can see the the prompt that initiated them, the user prompt. And I will jump into
the edit mode where you can actually define these different roles. So we have the CTO role, we have the security role, we have the UI UX
and developer role. Each one has its own system prompt and a user prompt. You can define how many can run at any given time.
And you can also define the folders for that particular worker. And as well, you can define the folders for the cluster. So if you want, you can create a cluster of agents and they can talk to each other all through folders and MD files. That's probably the most simple way of doing it. Now because I have an active GitHub project, it's already got over a thousand stars and because everybody is submitting enhancements and bugs, I might as well use
GitHub as the mechanism for controlling
how we get new tasks into
the POP bot and into this specific cluster here that I've defined where we can run it through the CTO, the security expert, the user interface expert, and the developer. And So I've got these two issues here that are just test issues that will open up. One of them is simple. It's just going to update the event handler side menu. If I come over here, we're just gonna swap these two here. And then I've got another one here which is to allow multiple API keys in the settings and secrets. So if I come back to the Pope bot here, in the settings page, if we come to secrets, right now you can only set up one API key. So if I were to delete this, it would disable anything that use this key. I'd like to be able to have multiple keys and then if I disable one, it only disables the service that was using that specific key and the other ones would continue to function. Once I have decided I want to work on specific issues,
all I need to do
is come to the labels here and simply add the plan
label and that is going to trigger if I jump back to cluster mode back into the POPOP,
that's gonna trigger the CTO to now start to create a technical plan
around that feature. And then when he's done, if it's needed, he'll send it to the security expert and the UI UX designer and then finally once these two sign off, it'll go to the developer to actually be coded.
And so we'll come over to this one as well and we'll hit plan and we'll be able to just watch this as I describe different things that are happening. So again, it's gonna go CTO,
then it's gonna go to security or the UX
and then when they're done, it's gonna go to the coder and then the coder is gonna push it back into GitHub. Now the way that GitHub was able to trigger these processes is if I come back to these roles and we come down to like CTO for instance, we have these different ways of triggering
this CTO to start. So we've got the manual trigger. You saw me do that in the console. So now we applied that. Now we'll see that second CTO pop up. So jumping back into the configuration.
So we've got the manual trigger webhook and so that's what GitHub used right here. It called this endpoint here to initiate the CTO to start. You can also trigger these agents by a cron job or by file watch. So if you're using folders and they're trading files and updating files,
you can use the file watch to monitor the files to trigger the agents. So if we come back to the console here we're gonna see we have now two CTOs running one on each feature and one was more simple.
So it looks like
this one might be done and again you can see how everything was triggered, can see the original system prompt and the user prompt and once this finishes up, the CTO is gonna comment back to the issue. This will be the first one that the CTO comments back on. There it is, it just popped in. So he came up with the technical plan and because it interacts with the UI, you can see that he just tagged it with UI UX.
So now if we come back to the console, we're gonna see that the UI UX agent is now running and is going to evaluate that plan, that technical plan and provide its own feedback. And again, you can monitor the performance of the console down here. Everything is totally tracked. You can even come and check out the logs. So we've got the CTO and the developer logs all here. And then once the UI UX developer is done, he will add the label too. And I could do this manually myself. I could just hit code here. But the UI UX agent will do that on its own. So we can see that it figured everything out. It's just making a comment back to GitHub. So let's just jump back there real quick. Now we have the code label and here was the technical plan from the CTO.
Here's the UI UX
plan from the agent and now we can see the developer has started the work. Now over here we can see that the security expert is working on the API keys because that one involved security so that automatically
triggered that to work. And the UI UX agent is finishing up its review
of the keys here.
Perfect. And the security expert looks like it's finishing up his job on the assessment of that issue. And now you can see that the agents are starting to finish up and we'll go back to an empty console. And so you can see if you're using GitHub, it's very easy to manage your entire project here, all of the to dos, and then simply have the cluster of agents spin up working on as many tasks as you want all at the same time and doing the complete process and actually checking that code back into the system. So here we can see that we have the first feature that was finished
by the first agent. Here we are. We can see what they did and we can see the files that they changed swapping those menu items. Pretty easy thing to to do. But back here in the console, we're seeing the developer finishing up actually about to submit the pull request right now. It's literally creating the pull request. You can always jump in
and expand and see what the tool is actually doing. Put its review here,
finished up. If we come back to GitHub,
pull requests,
and here's the feature. All of the files changed,
Ready to roll. Alright. So now let me show you how to set up your own cluster from scratch. I'm gonna jump back to clusters here. And when you're on the clusters page, just go new cluster. And it starts off with the main definition of your cluster and there's a main system prompt. And this system prompt is distributed to any worker that is ever created.
And of course you can rename it
cluster demo.
And here I usually like to define something that's pretty global like the mission and vision and the goals and the values of the cluster. I like to give it the current time in case it needs it and we'll talk a little bit more about this as well but there's a bunch of different variables and placeholders that you're allowed to dynamically place into the system prompt to give it information about the job that's running at that moment. And then like I said before is that for every cluster, you can define different folders that will be inside that cluster that will be available to all of the workers that are working within that cluster. So if you wanna create an inbox for incoming tasks or different folders for sharing tasks or for discussions or to drop reports, you can put all of that here. So if I do inbox,
outbox,
and reports,
it's gonna create those folders and share those folders with all of the workers. Now the way I manage workers is through roles. So if I wanted to add a new role like I did in the example like the CTO,
I just click on new role and we can rename it CTO
or whatever you'd like and then we have a role system prompt. And here you can see we're using some of those variables now, some of those placeholders.
And so when this agent runs, it will replace these placeholders with whatever it is. So self role name will be CTO
and self worker ID will be the actual dynamic ID of this worker so that it can find itself around. And then we're also inserting this workspace
placeholder which is actually the directory structure
of the cluster. So you can see what we're doing here is we're giving the worker context about who it is, what specific ID it is, and also the directory structure. And then you can define the specific prompt that it will execute as soon as it boots up. You can define how many are able to run at any given time. You can define whether it's supposed to clean up the directories that it created when it's done. You can define its own folders. So if I type test
one,
test two, test three, Then we're also gonna have these folders created for us during runtime and then we can also define the different types of triggers like manual. So manual is triggered
from the console itself like I did at the beginning of the video. If I just click this, it's gonna run this CTO agent and let's actually do that here so we can see the prompt. We'll be able to see how it replaces
these values
in real time as it launches. So we'll launch the CTO. Oh, actually I have to
just enable it, turn it on first otherwise it's not gonna
boot up. Back to the console. See that CTO boot up now and if I come over to the system prompt, notice here your role CTO. See how it inserted those in real time and then it inserts that entire directory structure of the cluster in the self so that it has context of everything about the cluster and where it can put files and obviously that's also supported
by the prompts that you give it as well. And then we have the webhook trigger. This is what I was using inside of GitHub. I built a little integration inside GitHub that is calling these webhooks to trigger these agents to launch from outside of the POP bot. And then you can also set up a cron so you can set up a schedule to run every minute or every hour or every day. And then there's a file watch. So this one's pretty cool. Here's where we define the different folders that we watch and then a files change
within these paths,
it will automatically launch this particular agent. And then you can just create as many different roles as you want each with different system prompts, different user prompts, different concurrency, all different settings. So instead of having to define every single worker or agent, you actually just define the roles,
how many can run at a given time and then you can launch as many of them as you want. And then of course, we also have the logs. I don't think we'll have much in there yet so I'll just jump back to the Popebot. We can filter it by the different roles
and then you can see everything that happened. How long it took,
the entire log here, all the different tools that were used, you can open everything up, you can inspect it, you can see the exact trigger that triggered it whether it's a webhook or a cron or a manual or a file watch. You can monitor the system prompt that was used to generate this output and then also the very specific user prompt. And so obviously in this situation, I had GitHub hit the webhook with the issue details in here and exactly what to do for each of the different agents. So the CTO was told to clone the repository,
develop a technical plan for a specific issue, to make sure to download that issue and all the comments,
and to comment back with its plan. And then here you can see if the plan involves UI or front end changes, add the GitHub label UI UX. And if it involves security sensitive changes,
add the GitHub label security review and that's what triggered the UX developer to run and the
security expert to run. Here we can see what the security expert did. You can monitor everything. Again, the trigger that did it, the system prompt that was developed, and the user prompt. If Now you're enjoying this video, make sure to like and subscribe. I've got a bunch of crazy insane stuff coming. You don't wanna miss it. Alright. So now let me show you the Cloud Code headless and interactive
feature that I've just built out. And this is just as cool, just in a different way. So I haven't explained everything that the Pope bot can do, but it is also an AI agent just like Open Claw. And from here, we can send the agent messages and we can have it do things. In the last video, I created an AI content machine but I've just introduced this new feature here which lets you go into code mode. So in the case where you wanna be a little bit more hands on, where you wanna interact with Cloud yourself instead of through a cluster, you can turn on code mode. You can select the repository that you want to work in. I'm gonna go ahead and again I'm gonna select the pop up. And then from here I'm gonna go ahead and say,
I'd like to create a new
new feature. Now the first thing that it's gonna do is that it's gonna go into that repository and it's gonna use a tool to get access to the cloud. Md and the readme so that it understands more about that project. And it's preparing to check out the code in order to help you implement the feature. Now there's two different ways that we can use this feature. We can use it in headless and I like to use this on my cell phone. I'm gonna show you that in just a minute. We have complete mobile support here so that if I'm working here and then I go to my phone, I don't have to change anything. I don't have to change a setting. I can just boot this up on my phone. Now from here, could continue to chat back and forth with the AI agent and we could develop a plan. And once we had that plan, if I wanted to interact with Cloud Code directly,
I just turned it into interactive mode and it's literally going to pop up Cloud Code and it's going to take that plan that we just developed and it's going to insert that context into this session
and I could just simply start to work on that feature. So I could just say execute
the plan
and it would start to execute it. Now there's also this here. So if I want to create additional
shells where I want to just have other terminals
where I can interface
from a command line perspective in the same code base. So here and I can open up as many of these as I want just like you could if you were using the terminal here. But what's cool about this is that if I now go to my phone, everything that I'm doing here will already be there. I don't have to send anything there, it's just there. In fact, why don't we go ahead and just look at that right now. I'm in my phone here. I'm going to click on the pop up. It'll open up and if I jump over, we can see all the different chats. I can filter just by the code chats and I can come right into the exact same session
that I'm on
and right here you can see where we have the different tabs that we were just working on. Type in from my phone
and if I were to jump back here we're gonna see that I just typed hello and I'm back here. So I didn't have to actually transfer the session back and forth. And what's also cool is we have these built in buttons down here which help you automatically commit your changes
back to GitHub. Once you start the session, you can merge them back, you can reconnect, you can close the different sessions as well, and then you can also close the interactive session and when you do that, it takes you right back to the headless mode where you're interacting with Cloud Code here. So I could say something like
create testing
dot md file
with contents
hello
inside
our
project.
So now if we do it this way, instead of it launching an interactive mode, in this case what it's gonna do is it's going to start a headless coding session and this is what's great on the mobile. If we come back to my mobile app, can see it's all happening
real time. So if I start something on my computer or if I started on my phone while I'm traveling, and this is a much easier environment when you're on your phone. Although from my phone, if I hit headless, again, you can come right back into
the interactive session. And then again, I was modifying the PopeBot project. So if I come back to the PopeBot, notice there was a commit one minute ago. We asked it to create a testing dot m d file with the contents hello
and there it is. And just like the cluster mode, you can always see what's going on inside of the tool calls that's happening inside of Cloud Code when this is running and then it's very easy to filter between all of your chats, your regular chats with your AI assistant and all of your code chats. And by the way, if you need support, make sure to click on this link here and we'll be able to help you out. Now I will show you how to install this by yourself in just a moment, but just keep in mind, it's totally mobile friendly. You can do everything on mobile that you can and we've designed everything to work just the same way, just reformatted. You can go into clusters. You can be on the go. You could be anywhere you want and you could create a brand new cluster, set everything up, all your roles, everything. I've got other videos that explain more about the chats and the runners and the approvals.
Those are super cool too. You're gonna definitely wanna check those out. Just like in any AI chat, you can star
specific chats so that you can keep track of them, put them to the top. If you're working on anything important like a specific feature. Even in cluster mode when you go in here, you can monitor all of the different agents, view the trigger, the system, the user, and then you've got your settings. This is where you can view all of your cron jobs, all of the various triggers in the system, your secrets,
everything. Now to get instructions on how to set up the PopeBot for free, if you just come to the GitHub page, the link is in the description below, and you scroll down to
the getting started section. There are a few things that you need to install first, and then once you have those, it's really just a two step process. You just cut and paste these commands and walk through the steps. I have other videos that walk through this step by step. So make sure to check those out if you want a step by step video tutorial. Now, you want support on setting up the POPbot or you wanna learn how to build amazing technology like this, make sure to jump into the no code architects community. I've got a new course that's coming out. I'm gonna be dropping a new module every single day. It's gonna go through the basics and the fundamentals even if you're starting from scratch, all the way up to advanced stuff like you're seeing me build here. We've got calls on the calendar to support you and a great group of people inside the community. I'd love to see you there. Either way, I hope you enjoyed this video, and I'll see you on the