Hey everyone. My name is Emily and I'm

an engineer on the growth team here at

Cursor. And today we will be presenting

about cloud agents, which is

agents that run in the cloud and they

keep going when laptops are actually

closed.

And they let you do long-running tasks

in parallel across multiple agents.

And with the harness that we set up

they're actually able to self-test,

build artifacts, and deploy and generate

kind of previews for you to come back

and evaluate. You're able to actually

run them on a schedule with our new

automations feature, not just on demand.

And they can run from minutes, hours to

days and report back with the real

results that you can verify.

Some key things that we've developed for

cloud agents, one is a really new

harness that actually lets you run cloud

agents for long tasks for maybe even

weeks at a time.

We had Wilson, one of our researchers,

go ahead and actually develop a browser

across thousands of commits.

Um

and it was able to actually simulate

almost Google Chrome functionality.

We also gave cloud agents the ability to

um

have [clears throat] artifacts. So they

can do computer use, click around in the

browser,

um and actually simulate the process

that a human does when you're verifying

code and testing the output through the

visual and actual final output.

Um you're actually also able to launch

agent swarms. So you can launch a bunch

of different sub-agents that run in

parallel to do the task and report back

to the orchestrator.

And then finally we built a lot of

extensibility in mind. So you can

actually build a bunch of custom skills,

plugins, and hooks so that the agents

work best for your internal environment.

Um a few key tasks here. Um one is the

sub-agents that I've been mentioned is

that you're able to actually, let's say

you're doing unit tests or writing your

larger factor, you're able to have all

of these agents working in parallel to

get the job done once you figure out the

right plan for them to implement. Um and

then with artifacts you're able to

actually get videos or even screenshots

as an output. Um so you can quickly go

and verify the results. Um and as I

mentioned also we have our new

automations feature. We won't be diving

too closely into that today. We'll have

a separate sessions. But you're actually

able to specify agents that run either

on specific triggers, so a Slack

message, um a GitHub PR, or on a cron

job to actually do these continuous

tasks that should always be running.

And one thing I did want to highlight is

we internally use cloud agents a lot. Um

ever since kind of that artifacts

release back in early January, um our

internal usage has skyrocketed

and now about a third of our PRs are

actually created and merged by cloud

agents. Um so you can kind of see this

is not something we've just built, but

this is something we heavily use

internally and I'd say for me I'd say

70% probably of my PRs are actually by

cloud agents.

Um and yeah, I think a little bit more

on how Cursor uses Cursor, like we don't

agents don't just write our code. Um it

reviews our code, it tests it, it fixes

it, and it also deploys it. Um we kind

of made it as easy as possible for us to

quickly iterate and launch code and new

features to all of you.

Um and kind of a vision for how we see

coding agents evolving.

One is that they work best when they

have knowledge to your internal tools

and systems. So being able to surface

the right MCPs that interact with your

um knowledge base, being able to write

skills that provide that relevant

context for how best practices and how

all the um internal systems interact is

actually critical for getting the best

results that you want. Um and so we

launched a plugins marketplace um a few

weeks ago to enable that to be as

seamless as possible. And last week we

launched two marketplaces so you can

actually share these um shared knowledge

bases across different team members.

Um and then agents are going to the

cloud. I think less and less time will

be hands-on keyboard and you will be

kind of orchestrating a bunch of um

PMing a bunch of agents running in

parallel. Um so if you have them across

different repos working on parallelized

tasks, um your kind of will be job is to

working on making sure they're working

on the right thing, constantly iterating

and looking at the outputs they're

giving. Um and then the bottleneck will

become more more on this review and code

quality, which is something that we're

focusing on um a lot as well. It's how

do we make sure that with the volume of

code being generated that it's not

resulting in any um vulnerabilities or

bugs that are coming out. So we have

kind of a code review product called

BugBot that we use a lot. Um and then

with automations you can actually also

build in a bunch of custom flows that do

this verification as well.

And of course there has to be controls

in place. You don't want a lot of agents

running um rogue out there in the wild.

And so making sure we have the

visibility, flexibility, and the control

is something that is always top of mind

for us.

Um so that's a high level a little bit

about cloud agents, but a demo is worth

a thousand words so I'll hand it off to

