How I'm Using AI Agents in 2026

In this video, I'll show you how to run multiple AI agents simultaneously in the cloud.

When you're working on complex development tasks, we've all heard about AI agents.

Now we're usually using one, maybe two locally on our own computer.

But what happens when you want to spin up five, ten, 15, 20 right where you want an agent to run on every pull request or, you know, in any slack message or linear, you get the idea.

Well, it's exactly what I'm going to show you how to do here using something called warp.

Now warp is in a genetic development environment.

It looks kind of like a terminal.

And it's, you know, branded the best terminal for building with AI agents.

They've been a long term partner of the channel, and they recently released their new agents feature, which has a ton of capabilities for scaling and running agents out in the cloud.

It's very cool.

You can use it for free, and if you use my link in the description, you can get an extra 1000 AI credits to mess around with this and see if you like it.

I've been playing with it for the past few days.

It's super cool. Hence why I'm making the video.

So I'm going to quickly do is just show you what the agent platform looks like and some examples of agents I've been running in the cloud.

And then I'll show you the full set up steps.

So stick around for that.

So the agent or agent platform I'm going to show you is called AWS.

Now you can use it directly inside of warp.

And you can use the dashboard that I'm about to show you in one second.

Or you can trigger it from the terminal or you can trigger it from some kind of third party software.

So let me show you what I mean.

But effectively, this is kind of what the platform looks like in the user interface.

So you can see that we have a bunch of different agent runs that I've been playing around with.

For any one of those runs. You can see exactly what's happened.

You can go into the state, you can view the environment that actually ran inside of, and then you can directly connect to the session via SSH.

So you can steer the agent even though it's not running on your own computer.

The basic idea here is that you can have agents running all of the time.

You can even, for example, schedule them to run.

So you can see, like I have one that I scheduled here.

I was just playing around with it.

You can create different skills that are kind of repeatable tasks that agents will complete.

So for example I have like a front end agent, validation agent, back end agent, etc. and then you can create environments in which your agents can operate inside of these environments will have a Docker container which will spin them up.

So you can choose the Docker image if you want it to have access to certain tools or capabilities.

And then you can give them access to one or multiple GitHub repositories, which contain the code in which they can operate it.

Then you can also connect with various integrations.

So as you can see, you can build your own integration using their API.

Or you can just use something like GitHub, slack or Linear.

And later in the video, I'll quickly show you how to set up a GitHub action.

So any time you submit a pull request, this all agent is capable of reviewing the pull request or doing some kind of task like that.

So that's kind of the gist of the platform.

And all of this can be managed and set up directly inside of warp, which is the interface you're seeing right here.

Now, while warp looks like a terminal, it's really a full a genetic development environment where you have access to a file tree, a code review tab, but more importantly, all of the terminal commands.

The basic philosophy behind warp, and one of the reasons I use it a lot is that oftentimes when we get into complex development, we have multiple different windows open, different servers, different, you know, Docker commands.

Right? We're running a lot of stuff in the terminal.

So rather than focusing our entire user interface on the code, which is becoming less and less important in terms of manually writing it as a human, let's focus most of it on the terminal where we're actually running a lot of the commands setting up the environment, and in this case, triggering multiple agents to go out and complete the different tasks for us.

You'll see how it works in one second, but if you want to play around with this, then just download warp again.

It's free and I'm going to start showing you how you can set up your environment to trigger these multiple agents.

So once you've opened up warp, you are going to want to just create an account and sign into it so you can see there's a little button here that will allow you to do that.

And you can view some other information and like the keyboard shortcuts, whatever if you want.

Now by default, you're just going to see kind of something that looks like a terminal.

But inside of this terminal you can write natural language like, you know, hello world, right?

Or you can actually type a command something like LS and warp is capable of automatically detecting whether you're running a command or natural language and kind of switching between like being an AI agent or just being a standard terminal and giving you the output directly.

Now, what I'd recommend is just creating a new directory to get started with.

So right now you can kind of choose, you know, the directory that you want to work inside of.

So what I'll do is just make a new folder on my desktop and then open that up in warp so we can start working from there.

So I'm just going to directly tell warp make a new directory on my desktop called YouTube Agent Demo and open it, and we'll give that a second.

And it should be able to actually just run that command for us.

Okay.

