Cursor’s Third Era: Cloud Agents

like, bottom model tier. We think that over the coming months, the big unlock is not going to be one person with a model getting more done, like the water flowing faster. It will be making the pipe much wider.

And so paralyzing more, whether that's swarms of agents or parallel agents, both of those are things that contribute to getting much more done in the same amount of time.

but they were sort of site reading code. Yeah. And those computers were not they were like blank VMs typically that were not set up for the DevX for whatever repo the agent's working on.

One of the things that we talk about is if you put yourself in the model shoes, and you were seeing tokens stream by, and all you could do was site recode and spit out tokens and hope that you had done the right thing No chance. I'd be so bad. Like, you've obviously, you need to run the code.

And so that, I think, also is probably not that contrarian of a take, but no one has done that yet. And so giving the model the tools to onboard itself and then use full computer use end to end pixels in, coordinates out, and have the cloud computer with different apps in it is the big unlock that we've seen internally in terms of use usage of this going from, oh, we use it for little copy changes, to no, we're really, like, driving new features with this kind of new type of agentic workflow. Alright.

Let's see it. Cool. So this is what it looks like in kershore.

com/agents. So this is one I kicked off a while ago. So on the left hand side is the chat, very classic sort of agentic thing.

The big new thing here is that the agent will test its changes. So you can see here it worked for half an hour. That is because it not only took time to write the tokens of code, it also took time to test them end to end.

So it started dev servers, iterate when needed. And so that's one part of it is, like, model works for longer and doesn't come back with a, I tried some things PR, but a, I tested at PR that's ready for your review. One of the other intuition pumps we use there is if a human gave you PR, asked you to review it, you hadn't they hadn't tested it, you'd also be annoyed because you'd be like, only ask me for a review once it's actually ready.

So that's what we've done with. Simple question I wanted to gather upfront. Some PRs are way smaller, like just copy change.

Does it always do the video or just sometimes? Sometimes. Okay.

So what's the judgment? The model does it. So we we do some default prompting with sort of what types of changes to test.

There's a slash command that people can do called slash no test, where if you do that, the model will not test. But the default is test? The default is to be calibrated, so we tell it don't test very simple copy changes, but test, like, more complex things.

And then users can also write their agents dot m d and specify, like, this type of if you're editing this sub part of my mono repo, never tested because that won't work or whatever. Okay. So pillar one is the model actually testing.

Pillar two is the model coming back with a video of what it did. We have found that in this new world where agents can end to end write much more code, reviewing the code is one of these new bottlenecks that crop up. And so reviewing a video is not a substitute for reviewing code, but it is an entry point that is much, much easier to start with than glancing at some giant diff.

And so, typically, you kick one off, you it's done, you come back, and the first thing that you would do is watch this video. So this is a video of it. In this case, I wanted a tool tip over this button, and so it went and showed me what that looks like in in this video that I think here it actually used a gallery.

So sometimes it will build storybook type galleries where you can see, like, that component in action. And so that's pillar two, is like these demo videos of what it built. And then pillar number three is I have full remote control access to this VM.

So I can go heat in here, I can hover things, I can type, I have full control, and same thing for the terminal. I have full access, and so that is also really useful because sometimes the video is like all you need to see, and oftentimes, by the way, the video's not perfect. The video will show you, is this worth either merging immediately or, oftentimes, is this worth iterating with to get it to that final stage where I am ready to merge in, so I can go through some other examples where the first video wasn't perfect, but it gave me confidence that we were on the right track, and two or three follow ups later, it was good to go.

And then I also have full access here, where some things you just wanna play around with. You wanna get a feel for what is this, and there's no substitute to a live preview, and the VNC kind of VM remote access gives you that. Amazing.

What sorry. What is VNC?

I was gonna say, is this only for front end? Exactly. One question you might have is this only for front end?

So this is another example where the thing I wanted it to implement was a better error message for saving secrets. So the Cloud agents support adding secrets. That's part of what it needs to access certain systems.

Part of onboarding that is giving access. On Cloud agents. Yes.

So this is a fun thing is It can get super meta. We can get super meta. It can start its own Cloud agents.

It can talk to its own Cloud agents. Sometimes it's hard to wrap your mind around that. We have disabled its Cloud Agents starting more Cloud Agents.