Emre that to show the product

connection.

Amazing. Thanks Emily. And again

reminder folks, if you have questions,

please just put it in the Q&A. Emily and

Florian will try and get to them um

while I'm talking.

Um cool. So thank you Emily for talking

uh or introducing introducing cloud

agents. I want to before I kind of jump

into the demo here explain why someone

would want to use cloud agents. Um cuz I

think we get that question a lot is like

why use cloud agents versus local

agents? The main reason is um kind of uh

I want to say async or multitasking or

kind of orchestrating agents here.

Basically how I use cloud agents is I

have a list of tasks I want to get done.

Um maybe it's the end of the day. I like

to close my laptop, maybe go for a walk,

or even just get other things done on my

local machine. Firing off cloud agents

has it run on remote VMs, meaning that

it's not going to be constrained by my

machine, and it's also not going to, you

know, take up any RAM or

uh extra space that I might not be able

to afford. So what's great about cloud

agents is I can now run as many agents

as I want on a external infrastructure,

on the Cursor's infrastructure, and that

will be able or that won't affect my own

personal uh machine or things I'm doing

locally. So that's kind of one big

reason. Another is um and I'll show

here, cloud agents are just really good

at self-verifying their work. So I'm

going to share my screen and we're going

to go through this a couple ways. I'm

first going to show the docs so that

folks can see if they want more

information how to learn about cloud

agents. Um we have a really great kind

of summary here about why you want to

use cloud agents. Um but I think more

importantly than that, if folks are

interested about uh security and

specific settings, let's say you're

using Docker or you have a specific

configuration, um we have really great

documentation around it. I think more

importantly than that, um cloud agents

are really, really great at just doing

work um that is something that maybe you

thought you wouldn't be able to have to

have time to do. So it almost feels like

an extra friend or colleague that is

picking up work for you that you might

not have thought you'd be able to do.

Cool. Okay, so again, go to these docs.

Um Florian will put this URL in the chat

if you want to kind of enhance your

learning as I'm speaking, but let's dive

right into how cloud agents work. So I'm

going to show two things. I'm going to

show how to uh start a cloud agent um in

like a brand new repository. And then

I'm also going to show what a cloud

agent run looks like and all the

capabilities that you get with cloud

agents. So the first thing I'm going to

do is I'm going to go to

cursor.com/onboard.

And what you're going to see here is I

can actually select a repository of my

choice. So I'm actually going to select

my personal website cuz it's kind of

small so I'm hoping that we can get it

fully built out by the end of this demo.

Um I don't have any environment

variables or secrets that I want to put

in here, but I can if I want. Again, if

you have questions about how these are

stored, feel free to check out our cloud

agent security page. We talk a lot about

how we do kind of the cloning of the

repo and the snapshots and secret

protection and all of that. Um so I'm

going to go ahead and just go ahead and

hit start for free.

It now is going to set up the

development environment for this

codebase. Um a couple things you'll see

here. The first is that you have this

really great setup where you have the

repository uh development environment

being set up on the left, um all the

dependencies being installed, and then

you have um what we call the cloud agent

UI on the right. So you'll see here it

has kind of a list of things that the

cloud agent is going to do. Um it also

has your list of secrets if you want to

see those. Um and then also it has your

Git UI. So as uh you make changes in the

cloud, as you ask Cursor to implement

things, you'll start to see uh the diff

showing up, seeing uh meaning that you

still get transparency into the code.

Cursor's uh a big believer that you

should always be able to see the code if

you want to. And so you'll be able to

see your diff here. Um you can, you

know, see your commits if you've

committed stuff already. And what I'll

also show as well in a previous run is

you can also see CI. So if you have CI

checks running, you would also be able

to see that here. Um what's great about

cloud agents is they automatically check

out a branch for you. So here I have a

branch with the

development environment being set up. Um

and I'm able to kind of check that

branch out locally on my machine if I

want as well.

As you're seeing here, cloud agents can

start sub-agents. Um that's a really

cool feature. Um and what that means is

it's able to work in really, really

large codebases. So

uh I'm going to show you uh a cloud

agent working in Grafana, which is I

think something like 2 million plus

lines, 30,000 files, and it's just a

testament that Cursor is great for large