So you can see now it's changed the directory here in the bottom left hand corner.

We also have this button that allows us to disable the kind of command auto detection as well as to change the model, see the context, all of that kind of stuff.

Right.

And if you want you can open up this tools pane here where you're able to switch between the agent view so you can manage all of your conversations.

You can view the Project Explorer where you can see kind of like a traditional kind of file tree and code editor.

And then you can look at the global search as well as the warp drive, where if you have teams or stuff that you want to save in the cloud, you can do it there.

Okay.

So I'm not going to focus too much on that because again, I want to look a lot at the agents.

And if you go here you can see the agent management tab where you can view all of the agents and their current status, which we'll have a look at here in one second.

So before we just start spinning up a bunch of agents, what we really should do is just set up the project such that we have kind of the infrastructure in place to be able to utilize the agents, and whether you're using warp or another tool.

I'm going to show you the best practices here for being able to design your app in a way that you can distribute it across multiple agents, so that they can take care of the front end, the back end, the testing, the validation, rather than this kind of slow, iterative back and forth approach with just a single agent running locally.

So the first thing that we're going to do here is we're just going to type the AWS command in our terminal and just make sure that that works.

Now AWS is essentially warps kind of new agent.

So you can type commands like AWS and then help for example, right.

And view all of the stuff that you can do.

And you can also type something like AWS and then log in, which is what we're going to start with.

Now, just to make sure that we're currently logged in and connected to AWS.

And if you want to view the graphical user interface for this, you can simply go to AWS dot warp slash dev.

If you go to that you'll be able to view the UI.

And then of course we can do it from the terminal in the UI.

I'm going to show you mostly from the terminal. Okay.

So now that we have AWS and we've signed in, what we're going to want to do is just make sure that we're connected to the GitHub MCP server.

So in order to do that I'm going to click on my little logo here and go to settings.

I'm going to go over to MCP servers.

And I'm just going to toggle GitHub and make sure that's online.

And then I'm connected to it. So it should be installed already.

If for some reason it's not this is the configuration that you can very easily add.

So you can just literally add this as a new MCP server, what you see on screen right here.

And then once you do that, it should trigger you to actually authenticate with GitHub, which I'm going to do right now.

Okay. Awesome.

So I just authenticated with GitHub.

So now we'll be able to create some new repos for me.

And you know view all the pull requests and all of that kind of stuff.

Now that we've done that what we want to do is just start with kind of a general spec or a plan for what it is that we want to build.

So I have a large spec that I've already written, which represents kind of like a YouTube content management system, but you can build whatever you want.

The idea is because I want to paralyze this across multiple agents.

I'm going to start by just telling me to generate a spec file essentially and say, hey, like, you know, describe the entire application based on what I'm going to tell you in a markdown file.

And then we'll go from there.

So you can see, I've said create a spec file that contains this.

And then I'm just going to paste in this kind of long prompt that I have saved, like on another monitor that describes what it is that I actually want to build.

And this is also going to indicate, for example, the tech stacks, like do I want to use fast API.

Do I want to use MongoDB.

You know you get the idea.

Okay.

So the spec file is completed.

If I wanted to see that I could also type ls for example.

And you can see like spec is here and if I wanted to open that I can just open it directly in warp.

And I can see it here, you know, just like I would in any other kind of development environment.

So what I'm going to do now is I'm just going to start scaffolding the project just because I need the basic kind of front end, back end directory set up before I can really get the agents to go off and start building everything.

So I'm just going to tell it scaffold a project based on the spec file, just create the front end it back end directory and connect them, but don't do anything else.

So we're just going to tell it. To do that we're going to press enter.

And once it's finished then we can get into the agent config.

Now you'll notice that sometimes warp will ask you for permission to run commands.

So if that's the case what you can do is either just press run here or you can auto approve.

In my case I'm just going to auto approve.

So it's not going to ask me any more for this run. Great.

So it looks like that worked.

Now what I'm going to tell it is just to create a GitHub repository, because we need a repo in order to set up the environment that our agents can operate in.

So I'll just say create a new GitHub repository, make it a remote repository, and then commit all of the changes so far to it.

Okay let's hit enter. And let's get it to go through that.

It should be able to do that now because it's connected to the GitHub server.

Okay. So it looks like that's complete.