So we currently disallow that. Someday you might. Someday we might.

Someday we might. So this actually was mostly a back end change in terms of the error handling here, where if the secret is far too large, it would this is actually really cool. The DevTools.

That's the DevTools. So if the secret is far too large, we don't allow secrets above a certain size. We have a size limit on them.

And the error message there was really bad. It was just some generic failed to save message. So I was like, hey, we want an error message.

So first cool thing it did here, zero prompting on how to test this. Instead of typing out the, like, a character 5,000 times to hit the limit, it opens dev tools, writes JS or to paste into the input 5,000 characters of the letter a, and then hit save, closes the DevTools, hit save, and gets this new gets the new error message. So that looks like the video actually cut off.

But here you can see the here you can see the screenshot of the of the error message. So that is like front end, back end, end to end feature Yeah. To to get And You you just need a full VM, full computer, run everything.

Okay. Yeah. Yeah.

So we've had versions of this. This is one of the AutoTab lessons where we started that in 2022 no. In 2023.

And at the time, it was like browser use, DOM, like, all these different things. And I think we ended up very sort of AGI pilled in the sense that just give the model pixels, give it a box. A brain in a box is what you want, and you want to remove limitations around context and capabilities such that the bottleneck should be the intelligence.

And given how smart models are today, that's a very far out bottleneck. And so giving it its full VM and having it be onboarded with DevX setup like a human would has just been, for us internally, a really big step change in capability.

Alexei demoed the Cloud Agent that built that feature, which was funny because that was an instance where one of the things that's been a consequence of having these videos is we use best of n where you run head to head different models on the same prompt. We use that a lot more because one of the complications with doing that before was you'd run four models and they would come back with some giant diff, like 700 lines of code times four. So what are you gonna do?

You're gonna review all that? That's horrible. But if you come back with four twenty second videos, yeah, I'll watch four twenty second videos.

And then even if none of them is perfect, you can figure out, like, which one of those do you wanna iterate with to get it over the line. Yep. And so that's really been really fun.

Here's another example that we found really cool, which is we've actually turned since into a slash command as well, slash repro, where for bugs in particular, the model having full access to the to its own VM, it can first reproduce the bug, Make a video of the bug reproducing. Fix the bug. Make a video of the bug being fixed, like, doing the same pattern workflow with, obviously, the bug not reproducing.

And that has been the single category that has gone from, like, these types of bugs really hard to reproduce and takes you tons of time locally. Even if you tried a Cloud Agent on it, are you confident it actually fixed it to when this happens, you'll merge it in ninety seconds or something like that. So this is an example where let me see if this is the broken one or the okay, this is the fixed one.

Okay, so we had a bug on cursor.com/agents, where if you would attach images, remove them, and then still submit your prompt, they would actually still get attached to the prompt. Okay?

And so here you can see, Kershur is using its full desktop. By the way, this is one of the cases where if you just do browser use type stuff, you will have a bad time, because now it needs to upload files. Like, it just uses its native file viewer to do that.

And so you can see here, it's uploading files. It's going to submit a prompt, and then it will go and open up. So this is the meta.

This is CursorAgent prompting CursorAgent inside its own environment. And so you can see here, bug, there's five images attached, whereas when it submitted, it only had one image. I see.

Yeah. But you gotta enable that if you wanna use Cursor Agent inside Cursor Agent. Yeah.

And so here, this is then the after video where it went, it does the same thing. It attaches images, removes some of them, hit send, and you can see here, once this agent is up, only one of the images is left in the attachments. Yeah.

Beautiful. Okay. So easy merge.

Yeah. When does it choose to do this? Because this is an extra step.

Yes. I think I've not done a great job yet of calibrating the model on when to reproduce these things. Sometimes it will do it of its own accord.

Yeah. We've been conservative where we try to have it only do it when it's sure because it does add some amount of time to how long it takes it to work on it.

Here's an internal one that I've made. I don't know if anyone else at Cursor uses this one. Fix BB?

I've never heard of it. Yeah. Fix Bug Bot.

So this is a thing that we want to integrate more tightly. So you made this for yourself? I made this for myself.

It's actually available to everyone in the team, but Yeah. No one knows about it. But, yeah, there will be Bug Bot comments.