repos. If you want to upload your mono

repo or whatever to your cloud agent,

you would be able to.

And then the last thing I want to show

is uh you and we'll see this in action

is Cursor actually has access to its own

computer and mouse. And what that means

is that you'll be able to kind of uh

test things manually for you.

Um looks like it's kind of not

connecting to the desktop today, but

I'll show you a previous um a run of

this and you'll see what that looks

like. And then the last thing is the

terminal. So you still have access to

terminal to see any commands that

Cursor's running, um if it's running a

local server or anything like that will

be all in the terminal here.

So that's kind of a little bit of a tour

of the cloud agent UI. Um pretty

straightforward, really great uh again

to visualize what's going on. As you can

see here, it's uh running uh based on

what I've given it in my repository a

couple of scripts um and it's going to

try and understand what's going on here.

As you can see,

it's saying this is a personal website,

all of that, and then now it's going to

install all these dependencies for me.

So, pretty straightforward, a great way

to kind of set up your environment.

Please check it out. Um it's really uh a

a really like fast and also just easy

way to get started in the web. Um and

the last thing I will say is that this

integrates with both GitHub and GitLab.

So, if you are not on GitHub um and

you're on GitLab instead, feel free to

use Cloud Agents. Um we have Bitbucket

support coming soon for all you folks on

Bitbucket. Um but feel free to try it

out on your own environment for now and

we will uh we'll talk more about what

that looks like.

Cool. So, this is the setup environment.

Um now I'm going to go into like what a

Cloud Agent run looks like. So, there's

multiple ways you can fire off a Cloud

Agent. Um the first way that oftentimes

I do is I do it from the Cursor IDE

itself.

So, as you can see, um I asked it to

build a plan. I'm going to ask it to

build this new dark mode plan for my

Grafana repository. Um I'm going to say

invisible. Um and what I'm going to do

is I can actually build a plan locally

and then have Cursor implement the plan

in the cloud. And I love doing that

because it's a really great way of kind

of working with Cursor to understand um

the plan and like what my strategy is.

This is my Devil's Advocate sub-agent

running actually that helps me kind of

challenge what's going on in my design

questions. Um and then I can run it uh

in the cloud once it's done building the

plan. So, that's one way to do it. You

can also just run um agents in the cloud

locally yourself. Um so, you can just go

from local to cloud and then just fire

off an agent without having to build a

plan and then that will automatically

start running here as well. So, I can do

that. I can say change the font of the

Grafana main header to Times New Roman.

And what you'll see is that it will

start all the environment set up, it'll

allocate all the resources, and what's

cool is you'll actually now see that

agent running on uh over here as well.

There it is. The Grafana main header

font change is now running. So, this is

like a great way to kind of sync between

your local and your cloud environment.

They're always there um and everything

will always be synced. So, that's one

way you can launch it. The other way to

launch a Cloud Agent is actually from

Slack or Linear. So, you can actually

comment on a Slack message um or a Slack

thread and say like, "Hey, @Cursor, can

you solve this for me?" Um that's due to

our amazing Slack integration. A lot of

PMs use this feature when bugs come come

in and they want to be able to fix it

easily. So, that's one way you can do it

as well. And then Linear is another way.

Um you can do @Linear in any ticket and

it will launch a Cloud Agent and be able

to solve your bug in the cloud. Um the

last thing I want to show with re-

regards on how to launch a Cloud Agent

is actually uh mobile. So, I'm actually

going to bring up my phone here. Let me

go ahead and open it um so you all can

see.

It's connecting.

And what you're going to see is I

actually have cursor.com/agents

up on my phone. And as you can see, I

can see all the agents that I just

launched. So, I have my dev environment

setting up on my personal website and

then I have the header font change on

the Grafana app. So, everything is kind

of in one place. I'm able to see like

what repository is working with what

agent. So, it's a very easy way to kind

of do multiple multiple uh like agent uh

requests across different repositories,

which is really neat. Um so, I know a

lot of people are asking about like

cross-repository work. Um this is kind

of my favorite way to work in like both

my website and my Grafana uh fork and

like the Cursor website that I'm making

changes to all at one time. And you

know, I can click in, I can launch

another agent from mobile here if I