And what we're going to do now is we're going to create a new environment in which our agent can operate it.

Now in order to make the environment you can run the command create and then environment, and it will just run you through a guided setup, which is recommended.

Or what you can do is go directly to the user interface.

So if you go here you can go to environments and then you can go new environment and you can create a new one and you can give some set of commands, the Docker image, the repository that you want to connect with, etc..

So what we're going to do is I'm just going to tell warp to create a new environment for me.

So rather than running the command which I can do, I'm just going to say, hey, make a new environment and then it should just set it up for me.

That's the thing that I love about these AI agents is that the developers add all of these tools, but then you don't even have to know how to use the tool, because you can just ask the agent to use the tool and it uses it.

So let me be prompted to do that.

Create a new environment for this GitHub repository so I can run as agents in the cloud.

Make sure it's a team environment okay, so I just told it create a new environment for this GitHub repository so I can run this.

I should say AWS not as AWS agent in the cloud.

Make sure it's a team environment.

Now you need to make sure this is a team environment.

Otherwise it's not going to let you run the agents in the cloud.

So just put team environment.

It should set it up correctly and let's see if it's able to do that okay.

So it looks like it created this environment successfully.

And then it says hey if you want to run an agent in the cloud you can run this particular command.

Now before we do that, I'm just going to quickly run at the slash init command.

What this is going to do is it's just going to read through our entire project and create a special file that our agents will be able to reference.

That kind of explains the project and any rules that they need to follow as they kind of go through the code.

So I'm just going to run slash it and I'm going to go, yes, I want to index the code base and generate the agent start MD file.

Again.

The more context we kind of generate before we have the agents just go off and start doing stuff, the better.

So I know you're like, how do we run the agents?

I'm going to show you in a second, but I just want to make sure that before we run them, the basic setup is in place.

Now at the end of this step, we did also prompt me to create an environment.

I believe that just something they have coded in.

I just said no, I don't need to make the environment because I already have one created and now we have this file created.

So if I go ls, you should see that we have this agents dot markdown file which it will reference any time it is going to, you know complete some new task.

Now I've also just brought up on my screen the CLI reference, which I'll leave a link to in the description.

So in case you just want to copy any of the commands, you can do it directly from here.

So everything is set up now for us to be able to run multiple agents.

So if you just want to run an agent locally on your own computer, it's fairly easy to do that.

First of all, you can just open a new tab and you can just run multiple agents at the same time in different tabs, like running locally on your computer.

Or you can run the command that's right here.

So something like AWS Agent Run.

And then you can specify a prompt that you want to execute.

So in this case you know summarize this directory.

And by default what it will do is run on your computer.

So you can have a mixture of multiple agents running locally as well as agents running in the cloud or agents that run on some kind of trigger.

Right. Like an integration, which we'll look at in a second.

So I'm going to go ahead and press enter here just so we can see this one running locally.

You'll notice that what's going to happen now is that a new conversation has started.

And this will actually be running in the background.

Now it will stream the output to the terminal right now because I'm not doing anything else.

But if I wanted to, I could take over this agent by hitting control shift and then enter.

Right. And I can tell it something to do.

So you can see the agent is waiting for instructions.

I'm just going to say continue.

But the point is that at any point in time, I can kind of steer the agent, take over and control what it's doing.

In this case, I'm just going to stop this one because we don't need it to run.

And then if we go back to our AWS platform here, let me just make this a little bit larger and we go to the agents.

We should be able to see sorry, not the agents, but the runs are the agent that was running right.

So summarize directory contents and you can see that it's showing that it was running well.

Some of the other ones were completed errored out etc..

Okay.

So that is how you run an agent locally now.

It will still show up here even if it's not running in the cloud, which I know can be a little bit confusing.

But point is, you can, you know, change where you want it to run.

And if you want it on your own machine or in the cloud.

Now where this becomes a lot more useful is when you start running agents well in the cloud.

So what I'm going to do is I'm actually going to tell this agent to create a general plan for everything that we need to do to build the back end, as well as the front end, and then how to test the project.

I'm going to have it create three separate files, which are kind of the instructions that I'm going to pass to these individual agents.

So each agent knows what it's supposed to do.

So let me just prompt this and tell it the following.

Create three markdown files that explain what the tasks are that need to be completed for building the front end, the back end, and for testing the application.