And so Bug Bot has a lot of cool things. We actually just launched Bug Bot Auto Fix, where you can click a button and or change a setting, and it will automatically fix its own things. And that works great in a bunch of cases.

There are some cases where having the context of the original agent that created the PR is really helpful for fixing the bugs because it might be like, oh, the bug here is that this is a regression, and actually, you meant to do something more like that, and so having the original prompt and all of the context of the agent that worked on it. And so here, I could just do fix or I used to be able to do fix PB and it would do that.

Yeah. I think that what it looks like to code with AI, code generally creates software, even if you wanna go higher level, is changing very rapidly. No.

Not a hot take. But I think from our vantage point at Cursor, I think one of the things that is probably underappreciated from the outside is that we are extremely self aware about that fact, and Cursor got its start in phase one, era one of, like, tab and auto complete, and that was really useful in its time. But a lot of people start looking at text files and editing code.

Like, we call it hand coding now when you, like, type out the actual letters. It's Oh, that's cute. Yeah.

Oh, that's cute. You're so boomer. So boomer.

And so that, I think, has been a slowly accelerating and now in the last few months, rapidly accelerating shift. And we think that's going to happen again with the next thing where the I think some of the pains around tab of it's great, but I actually just wanna give more to the agent and I don't want to do one tab at a time. I wanna just give it a task and it goes off and does a larger unit of work, and I can lean back a little bit more and operate at that higher level of abstraction.

the work that is left that the humans are discussing in these threads is the nugget of what is actually interesting and relevant. It's not the boring details of where does this if statement go. It's do we wanna ship this?

Is this the right UX? Is this the right form factor? How do we make this more obvious to the user?

where currently cursor won't chime in unless you explicitly at mention it. Yeah. So it's not always listening.

Yeah. I can see all the intermediate messages. Have you done the recursive can cursor at another cursor or spawn another cursor?

Oh. We've done some versions of this. Because we can add humans.

Yes. One of the other things we've been working on that's like an implication of generating the code is so easy is getting it to production is still harder than it should be. And broadly, you solve one bottleneck and three new ones pop up.

Yeah. And so one of the new bottlenecks is getting it to production. And we have a, like, joke internally where you'll be talking about some feature and someone says, I have a PR for that, which is it's so easy to get to I have a PR for that, but it's hard still relatively to get from I have a PR for that to I'm confident and ready to merge this.

And so I think that over the coming weeks and months, that's the thing that we think a lot about is how do we scale up compute to that pipeline of getting things from a first draft an agent did Is there no way merge. Isn't there what Graphite's for? Like, Graphite is a big part of that.

The cloud agent integrated or still different companies? Working on, I think we'll have more to share there in the future, but the goal is to have great end to end experience where Cursor doesn't just help you generate code tokens, it helps you create software end to end. And so review is a big part of that that I think, especially as models have gotten much better at writing code, generating code, we've felt that relatively crop up more.

Sorry.

more different aspects of how this feature might affect your code base that you want to potentially leverage an agent to help with. And some of those, like, bug baud will be synchronous and you'll typically want to wait on before you merge. But I think another thing that we're starting to see is, as with Cloud Agents, you scale up this parallelism and how much code you generate, 10 person startups become need the DevEx and pipelines that a 10,000 person company used to need.

And that looks like a lot of the things, I think, that 10,000 person companies invented in order to get that volume of software to production safely. So that's things like release frequently, release slowly, have different stages where you release, have checkpoints, automated ways of detecting regressions. And so I think we're gonna need merge diffs, merge queues.

Exactly. A lot of those things are going to be important. For what it's worth, I think the majority of people still don't know what stack diffs are.

Where historically, Cursor part of why we grew so quickly was anyone on the team could pick it up. And in fact, people would pick it up on the weekend for their side project and then bring it into work because they loved using it so much. Yeah.

And I think a thing that we've started working on a lot more, not us specifically, but as a company and other folks at Cursor, is making it really great for teams and making it that the tenth person that starts using Cursor in a team is immediately set up with things like we launched Marketplace recently, so other people can configure what MCPs and skills, like plug ins. So skills and MCPs, Other people can configure that so that my cursor is ready to go and set up. Sam loves the Datadog MCP and Slack MCP.