want. Um I can even go inside here and

check and see how my agents are doing.

As you can see, uh this is an example of

uh Cursor using the computer. So, we'll

we'll take a look here and see what it's

doing. Um but again, using using your

mobile phone for launching Cloud Agents

is really great. It's very seamless um

and we're really excited to have this

feature up. Um Cool. Okay, so that's

mobile. I'll go ahead and just minimize

this for now. Um

I'm going to go back to our plan. Oh,

looks like the plan is asking me more

questions. That's fine. Um and then I

want to show you all the uh build in

cloud feature cuz I think that's a

little bit hidden in plans and I want to

make sure that everyone sees it.

Um in the meantime, I'm going to

minimize this and I'm going to go back

to where it was setting up my um my

website. Cool. So, as you can see, it

went through all the to-dos here and now

it's actually doing the uh computer use,

meaning that it's seeing how it actually

looks like to start the server and uh

run my website on um Cursor's Cloud

Agent computer. As you can see, it

checks for uh API responses, so it makes

sure that everything is returning 200.

Um but it can sometimes take longer

than, you know, maybe it would locally.

We keep a little like note here saying

that Cursor setting up a development

environment from scratch can take from 5

to 30 minutes. So, just be aware of

that, but remember that you can always

launch as many agents as you want at

once. So, this should not be a blocker.

You can go ahead and just go and check

on your other agents in the meantime.

Cool. So, this font change is working

well. Um now while kind of these are

both running, I want to show you all

what a completed Cloud Agent run looks

like and how you can see uh demos and

artifacts like what Emily showed. So,

I'm going to go actually to a Let's go

to this guy. This feature that was

built. Cool. So, again, I was working in

uh Grafana, so my Grafana fork, and I

wanted to implement a new feature. So, a

couple cool things here. The first is

that Cloud Agents in Cursor have access

to MCP servers and this is huge because

uh to my knowledge, no other uh AI tool

Cloud Agent right now can use MCP

servers um in the way that Cursor can.

So, all I asked it to do was implement

this ticket, graph-59. It immediately

was able to understand that this is a

Jira ticket. It got all the full details

from the Jira issue and then it made a

plan. It explored patterns using

sub-agents and then it read the key key

key files that it needed to modify.

What's really cool about Cloud Agents

and just about um Cursor generally is it

is always able to parallelize work with

sub-agents even in the cloud and that

makes both the speed and the

comprehensibility of what it's able to

do really powerful. So, I think that

Cursor is the best way to work with

large code bases and, you know, and be

able to make changes in, you know, that

that doesn't take like hours. So, I love

working uh with Grafana in Cursor

because it's just super super fast. So,

I asked it to implement this ticket,

graph-59, which is basically a way to

view the feature flags in Grafana um and

then just view it on uh a separate page.

So, if you want to see the ticket, I can

go ahead and just load that up right

now. Um graph-59, oops, 59.

Um

Oh, sorry. Graph-59 Jira.

Hold on.

Um

This is

probably where

There we go. Here's my ticket. Um so, as

you can see, I have details about what

the ticket does. Um Cursor reads all

these details and then goes ahead and

implements them step by step in the

Cloud Agent. Um so, I basically said,

"Hey, like feature flags right now are

not visible in Grafana. Can you make a

whole page that shows all the feature

flags and allows me to toggle them on

and off?" So, that's a pretty big

feature and this is Cursor actually

sending me a walk-through video after

it's finished implementing the whole

feature on how it did. And this is

really phenomenal. This is like what you

would expect kind of a colleague or a

co-worker to do after they finish

implementing a feature, they add a video

to your PR being like, "Hey, this is

proof that it works." Um but Cursor does

this all on its own. And as you can see,

I didn't really give any instructions on

how to test it. I gave it a scope, I

gave it acceptance criteria, I gave it

some notes, but Cursor was able to

figure out on its own how to test a

feature like this. So, it was able to

kind of see how to search for stuff in

the search bar. Um it was able to

understand like how to toggle flags on

and off. We really think that these

artifacts are the future of what coding

is going to be like where these agents

will be able to go off, make changes,

and then come back and be like, "Hey,

here's proof that this change was made

and I've made a video for you showing

that." So, it's really really neat and