Put them in three separate files in a plans directory.

Okay, so I just want this agent that's running locally to create that.

And then as soon as that's done, I'm going to spin up three agents in parallel and run them in the cloud and have them submit pull requests to my main GitHub repository.

So again, they can do that in parallel.

So it looks like you created those three plans for us.

What I'm going to do now is I'm going to create something called a skill.

A skill again is kind of a repeatable thing that an agent is going to be able to do, and that we could run directly in the cloud.

And then I'm going to have these agents kind of use this skill and spin up.

You don't have to go this far.

But again, I'm just showing you how to get the best usage out of this.

Now again, I'm just referencing the CLI reference here directly from your app, which I'll link in the description.

But in order to run an agent in the cloud, you run AWS Agent Run Cloud, and then you can specify things like, you know, a model.

You want it to use a skill, you want it to use different environments, etc..

So first things first, we're going to set up the skills.

Set up three skills for each of these three plans that I can use for my agents.

Okay, so same thing.

I'm just going to tell it to set up the skills and then it's going to use.

I believe it's the create skill command to create those skills for us.

Okay.

So we just created the skills.

Now just one thing that I need to tell this to do is put the skills inside dot agents slash skills.

This is just the structure that we need in order for it to be picked up automatically in the cloud for us, so that we can reuse these skills later.

Okay. So it says it did that. Let's have a look.

And we can see we have the dot agents folder.

And now we should be good to go okay.

So now it's finally time to actually run these agents again I don't need to manually type the command.

I can just tell it what to do.

So I'm going to say run three agents, one for the front end, one for the back end and one for testing.

Run these in the cloud using the skills that were just generated, and put them in the environment that we created for this GitHub repository.

Okay. So I'm going to do that.

And then it should actually trigger these different agents for me.

And if we have a look here again you can reference the CLI.

And you can see that yeah I could type all of this out.

But now I'm lazy because of coding.

So I'm just getting it to do that for me.

And again it will have all of the context because it's created pretty much everything automatically.

Awesome. Now while that runs.

So it's going to run in the background now and hopefully spin up some of these.

I just want to show you in this user interface.

So from here again you'll be able to see all of the runs that are happening.

We should see the new ones pop here.

Pop up here. Sorry in a second.

We also have all of our agents.

So these are the skills effectively that we've added to the GitHub repository.

We'll show up here and we can click into them and start running them or scheduling them or you know changing the configuration.

We have the environments as you saw.

So if you wanted to see the GitHub repo, you could go into the environment you have, see what GitHub repo it's working inside of.

And then the integrations which we'll get into in a second.

We also have the schedules so you can go new schedule.

And then you can choose an environment as well as a model or a skill that you want to run that you can see. Right.

Like there's a bunch of stuff here that we can do and we can say, okay, we want to run this every day or every hour, every month or whatever, which is super interesting.

So anyways, it looks like it's spawning the agents right now.

So let's go here and let's make sure that's the case.

And we see new agents popping up and boom, we see one right here at Cloud Agent Run.

And it should give us the real name of that in a second.

Awesome.

Now I'm also just going to quickly go to warp here in a new terminal and say push all of the contents of this to GitHub just to make sure that the GitHub repo has all of the codes that the agents are going to be able to access all of that information, because sometimes it doesn't actually push everything to GitHub.

Okay. Awesome. So you can see that all of this is running.

And then what I can do for any one of these, if I actually want to see what's going on, is I can press into it and I can go view session, and I can open this directly inside of warp or in my, term or what do you call a web browser here?

So let's give this a second, and see.

So let's go open warp and you see it's going to give me a new terminal here.

And what I'm able to do is actually directly get inside of the agent.

We can see it's running in the cloud and start steering the agent, you know, changing anything that it's doing, etc..

And if we want, we can go to the agent management page and same thing.

From here we can view all the agents that are running, so that, you know, we don't need to, what do you call it?

Go to that web UI in case we don't want to. Awesome.

So that's it for the agent. So this is going to take a second to run.

And in a minute they should add a pull request to our GitHub repo which we can have a look at.

Okay.

So while those take a second to run I'm just going to go into the AWS UI here.

And I'm going to go to my integrations and click on GitHub action.

Because this is something that I want to set up.

Or at least give you a bit of insight on how to trigger.