You've also been using a lot. I see. I'll also pre launch, but I feel like it's so good.

Yeah. My cursor should be configured if Sam feels strongly. That's just amazing and required.

agents, we expect to have similar kind of PLG things where I think off the bat, we've seen a lot of adoption with kind of smaller teams where the code bases are not quite as complex to set up. Yes. If you need some insane Docker layer caching thing for builds not to take two hours, that's going to take a little bit longer for us to be able to support that kind of infrastructure.

Whereas if you have front end, back end, like one click, agents can install everything that they need themselves.

almost. Like you rent a box. You rent a box.

Yes. We talk a lot about brain in a box. Yeah.

So Cursor, we want to be a brain in a box. But is the mental model different? Is it more serverless?

The main default way is actually snapshotting. Like a Linux VM. Like a VM.

Right? You run a bunch of install commands, and then you snapshot more or less the file system, and so that gets you set up for everything that you would want to bring a new VM up from that template, basically. Yeah.

actually is like half of what we had at peak, where we've decided to unship or unship quite a few things. So two of the interesting things to talk about. One is directly in answer to your question where we had native browser that you would have locally.

It was basically an iframe that via port forwarding could load the URL, could talk to local host in the VM. So that gets you So in your machine's browser. Like In your local browser Yeah.

You would go to local host 4,000, and that would get forwarded to local host 4,000 in the VM via port forwarding. We unshipped Like that an ngrok. Like an ngrok.

Exactly. We unshipped that because we felt that the remote desktop was sufficiently low latency and more general purpose. So we build Cursor web, but we also build Cursor desktop.

And so it's really useful to be able to have the full spectrum of things. And even for Cursor web, as you saw in one of the examples, the agent was uploading files. And, like, I couldn't upload files and open the file viewer if I only had access to the browser.

And we've thought a lot about this might seem funny coming from Cursor where we started as this Versus Code fork and I think inherited a lot of amazing things, but also a lot of legacy UI from Versus Code. And so with the web UI, we wanted to be very intentional about keeping that very minimal and exposing the right sum of set of primitive sort of app surfaces, we call them, that are shared features of that cloud environment that you and the agent both use. So agent uses desktop and controls it.

I can use desktop and control it. Agent runs terminal commands. I can run terminal commands.

So that's how our philosophy around it. The other thing that is maybe interesting to talk about that we unshipped is and we may both of these things, we may reship and decide at some point in the future that we've changed our minds on the trade offs or gotten it to a point where Put it out there. Let users tell you they want it.

Exactly. Alright. Fine.

So one of the other things is actually a files app. And so we used to have the ability at one point during the process of testing this internally to see next to I had git desktop and terminal on the right hand side of the tab there earlier to also have a files app where you could see and edit files. And we actually felt that in some ways by restricting and limiting what you could do there, people would naturally leave more to the agent and fall into this new pattern of delegating, which we thought was really valuable.

And there's currently no way in Cursor web to edit these files. Yeah. Except you, like, open up the PR and go to GitHub and do the thing Yeah.

Which is annoying. Just tell the agent.

they were like, no, just trust us. Yeah. I think we as Cursor will want to, as a product, offer the whole spectrum.

And so you want to be able to work at really high levels of abstraction and double click and see the lowest level. That's important. But I also think that, like, you won't be doing that in Slack.

And so there are surfaces and ways of interacting where, in some cases, limiting the UX capabilities makes for a cleaner experience that's more simple and drives people into these new patterns where even locally, we kicked off joking about this. People, like, don't really edit files, hand code anymore. And so we want to build for where that's going and not where it's been.

Lot of cool stuff. And okay.

where, like, I host my cursor site, or this which is basically a Versal clone. Right? I don't know.

I think that's an interesting question to be asking, and I think, like, the logic that you laid out for how you would get there is logic that I largely agree with. I think right now, we're really focused on what we see as the next big bottleneck, and because things like the Datadog MCP exist, I don't think that the best way we can help our customers ship more software is by building a hosting solution right now. By the way, these are things I've actually discussed with some of the companies I just named.

Yeah. For sure. Right now, just this big bottleneck is getting the code out there.