very cool. Um

You can save these videos if you want

and share them with your team. You can

get a link to the video. You can also

just ask Cursor to upload these videos

to your PR if you want. I've done that a

couple times if I want um

if I want to have those videos saved.

And then we add our lovely little Cursor

logo at the end so you show that this is

Cursor made. So, these videos are really

neat and this is kind of my favorite

part of Cloud Agents are these artifacts

that Cursor creates. As you can see

here, it also takes screenshots if you

want not a video and just want to see

like what each area looks like. As you

can see, there's a screenshot of it

searching in the search bar making sure

search works. Um there's a screenshot of

it checking the other uh pages that it

created. So, it was able to categorize

all the feature flags by experimental

versus preview and then it was able to

filter it by there. Um so, this is like

truly remarkable. This is a big feature.

I mean, I was a software engineer for 6

years before this. I think implementing

a feature like this probably would have

taken me weeks um and Cursor was able to

do it in an hour. Um so, that is just

remarkable. In addition to the manual

testing that it does in the browser, it

also does a lot of uh testing

locally. So, it's able to run scripts.

Um again, I didn't give it any

information on how to test it. It was

able to figure that out all on its own.

Um and it so it made sure that not only

did it pass the test manually and it

looks good, but it also passed all the

unit tests um that it was able to create

and run for itself. Um as I mentioned,

there are CI checks that happen and this

is just because this is

uh a forked repo of Grafana. So, I get

all the CI checks that would be on the

original Grafana repo. Um you can

actually have Cursor access these checks

and be like, "Hey, why is this check

failing?" and it will rerun CI and be

able to understand and figure out what

the checks are. Um this is something

that actually is a great use case for

automations. So, we actually have a

great automation template for uh fixing

failing CI checks that we'll probably

talk about in a later session. But

again, really cool way for Cursor to see

CI and understand what's going on there.

And then you can also see your commits,

so you can see what what changes were

made, what changes Cursor decided to

make. Um you can check out those commits

if you want more granular detail there.

Um but it's a really cool way as well of

making sure that you're not just

creating massive PRs. Cursor is

organizing them in a way that makes

sense.

So again, this is like a what a final

cloud agent run will look like. Um and I

wanted to show you all kind of the

beauty of it because I haven't seen this

in any other tool. Um this kind of just

blew my mind when we first tested out

internally. So, I'm excited for you all

to try it because it really is quite

neat. Um as you can see here, it looks

like our dev environment is still

running. Um a couple of things that I

want to mark here. Oh, there you go.

There's our little walk-through video

that we made for my website. So, as you

can see, it's going to go, it's going to

go to my localhost, have my server

running, and then it's going to show off

my website, hopefully. Let's see. Looks

like it's refreshing, making sure that

everything looks good. Um and there it

is. And there's my website. So, this is

just a really cool example of, you know,

and this honestly didn't take that long.

Oh, I love this. It's testing and making

sure that all my blog posts work. That's

very cute. Um so, it's testing stuff

like that. It's making sure that

everything, all the other uh links on my

website work. I have a little

connections page on my website when I

used to make my own connections board.

Um so, it's doing a really good job of

that. And then it's also navigating to

uh Oh, no. This is just a screenshot.

Amazing. But as you can see, it does a

little summary. Um so, it says, "This is

what I did. This is all the things that

I tested." And then what you can do is

obviously you don't want to uh rebuild

this environment every single time. So,

when I actually actually save this

environment to my team so that new

agents can start from that current

snapshot and they don't need to always

rebuild the environment from scratch

each time. So, we're totally aware that,

you know, the cloud agents can take

time, especially for something like

Grafana, it probably takes a while. So,

definitely save your environment to your

team so that you can start from that

same snapshot.

>> [gasps]

>> Cool. Awesome. So, this looks great. I

can now go ahead and just start uh

talking to the agent and making changes.

Um

I like to actually go to this uh UI for

new changes. As you can see, I can

choose what repository I'm working in,

so I can change repositories really

easy. But then I can also choose what

model I'm using. So, I think this is a

good thing to highlight is we have all

our greatest models and this is a model

we released as of the last, I think, 10

minutes or maybe 20 minutes, Composer 2