So what we're able to do is actually create a GitHub action where any time a pull request is, you know, created, for example, we're able to review all of the code so you can see that we can kind of just use this pre-built, GitHub action here directly from or we can have some kind of prompt.

We can specify the model.

We can use an MCP server, whatever.

And all we need to do is just include our warp API key inside of GitHub when we set this up.

So what I'm going to do is just copy the contents of this.

And I'm just going to go to warp and tell it to start setting that up creates a new GitHub actions folder that includes this configuration so that we have one, what we call a GitHub action that does automatic code review based on what I'm going to paste.

Okay.

So let's wait for that to trigger I'm going to paste this inside of here.

And I'm also just going to copy the URL directly and give that to warp.

And hopefully it's going to create that for me.

So let's go. Yeah. Start a new conversation. That's fine.

And then add that into our directory and push that up to GitHub so we can test it okay.

So I'm just going to review this here.

You can see I just press the review button so I can open up the code review pane so I can see what it's actually writing.

That looks good to me.

So what I'm going to do is just say this is good.

Now push it to GitHub.

And we could just say force push main for right now just because I want it to directly go up there.

Now at the same time I was just checking and we do have a pull request that is completed.

And in fact you can see a few of them are kind of popping up now and being created.

So we have this one, which is the front end where we're doing this kind of bootstrap workspace and MVP, you know, page scaffolds.

And if we have a look we can see everything that it is automatically generated for us.

And that is the what do you call it, front end.

And then if we go back here, we can see that there's actually another one that we can create a pull request for, which is for the back end.

So let's go ahead and create that. Cool.

Now what I want to do is I just want to test that GitHub action feature.

So let's go here and see if this is here.

So I don't see the GitHub folder.

So let's go back to warp and make sure that it's actually creating that okay.

So it looks like it did add that to GitHub.

If I bring this back now and we go to the code, we can see that we have the workflows folder created.

And what I just told warp now to do is create a sample pull request.

So we can test this effectively.

And just make sure that's actually going to run that workflow and do the automatic code check.

So now that this is here, what I do need to do is add in my warp API key.

Otherwise this isn't going to work.

So what I'm going to do is go to settings.

I'm going to go to Secrets and Variables.

I'm going to go to actions.

And then I'm just going to do a new repository secret here I'm going to add the warp API key.

So this is going to be in all capitals warp API underscore key.

In order to get that key I believe we can do that directly from warp.

So if I go here, I should be able to go to settings and then find something with an API key.

So let's just search for it API key.

And it looks like we can go to Plot form here.

Go create API key.

We'll call this GitHub actions okay.

And we'll do a team key. Should we do.

Yeah.

Let's do a team key and then create that copy it.

And we're going to go back here and paste the key.

And obviously don't leak that and then add the secret.

So now I just had to create a test.

What do you call it PR so you can see the GitHub action is now running for some reason we got some error.

So let's quickly just check this out.

And it says the warp API key must be provided.

So actually let me check if it needs to be all capitals or lowercase.

This looks like capitals is fine, but I'm just going to try to rerun this because now I added the secret, which I think just wasn't there when it was running, and let's see if we get it now.

Okay, so it looks like it's running now. I don't see any errors.

So that's a good sign.

And we can see that it's setting up all of this stuff directly inside of warp.

And it should trigger an agent now to actually do the code review, even though we don't really need to review much for this because it was a test.

So that'll be interesting to see if that works.

And actually, I can see now if I go to my UI that this is running right and I can see the status of it, whatever it's going to take a second to complete, and then we should get a result here in a second with any of the PR revisions.

Okay. Awesome. And it looks like this was completed.

You can see that we got a checkmark here for the GitHub action.

And we are good to go.

And we can merge in this pull request.

So I think with that said guys that is going to wrap up this video.

Look I showed you a lot of stuff.

I know there was a lot of set up, but I always like to be pretty comprehensive.

This is a very powerful tool for doing advanced developer workflows where you're running multiple agents, putting them out in the cloud, for example, starting an agent, closing your laptop, you know, running on the train, whatever you need to do.

So definitely check it out.

I've been using work for a while.

Again, I like it for a lot of projects, especially ones that are really backend heavy, and I believe you probably will, as well as a reminder, if you want to get some free credits, click that link in the description and I look forward to seeing you in another video.