And, also, unlike a Lovable and the Bolt, we focus much more on existing software. And the zero to one greenfield is just a very different problem. Imagine going to a Shopify and convincing them to deploy on your deployment solution.

That's very different, and I think will take much longer to see how that works may never happen relative to, oh, it's like a zero to one app.

Yeah. Where we can suggest things to people. A thing that we have in the editor, the desktop app is auto, which will route your request and do things there.

Because I think we will want to do something like that for Cloud Agents as well. We haven't done it yet. And so I think we have both people like Sam who are very savvy and want know exactly what model they want.

And we also have people that want us to pick the best model for them because we have amazing people like Sam, and we we are the experts. Yeah. We have both the traffic and the internal taste and experience to know what we think is best.

Yeah. I have this ongoing thesis of agent lab versus model lab. And to me, Cursor and other companies are example of an agent lab that is building a new playbook that is different from a model lab where it's, like, very GPU heavy.

Although, as you obviously has a research team. And the my thesis is, you just every agent lab is going to have a router. You because you are going to be asked, like, what's what I don't keep up to every day.

I'm not a Sam.

are, one, the best event thing we mentioned, where running different models head to head is actually quite interesting because Which exists in cursor That exists in cursor IDE and web. So the problem is where do you run them? Okay.

And so I I can share my screen Yeah. Yeah. Yeah.

Yeah.

That would be my answer. So this is what that looks like, and so here in this dropdown picker, I can just select multiple models. Yeah.

And now if I do a prompt, I'm going to do something silly.

so the Cursor two point o, you can do desktop or cloud. And so this is cloud specifically where the benefit over WorkTrees is that they have their own VMs and can run commands and won't try to kill ports that the other one is running, which are some of the pains These are all cloud WorkTrees?

on different parallel agents that's interesting is an idea that's been around for a while as well, that has started working recently, is sub agents.

it might decide to spin up an explorer sub agent and or might decide to spin up five explorer subagents. But I don't get to set what those subagents are. Right?

It's all defined by the model. I think I actually would have to refresh myself on the subagent interface. So yeah.

Know. There are some built in ones, like the explorer subagent is pre prebuilt, but you can also instruct the model to use other subagents, and then it will. And one other example of a built in subagent is I actually just kicked one off in cursor, and I can show you what that looks like.

Yes. Because I tried to do this in pure prompt space. This is the desktop app.

And That's all you need to do. Right? Yeah.

That's all you need to do. So I said, use a sub agent to explore. And I think yeah.

So I can even click in and see what the sub agent is working on here. It ran some fine command. And this is Composer under the hood.

Even though my main model is Opus, it does smart routing to take, like, in this instance, the Explorer sort of requires reading a ton of things, and so a faster model is really useful to get an answer quickly. But that this is what sub agents look like, and I think we want to do a lot more to expose hooks and ways for people to configure these. Another example of a cuss sort of built in sub agent is the computer use sub agent in the Cloud Agents, where we found that those trajectories can be long and involve a lot of images, obviously, and execution of some testing verification task.

We want to use models that are particularly good at that, So that's one reason to use sub agents, and then the other reason to use sub agents is we want context to be summarized, reduced down at a sub agent level.

And if it's gonna go off and work for three minutes, that's one thing. When it's gonna go off and work for three days, probably should spend, like, a few hours upfront making sure that you have communicated what you actually want. Yeah.

And just to, like, really drive home the point, we really mean three days? No no hearing. Yeah.

We've had two days. Yeah. Yeah.

Yeah. So the thing that is available in Cursor, the long running agent, is if you want to think about it very abstractly, that is like one worker node, whereas what built the browser is a society of workers and planners and different agents collaborating. Because we started building the browser with one worker node.

At the time, that was just the agent, and it became one worker node when we realized that the throughput of the system was not where it needed to be to get something as large of a scale as the browser done. Yeah. And so this has also become a really big mental model for us with cloud cloud agents is there's the classic engineering latency throughput trade offs, and so, you know, the code is water flowing through a pipe.

The we think that over the coming months, the big unlock is not going to be one person with a model getting more done, like the water flowing faster, and we'll be making the pipe much wider. And so paralyzing more, whether that's swarms of agents or parallel agents, both of those are things that contribute to getting much more done in the same amount of time, but any one of those tasks doesn't necessarily need to get done that quickly. And throughput is this really big thing where if you see the system of a 100 concurrent agents outputting thousands of tokens a second, you can't go back.