is officially out. Um please give it a

shot. It is a great great model um and

it's much much cheaper than a lot of

these frontier models at the same

intelligence level. Um but if you want

to kind of try out other models, um this

is a great way to do it. I really like

Codex 53. I think it's a really great

model for how inexpensive it is. So, if

cost is something that's important to

you, definitely try out Codex 53. And

then as always, you can try out multiple

models and see how they work. Um we

offer that setting in cloud agents as

well if you want to compare models.

The last thing, or actually two last

things I want to talk about, is the MCP

servers. So, I mentioned it earlier when

you saw that I just asked it to

implement a ticket, it was able to

access my Atlassian MCP server, but you

can actually add whatever MCP server you

want to your cloud agent. So, any MCP

server that you have locally, you should

be able to add. I really like um the

DataDog MCP server. I think it's really

great um in like identifying uh you

know, performance issues or any bugs

that have come up. A lot of folks also

really like um

Where is it?

Oh, there it is. Um I guess the Slack

MCP server and Atlassian MCP server are

both kind of, you know, par for the

course. A lot of folks have used them.

But again, Linear is a great one if you

want to create more linear tickets. Um

and then we have a a lot of other cool

ones that people have enjoyed. Um I

think one that specifically I like is

doing the um the integration with TLDraw

and with actually the Excalidraw MCP

server, which I think I would just add

here to my custom.

Um mainly because I love uh Cursor to

create diagrams for me and I do think

that TLDraw and Excalidraw do a great

job with that. Um I also have the

Granola MCP server turned on and I use

that sometimes to uh take notes from

meetings and use that with Cursor to

generate action items and feature

requests. So, there's a lot of great

things you can do with MCP servers and

cloud agents and it's it's really quite

powerful.

And then the last thing I'll show, this

is actually in beta right now. So, I

think maybe some folks will have access

to it, I'm not sure. But you can

actually have a long-running task, which

means you can actually ask

Cursor to work on a task um that can

take maybe hours. Uh you can go for as

long as you want if you do grind until

done. So, um as Emily mentioned, we had

one of our engineers, Wilson, build a

browser, like a full browser, from

scratch using grind mode. Um but yeah,

I've seen people use this for like

really, really uh tough migrations. Um I

know someone who tried to migrate from

Poetry to UV doing this and they were

able to do it. Um same from like SQL

upgrades from like version 4 to 5, um

you can do that with uh with something

like grind mode. So, check that out.

Last thing is we offer the same voice

mode and images that we do uh locally

with Cursor. Um so, sorry, with the

cloud agent. So, that is also um

available for you if you want. Um but

yeah, this is kind of a tour of cloud

agents. As uh Emily said, we'll do a

specific um

deep dive into automations next week, I

believe, um where it's actually going to

be cloud agents on a schedule and on a

trigger. So, you'll see here there's a

ton of different templates that we

offer. But if you kind of look inside

one, so here's like a cleanup feature

flags cloud agent, um you have one that

actually you can schedule on a trigger

um that acts as a feature flag cleanup

kind of bot for you. Um and then you

can, you know, connect it to whatever

MCP server that you want. So, really

quite neat.

Um I know uh I'm about time. Are there

any

questions that I could tackle before I

end? I think there's two core groups of

questions I wanted to highlight. Um one

is people are saying they have a

separate like front-end and back-end

repo. Um cloud currently doesn't support

multi-repo workspaces. Is that correct?

Correct. Yeah, so if you have two repos,

so you can you can work on them

separately, but you can't work on them

together if that makes sense. But that

is coming very, very soon.

Yes. And then the other common question

is a lot of people work at enterprises

and they want to run cloud agents in

their own cloud. Um that is on our road

mapping road mapping coming very soon.

So, um stay tuned for that.

Yep. And you'll see that actually right

here, this use private workers, it's in

beta right now. We're testing it out

with a couple customers. So, that will

be your your gateway to running cloud on

your own infrastructure. Mhm. Yeah, and

if you wanted to get connected, feel

free to email me Emily@cursor.com.

And I know we are at time, but yes,

highly encourage you to all check out

our new Composer 2 model. We're all

really excited about it. And yes, this

recording will be shared after the call.

So, thanks everyone for joining.