Like, that just you see a glimpse of the future where, obviously, there are many caveats, like, one is using this browser IRL. There's, a bunch of things not quite right yet, but we are going to get to systems that produce real production code at the scale much sooner than people think. And it forces you to think, what even happens to production systems?

Like, we've broken our GitHub actions recently because we have so many agents, like, producing and pushing code that, like, CICD is just overloaded because suddenly it's, like, effectively regrew. Cursor's growing very quickly anyway, but you grow head count 10 x when people run 10 x as many agents. And so a lot of these systems exactly.

A lot of these systems will need to adapt.

It's like all these parallel rollouts and scheduling them and making sure as much throughput as possible goes through them. Yeah. It's the same thing.

We were talking briefly before we started recording. You were mentioning memory chips and some of the shortages there. The other thing that I think is just, like, hard to wrap your head around, the scale of the system that was building the browser, the concurrency there.

If Sam and I both have a system like that running for us shipping our software, the amount of inference that we're going to need per developer is just really mind boggling. And that makes sometimes when I think about that, I think that even with the most optimistic projections for what we're going to need in terms of build out are underestimating the extent to which these swarm systems can, like Yeah.

and I'm also doing more things. Yeah. Yeah.

I don't have the stats for myself, but I think broadly a thing that we've seen that we expect to continue is Javan's Paradox Yep. Where You can't do it in your podcast without seeing it. Exactly.

We've done it now. We can rap. We've done we said the words phase one, tab auto complete, people pay like $20 a month, and that was great.

Phase two, where you're iterating with these local models today, people pay, like, hundreds of dollars a month. I think as we think about these highly parallel kind of agents running off for a long time in their own VM system, we are already at that point where people will be spending thousands of dollars a month per human, and I think potentially tens of thousands beyond, where it's not like we are greedy for, like, capturing more money, but what happens is just individuals get that much more leverage. And if one person can do as much as 10 people, yeah, that tool that allows them to do that is going to be tremendously valuable and worth investing in and taking the best thing that exists.

Basically, I'm asking this for other people. Right? Yeah.

Totally. Totally. To hear Sam's opinion, we haven't talked about this, the two of us.

I think that we don't see necessarily being great at the latest thing with AI coding as a prerequisite. I do think that's a sign that people are keeping up and curious and willing to upscale themselves in what's happening because as we were talking about the last three months, the game has completely changed. It's like what I do all day is very different.

Like, it's my job and I can't. Yeah. Totally.

I do think that still, as Sam was saying, the fundamentals remain important in the current age and being able to go and double click down. And models today do still have weaknesses where if you let them run for too long without cleaning up and refactoring, the code will get sloppy and there'll be bad abstractions. And so you still do need humans that, like, have built systems before, no good patterns when they see them and know where to steer things.

Yeah. I would agree with that.

Predictions are not going to go well. I know. It's hard.

They're so hard. You did it wrong. It's okay.

Just One other plug that may be interesting that I feel like we touched on but haven't talked a ton about is a thing that the kind of these new interfaces and this parallelism enables is the ability to hop back and forth between threads really quickly. And so a thing that we have You wanna show something? Or Yeah.

I can show something. A thing that we have felt with local agents is this pain around context switching, and you have one agent that went off and did some work and another agent that that did something else. And so here, by having I just have three tabs open, let's say, but I can very quickly hop in here.

This is an example I showed earlier, but the actual workflow here, I think, is really different in a way that may not be obvious where I start the morning, I kick off 10 agents or something. The first one of them finishes, come in, watch the video. Either is close, and so I might send a follow-up.

I might say, hey, make it red, or I might hop into the desktop and try it out, and within ninety, a hundred twenty seconds, I've kicked this one back off and either started the merge process, like CI is running now, and I'll come back to it later, or it's off with some additional follow-up information, and then I can hop into the next one. And then the next one, I hop in and I'm like, okay, this looks interesting. Actually, try it out for real in the app.

I want to see it in action, not just in the gallery. So I can kick that off and the agent will go and work on that because maybe I wanted to try it out, like, what the button looks like in the actual thing. And then here I might hop in as well and check the video here or do something.

And so you're really parallelizing much more and follow-up here, check-in there. It's much more this higher level of abstraction and having the different desktops where you can hop back and forth, and you're not like, oh, I checked out this branch. Oh, where was that work tree again?

Yeah. It's really like solving for that, which we've ourselves have struggled with in Cursor and these local agents to be like, where was that diff again? It's lost in some work tree.

Never gonna find it. Oh, my local thing is rebuilding. Oh, just make another one.

That that's what you end up with. And then you wait for five more minutes for it to run. And so this is really like a new way of just paralyzing that we found to be really fun, honestly Yeah.

Where you're just hopping in and injecting taste. And you're like, that doesn't quite feel right. Oh, actually, is not architected quite right.

But you're just focusing on those, like, taste interesting questions. And for me, the cloud ecosystem too also enabled this to be, like, something that is, like, adding productivity to my dead time, like, commuting or, like, overnight or something like that. The fact that I don't have to leave my computer open.

There's no cursor there is a cursor mobile app. If there is, I'm not sure. It's, the current thing.

We I use it on my phone all the time, just on the web.

Yep. And it's all based on a coding agent based. Totally.

And I think one of the things that like talking to friends and family that are not in the software world that's interesting is I do, speaking of predictions, I do think that we are going to start to see other industries go through what software development has started going through. I think by virtue of how good models are at writing software and how early adopter the people building the new technology are and trying it out and applying it to themselves, that certain kinds of shifts will happen too to other industries. And there's a lot to be learned from how that's gone down and is continuing to go down in software in terms of all the interesting questions about to what point do people get more leverage?

When do you start changing the role to become much more generalist? Like all of these questions that we've seen some data on, but we'll see a lot more in the coming months, that will happen everywhere. Sam, any parting thoughts?

bare intent transfer that like telling the agent what I want. It's like writing an essay where I don't use agents to write essays yet because the process of writing it is the thinking. I still can't stand AI generated writing.

So yeah, I can also can't have the agent write prompts.

But, like, the brain dump is good. Yeah. Because you can interrupt yourself, you can go on a tangent, whatever.

It just captures everything Yeah. And slop it into all of them. It's fine.

Yeah. The way that we did this with AutoTab was people would record full screen recordings with audio to teach the model, like, how to do a task.

that kind of stuff. But at some point, it's gonna hit voice coding. Yeah.

I have a prediction for you. Yeah. I predict that by the end of the year, the volume on I think it will take longer than people think and longer than we think for cloud and agents working in their own boxes to surpass local agents.

But I think that crossover will happen before the end of the year, and probably by the end of the year, agents running in the cloud will be a multi like, more than two x the volume of local agents.

Yeah. There's a bunch of hard things. So one of them is just getting those sandboxes to be really good.

And the thing that was part of this launch that we spent an inordinate amount of time on is cursor.com/onboard, where you pick a repo, add secrets, give it access to things, and the agent just goes off and installs things. Yes.

I think all the whole thing, that was my favorite. Yeah. We worked a lot on that.

Sam and I in particular, spent a lot of late nights just making that good. But there's still a lot to do there. Right?

Set up one two two things maybe. It's too slow. It's too slow working on it.

Setup is not like a unitary thing where everything is set up or not. Right? Like things will break over time.

You have new dependencies. You need access to new systems. Like you change where your database lives.

So that's one part of it. And then the other part of it is having these agents run-in the cloud and be more autonomous. We've really started to see the lack of memory.

And Sam, as someone who's thought a lot about this, once you start getting the model kind of doing operating the code base, there's more particularities that are not it's not just a read file tool. It needs to know how do I start up the back end? How do I check the status of the back end?

That's very particular to your code base. And even if it's great at NPM, run watch, or whatever the default things are, there's always quirks. Everyone has quirks, And getting the model good at those things will require more work, and we're working on that.

and decide how to fill them. That's such a good point. Like, self awareness broadly has been a really big thing that I think Sam has pushed us to do more and more of where the agent should understand how its environment works.

It should understand how secrets work. Like, it needs to be self aware about its own harness and its environment. And anything that's not inherent in the model, you have to do Specifics.

Right? If it's running in cursor versus some other sandbox, that's a bit different.