Cursor 的第三时代：云端 Agent——Sam Whitmore、Jonas Nelle、Cursor

So this is another experiment that we ran last year and didn't decide to ship at that time, but may come back to: an LLM judge that was also agentic and could write code. It wasn't just picking; it was also taking the learnings from 2 models that it was looking at and writing a new diff.

What we found was that there were strengths to using models from different model providers as the base level of this process. Basically, you could get an almost synergistic output that was better than having a very unified bottom-model tier.

Alessio Fanelli

We think that over the coming months, the big unlock is not going to be 1 person with a model getting more done, like the water flowing faster. We'll be making the pipe much wider and parallelizing 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.

This week, 1 of the biggest launches that Cursor has ever done is Cloud Agents. I think you had Cloud Agents before, but this was like, well, you give Cursor a computer, right?

So is this basically that they bought Autotab and then repackaged it? Is that what's going on?

That's a big part of it. Cloud Agents already ran on their own computers, but they were sort of sight-reading code. Those computers were typically blank VMs that weren't set up for the DevEx of whatever repo the agent was working on.

If you put yourself in the model's shoes and you were seeing tokens stream by, all you could do was sight-read code, spit out tokens, and hope that you had done the right thing—

No chance.

I'd be so bad. Obviously, you need to run the code. I think that's probably not that contrarian of a take, but no one has done that yet.

Giving the model the tools to onboard itself and then use full computer use end to end—pixels in, coordinates out—and having the cloud computer with different apps in it is the big unlock that we've seen internally. Usage has gone from, “Oh, we use it for little copy changes,” to, “No, we're really driving new features with this kind of new agentic workflow.”

All right, let's see it.

Cool. This is what it looks like at cursor.com/agents. This is 1 I kicked off a while ago. On the left-hand side is the chat, which is a very classic sort of agentic interface.

The big new thing here is that the agent will test its changes. You can see here that it worked for half an hour. That's because it not only took time to write the code, it also took time to test it end to end. It started the dev servers and iterated when needed.

That's 1 part of it: the model works for longer and doesn't come back with an “I tried some things” PR, but an “I tested it” PR that's ready for your review. 1 of the other intuition pumps we use is that if a human gave you a PR, asked you to review it, and hadn't tested it, you'd also be kind of annoyed. You'd be thinking, “Only ask me for a review once it's actually ready.”

Some PRs are way smaller, like just a copy change. Does it always do the video, or is it sometimes?

Sometimes.

Okay. So what's the judgment?

The model does it. We do some default prompting with the types of changes to test. There's a slash command called `/no-test`; if you use that, the model won't test, but the default is to test.

The default is calibrated. We tell it not to test very simple copy changes, but to test more complex things. Users can also write their `AGENTS.md` and specify, for example, “If you're editing this subpart of my monorepo, never test it because that won't work,” or whatever the relevant instruction is.

So pillar 1 is the model actually testing. Pillar 2 is the model coming back with a video of what it did. We've found that in this new world, where agents can write much more code end to end, reviewing the code is 1 of these new bottlenecks that crops up.

Reviewing a video isn't a substitute for reviewing code, but it's an entry point that's much easier to start with than glancing at some giant diff. Typically, you kick 1 off, it's done, and you come back. The first thing you do is watch the video.

This is a video of it. In this case, I wanted a tooltip over this button, and it went and showed me what that looks like in the video. I think here it actually used a gallery. Sometimes it will build Storybook-type galleries where you can see that component in action.

That's pillar 2: these demo videos of what it built. Pillar 3 is that I have full remote-control access to this VM. I can go in here, hover over things, type, and have full control. The same thing applies to the terminal, so I have full access.

That's also really useful because sometimes the video is all you need to see. Oftentimes, the video will show you whether something is worth merging immediately or whether it's worth iterating on to get it to that final stage where you're ready to merge it.

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. After 2 or 3 follow-ups, it was good to go.

I also have full access here, because sometimes you just want to play around with something and get a feel for it. There's no substitute for a live preview, and the VNC remote access to the VM gives you that.

What is VNC?

It's just the remote desktop.

Sam, any other details that you always want to call out?

The videos have been super helpful for me, especially in cases where a common problem with agents and Cloud Agents beforehand was underspecification in my requests.

Our plan mode, and going back and forth to get a detailed implementation spec, is 1 way to reduce the risk of underspecification. But, similar to how human communication breaks down over time, you have this risk where it's like, “Okay, when I go to the trouble of pulling down and running this branch locally, I'm going to see that I said this should be a toggle and you have a checkbox. Why didn't you get that detail right?”

Having the video up front makes that alignment—the shared artifact you're talking about with the agent—very clear. That's been super helpful for me.

I can quickly run through some other examples. This is a very front-end-heavy 1.

I was going to say, is this only for the front end?

Exactly. 1 question you might have is whether this is only for the front end. Here's another example where what I wanted it to implement was a better error message for saving secrets.

Cloud Agents support adding secrets. That's part of what it needs to access certain systems. Part of onboarding it is giving—

Claude is working on Cloud Agents.

Yes. This is a fun thing: it can get super meta. It can start its own Cloud Agents and talk to its own Cloud Agents. Sometimes it's hard to wrap your mind around that.

We have disabled its ability to start more Cloud Agents. We currently disallow that.

Someday you might.

Someday we might.

This was mostly a back-end change in terms of the error handling. 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 was really bad. It was just some generic “Failed to save” message, so I asked for a better error message.

The first cool thing it did here was test it with zero prompting on how to do so. Instead of typing a character 5,000 times to hit the limit, it opened DevTools, wrote JavaScript to paste 5,000 characters of the letter A into the input, and then hit Save. It closed DevTools, hit Save, and got the new error message.

It looks like the video actually cut off, but here you can see a screenshot of the error message. That's a front-end, back-end, end-to-end feature.

You just need a full VM, a full computer, and to run everything, right?

Yeah. We've had versions of this before. This is 1 of the Autotab lessons. We started that in 2023, and at the time it was browser use, the DOM, and all these different things.

I think we ended up very AGI-pilled, in the sense that you just give the model pixels and give it a box. A brain in a box is what you want. You want to remove limitations around context and capabilities so that the bottleneck is the intelligence.

Given how smart models are today, that's a very far-out bottleneck. Giving it a full VM and having it onboarded with the DevEx set up like a human would has been a really big step change in capability for us internally.

Let's call it a year ago: the models weren't even good enough to do any of this stuff.

Even 6 months ago.

What people have told me is that around Sonnet 4.5 is when this started being good enough to automate fully by pixel.

Yeah. I think it’s always a question of when it’s good enough. I think we found, in particular, with Opus 4.5, 4.6, and Codex 5.3, that those were additional step changes in the autonomy-grade capabilities of the model to just go off, figure out the details, and come back when it’s done.

I want to appreciate a couple of details. One: TanStack Router. I see it. I’m a big fan. Do you know why I have to name the TanStack?

No.

This is just random lore: somebody named Sue Tanner. And then the other thing—if you switch back to the video—

Yeah.

So I want to shout out this thing. Probably Sam did it. I don’t know the chapters.

Oh, this is—yeah, this is called Chapters. It’s like a Vimeo thing. I don’t know. But it’s so nice, the design details. Obviously, a company called Cursor has to have a beautiful cursor.

And it is the Cursor cursor. You see it—Cursor. Yeah, yeah. Okay, cool. And then I was like, “You know, I complained to Evan. I was like, ‘Okay, you guys branded everything but the wallpaper.’” And he was like, “No, that’s a Cursor wallpaper.”

I was like, “What?”

Alessio Fanelli

Yeah. Rio picked the wallpaper. I think the video was probably Alexi and a few others on the team, with the chapters on the video. Matthew Fria—there’s been a lot of teamwork on this. It’s been a huge effort.

I just like design details. When you download it, it adds a little Cursor TikTok clip.

Alessio Fanelli

Yes, yes. It’s to make it really obvious that it’s from Cursor. We did the TikTok branding at the end. This was actually in our launch video. Alexi demoed the cloud agent that built that feature, which was funny because one of the consequences of having these videos is that we use Best-of, where you run different models head-to-head on the same prompt, a lot more.

One of the complications with doing that before was that you’d run 4 models and they would come back with some giant diff—700 lines of code times 4. What are you going to do? You’re going to review all of that? It’s horrible. But if you come back with 4 20-second videos, you can watch 4 20-second videos, and even if none of them is perfect, you can figure out which one you want to iterate with to get it over the line. That’s been really fun.

Here’s another example that we found really cool. We’ve actually turned it into a slash command as well: `/repro`. For bugs in particular, with the model having full access to its own VM, it can first reproduce the bug, make a video of the bug reproducing, fix the bug, and make a video of the bug being fixed—doing the same workflow, with the bug no longer reproducing.

That has been the single category that has gone from bugs that are really hard to reproduce and take you tons of time locally—even if you tried a cloud agent on them, you weren’t confident it actually fixed them—to, “When this happens, you’ll merge it in 90 seconds.”

This is an example. Let me see if this is the broken one or the—okay, this is the fixed one. We had a bug on cursor.com/agents where, if you attached images, removed them, and then still submitted your prompt, they would actually still get attached to the prompt.

Here you can see Cursor is using its full desktop. This is one of the cases where, if you just do browser-use-type stuff, you’ll have a bad time because it needs to upload files. It just uses its native file viewer to do that. You can see here it’s uploading files, submitting a prompt, and then opening up.

This is the meta: this is Cursor Agent prompting Cursor Agent inside its own environment. You can see here that there are 5 images attached, whereas when it submitted, it only had 1 image.

I see. But you’ve got to enable that if you’re going to use Cursor Agent inside Cursor.

Alessio Fanelli

Exactly. And so here is the after video, where it does the same thing. It attaches images, removes some of them, hits Send, and you can see that once the agent is done, only 1 of the images is left in the attachments.

Yeah. Beautiful. Okay. So easy to merge.

Alessio Fanelli

Yeah.

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

Alessio Fanelli

Yes. I don’t think I’ve done a great job yet of calibrating the model on when to reproduce these things. Sometimes it will do it of its own accord. We’ve been conservative and tried to have it do this only when it’s quite sure, because it does add some amount of time to how long it takes to work on the issue.

But we’ve also added things like the `/repro` command, where you can just say, “Fix this bug—repro,” and it will know that it should first make you a video of it finding and making sure it can reproduce the bug.

Yeah. One ML topic this ties into is reward hacking. You write tests that only pass, right? So first write a test that shows me it fails, and then make your test pass, which is a classic red-green—

Alessio Fanelli

TDD.

TDD thing, right? Very cool. Was that the last demo? Is there anything else?

Alessio Fanelli

Yeah. Anything I missed on the demos or points?

That covers it well. Cool.

Before we stop the screen share, can you give me a tour of the slash commands? There are so many, and I’m like, “What are the good ones?”

Alessio Fanelli

Yeah, we want to increase discoverability around this, too. That will be a future thing we work on, but there’s definitely a lot of good stuff. We have a lot of internal ones that I don’t think will be that interesting. Here’s an internal one that I made. I don’t know if anyone else at Cursor uses this one: `/fix-bb`.

I’ve never heard of it.

Alessio Fanelli

Yeah, Fix Bugbot. It's actually available to everyone on the team, but no one knows about it. This is something that we want to integrate more tightly. You’ll get Bugbot comments, and Bugbot has a lot of cool things. We just launched Bugbot Autofix, where you can click a button or change a setting and it will automatically fix its own issues. 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. It might be, “The bug here is that this is a regression, and actually you meant to do something more like that.” Having the original prompt and all the context of the agent that worked on it is really useful. I used to be able to do `/fix-bb`, and it would do that.

`/no-test` is another one that we’ve had. `/repro` is in here; we mentioned that one.

One of my favorites is Cloud Agent Diagnosis.

This is one that makes heavy use of the Datadog MCP. I think Nick and David on our team wrote it, and basically, if there is a problem with a cloud agent, we’ll spin up a bunch of sub—

Alessio Fanelli

A single instance?

Yeah. We’ll take the idea as an argument and spin up a bunch of sub-agents using the Datadog MCP to explore the logs and find all of the problems that could have happened with that. It takes the debugging time from potentially—although you can do quick stuff quickly with the Datadog UI—it takes it down to a single agent call, as opposed to trawling through logs yourself.

You should also talk about the stuff we’ve done with transcripts.

Alessio Fanelli

Yes, also. We’ve done some things internally, and there will be public versions of this soon, where you can spin up an agent and give it access to another agent’s transcript to either debug something that happened—acting as an external debugger—or continue the conversation, almost like forking it.

A transcript includes all the chain of thought for the 11 minutes here, 45 minutes there?

Alessio Fanelli

Exactly. It acts as a secondary agent that debugs the first. We’ve started to push—

And they’re all the same code, just different prompts, but the same—

Alessio Fanelli

Yeah. Basically, the same cloud agent infrastructure and the same harness. When we include an external transcript as an attachment, there’s some extra infrastructure that goes into piping it in.

For things like Cloud Agent Diagnosis, it’s mostly just using the Datadog MCP, because we also launched MCPs along with this cloud agent launch—support for cloud agent MCPs.

Oh, that was drawn out.

Alessio Fanelli

We’ll be doing a bigger marketing moment for it next week.

And you can now use MCPs. People who listen to this will be ahead of the curve.

Alessio Fanelli

Yeah, you’ll be ahead. I actually don’t know if the Datadog MCP is publicly available yet. I realized this over beta testing it, but it’s been one of my favorites to use.

I think that one’s interesting for Datadog because Datadog wants to own that side, right? With Bits. I don’t know if you’ve tried Bits.

Alessio Fanelli

I haven’t tried Bits.

Yeah, that’s their cloud agent product.

Alessio Fanelli

They want to be like, “We own your logs. Give us some part of the self-healing software that everyone wants.”

Yeah, but obviously Cursor has a strong opinion on coding agents, and you’re taking away from that—which you’re obviously going to do. Not every company is like Cursor, but it’s interesting if you’re Datadog. What do you do here? Do you expose your logs to MCP and let other people do it, or do you try to own that because it’s extra business for you? It’s an interesting one.

Alessio Fanelli

It's a good question. All I know is that I love the Datadog MCP. It's going to be no surprise that people will demand it, right?

Yeah, it is. It's like any system-of-record company: how much do you give away, you know? Cool, I think that's it for the sort of Cloud Agents tour. When did Cloud Agents launch? Do you know?

Alessio Fanelli

June last year.

June last year. So it's been a slowly developing thing. You did a bunch of—Michael did a post for himself where he showed this chart of agents overtaking Tab, right?

Alessio Fanelli

Right?

And I'm like, “Wow, this is the biggest transition in code.” It feels like the biggest transition in code in a very long time.

Alessio Fanelli

Yeah, I think that kind of got drowned out.

Yeah.

No, I think it's been highlighted by our friend Andrej Karpathy today.

Alessio Fanelli

Okay.

Talk more about it. What does it mean? I just got given the Cursor Tab key.

Alessio Fanelli

Yes. Yes.

That's cool.

Alessio Fanelli

I know. It's going to be put in a museum.

It is. I have to say, I haven't used Tab in a little bit myself.

Alessio Fanelli

Yeah. I think that what it looks like to code with AI, or create software generally, even if you want to go higher level, is changing very, very rapidly. Not a hot take, but I think from our vantage point at Cursor, one of the things that is probably underappreciated from the outside is that we are extremely self-aware about that fact.

Cursor got its start in phase 1, era 1, with Tab and autocomplete. That was really useful in its time, but a lot of people are starting to look at text files and editing code—what we call hand-coding now.

Like, “Oh, that's cute.”

Alessio Fanelli

Yeah. “Oh, that's cute.”

You're so boomer.

Alessio Fanelli

So boomer. I think that has been a slowly accelerating—and now, in the last few months, rapidly accelerating—shift. We think that's going to happen again with the next thing, where some of the pain around Tab is, “That's great, but I actually just want to give more to the agent. I don't want to do one Tab at a time. I want to 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.”

That's going to happen again, where it goes from agents handing you back diffs and you're sort of in the weeds, giving it 30-second to 3-minute tasks, to giving it 3-minute, 30-minute, or 3-hour tasks. You're getting back videos and trying out previews rather than immediately looking at diffs every single time.

Yeah. Anything to add?

Alessio Fanelli

One other shift that I've noticed as our cloud agents have really taken off internally has been a shift from primarily individually driven development to almost this collaborative nature of development. For us, Slack is actually almost like a development IDE, basically.

That's why I'm like, maybe don't even build a custom UI. Maybe that's a debugging thing, but actually it's Slack.

Alessio Fanelli

I know. There's a lot more to do with our Slack surface area to show people externally. Basically, Slack is where a lot of development happens for us. We'll have issue channels or product discussion channels where people are always Cursor-ing, and that kicks off a cloud agent.

For us, at least, we have team follow-ups enabled. So if Jonas kicks off a Cursor task in a thread, I can follow up with it and add more context. It turns into almost like a discussion service where people can collaborate on the UI. Oftentimes, I'll kick off an investigation and ask it to run `git blame`, then tag people who should be brought in, because it can tag people in Slack.

It can tag other people who aren't involved in the conversation.

Alessio Fanelli

It can just do @Jonas.

Yeah.

Alessio Fanelli

Yeah. That's cool. Basically, it can bring other people in, and then other people can contribute to that thread. You can end up with a PR, with the artifacts visible, and people can be like, “Okay, cool, we can merge this.” So for us, the IDE is almost moving into Slack in some ways as well.

I have the same experience, but it's not developers. It's me, designers, and salespeople.

Alessio Fanelli

Yeah. For me, it's technical marketing and vision; the designer works on design; and salespeople contribute the legal terms of what we agreed on. They all just collaborate and correct the agents.

I think what we found is that the work left for humans to discuss in these threads is the nugget of what is actually interesting and relevant. It's not the boring details of where an `if` statement goes. It's, “Do we want to ship this? Is this the right UX? Is this the right form factor? How do we make this more obvious to the user?” Those are the really interesting, higher-order questions that are so easy to collaborate on while leaving the implementation to the cloud agent.

Totally. And no more discussion of, “Am I going to do this? Are you going to do this?” Cursor is doing it. You just have to decide whether you like it.

Sometimes you need a mute button. Cursor is like, “We're going to take this offline”—still online, but we need to talk among the humans first before you stop responding to everything, right?

Alessio Fanelli

Yeah. This is a design decision. Currently, Cursor won't chime in unless you explicitly @mention it.

Yeah.

Alessio Fanelli

So it's not always listening.

Yeah, yeah.

Alessio Fanelli

Well, it can see all the intermediate messages.

Have you done the recursive thing? Can Cursor @ another Cursor or spawn another Cursor?

Alessio Fanelli

Oh, we've done some versions of this, because it can add humans. One of the other things we've been working on, as an implication of generating code being so easy, is that getting it to production is still harder than it should be.

Broadly, you solve one bottleneck and 3 new ones pop up. One of the new bottlenecks is getting it to production. We have a joke internally where you'll be talking about some feature and someone says, “I have a PR for that.” It's so easy to get to “I have a PR for that,” but it's still relatively hard to get from “I have a PR for that” to “I'm confident and ready to merge this.”

I think that over the coming weeks and months, that's something we think a lot about: how do we scale up compute for the pipeline of getting things from a first draft an agent did to something that's ready for production?

I mean, isn't that what Graphite's for?

Graphite is a big part of that. Is the Cloud Agent fully integrated, or are they still different companies working on it?

Alessio Fanelli

I think we'll have more to share there in the future, but the goal is to have a great end-to-end experience where Cursor doesn't just help you generate code tokens; it helps you create software end to end. Review is a big part of that. Especially as models have gotten much better at writing and generating code, we've felt that need crop up more.

Sorry, this was completely unplanned, but I have people arguing one school of thought that you need AI to review AI.

Alessio Fanelli

And then there's another school of thought where reviews are dead. “Just show me the video.”

Yeah. I feel like, for me, the video is often about alignment, and I still often want to go through a code review process and look at the files.

Alessio Fanelli

There's a spectrum, of course. If the video is really well done and it fully tests everything, you can feel pretty confident, but it's still helpful to look at the code.

I pay a lot of attention to BugBot. BugBot has been really highly adopted internally. We often tell people, “Don't leave BugBot comments unaddressed,” because we have such high confidence in it. So people always address their BugBot comments.

Once you've had 2 cases where you merged something, went back later, and found a bug—and BugBot had found it and you should have listened to BugBot—once that happens 2 or 3 times, you learn to wait for BugBot.

Alessio Fanelli

Yeah. For us, there's code-level review, where it's looking at the actual code, and feature-level review, where you're looking at the features. There are a whole number of different areas. Eventually, there will probably be things like performance-level review and security review—different aspects of how a feature might affect your codebase that you want to potentially leverage an agent to help with.

Some of those, like BugBot, will be synchronous, and you'll typically want to wait for them before you merge. But another thing we're starting to see is that, as cloud agents scale up parallelism and the amount of code you generate, 10-person startups 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 10,000-person companies invented in order to get that volume of software to production safely. So that's things like releasing frequently, releasing slowly, having different stages where you release, having checkpoints, and automated ways of detecting regressions. I think we're going to need—

Stacked diffs, merge queues.

Alessio Fanelli

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 stacked diffs are. I have many friends at Facebook, and I'm pretty friendly with Graphite. I've just never needed it because I don't work on that larger team. It's just the democratization of, “Here's what we've already worked out at very large scale, and here's how it benefits you, too.”

To me, one of the beautiful things about GitHub is that it's actually useful to me as an individual solo developer, even though it's collaboration software.

Alessio Fanelli

Yep.

I don't think a lot of dev tools have figured that out yet—that transition from large down to small.

Alessio Fanelli

Yeah.

Cursor is probably an inverse story.

Alessio Fanelli

Historically, part of why Cursor grew so quickly was that anyone on the team could pick it up. 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.

Alessio Fanelli

One thing that we've started working on a lot more—not us specifically, but as a company and with other folks at Cursor—is making it really great for teams, and making it so that the 10th person who starts using Cursor on a team is immediately set up with things like Marketplace. We launched Marketplace recently, so other people can configure which MCPs and skills—plugins, essentially—are available. That way, my Cursor is ready to go and set up.

Sam loves the Datadog MCP and Slack MCP. You've also been using a lot—

That's also pre-launch, but I feel like it's so good. Yeah, my Cursor should be configured if Sam feels strongly that it's amazing and required. Is it automatically shared, or do you have to go and—

Alessio Fanelli

It depends on the MCP. Some are obviously per-user, so Sam can't authenticate my Cursor with my Slack MCP. But some are team-owned, and those can be set up by admins.

Yeah, yeah, that's cool. We had Aman on the pod when Cursor was 5 people, and everyone was like, “Okay, well, what's the thing?” Then it's usually something about teams, orgs, and enterprise.

Alessio Fanelli

But it's actually working. Usually at that stage, when you're 5, when you're just a VS Code fork, it's like—

How do you get there?

Alessio Fanelli

Will people pay for this? People do pay for it.

Yeah.

Alessio Fanelli

And I think for cloud agents, we expect to have similar kinds of product-led growth things. Off the bat, we've seen a lot of adoption with smaller teams, where the codebases aren't quite as complex to set up. If you need some insane Docker layer-caching thing for builds not to take 2 hours, that's going to take a little bit longer for us to support. Whereas if you have a frontend and backend, with one click, agents can install everything they need themselves.

This is a good chance for me to ask some technical, check-the-box questions. Can I choose the size of the VM?

Alessio Fanelli

Not yet. We are planning on adding that. We have—

Because obviously you want L, XXL, whatever, right? It's like the Amazon menu.

Alessio Fanelli

Yes, exactly. We will add that.

In some ways, you have to basically become like EC2—you rent a box.

Alessio Fanelli

You rent a box. Yes. We talk a lot about “brain in a box.” So Cursor, we want to be a brain in a box.

But is the mental model different? Is it more serverless? Is it more persistent? Is it something else?

Alessio Fanelli

We want it to be a bit persistent. The desktop should be something you can return to even after a few days. Maybe you go back and it's still thinking about a feature for some period of time.

Fully suspend the memory and bring it back, then keep going.

Alessio Fanelli

Exactly.

What I actually do want from OpenClaw or whatever is to be able to log in with my credentials to the thing, but not actually store them in any secret store, because this is my most sensitive stuff. This is my email, whatever. I just want to have it persist through the image, rehydrate, and keep going from there.

But I don't think a lot of infrastructure works that way. A lot of it is stateless, where you save it to a Docker image, and it's only whatever you can describe in a Dockerfile, because that's the only thing you can clone multiple times in parallel.

Alessio Fanelli

Yeah, we have a bunch of different ways of setting them up. There's a Dockerfile-based approach. The main default way is actually snapshotting a Linux VM. You run a bunch of install commands, and then you snapshot more or less the filesystem. That gets you set up for everything you'd want to bring a new VM up from that template, basically.

That's a bit distinct from what Sam was talking about with hibernating and rehydrating, where that is a full memory snapshot as well. So if I had the browser open to a specific page and we brought that back, that page would still be there.

Was there any discussion internally about building this stuff where, every time you show the video, you show a little bit of the desktop and the browser, and it's kind of not necessary? If you're just demoing a frontend application, why not just show the browser?

Alessio Fanelli

We do have some panning and zooming. It can decide that when it's actually recording and cutting the video, to highlight different things. I think we've played around with different ways of segmenting it.

Yeah, there have been some different revisions on it for sure.

Alessio Fanelli

Yeah, I think one of the interesting things is that the version you see now on Cursor.com is actually half of what we had at peak, because we've decided to unship quite a few things.

Two interesting things to talk about: one is directly in answer to your question. We had a native browser that you would have locally. It was basically an iframe that, via port forwarding, could load the URL and talk to localhost in the VM. So that gets you basically—

In your machine's browser—

Alessio Fanelli

In your local browser. You would go to localhost:4000, and that would get forwarded to localhost:4000 in the VM via port forwarding. We unshipped that—

Like an ngrok.

Alessio Fanelli

Like an ngrok, exactly. We unshipped that because we felt that the remote desktop was sufficiently low-latency and more general-purpose. So we built Cursor Web, but we also built Cursor Desktop, and it's really useful to be able to have the full spectrum of things.

Even for Cursor Web, as you saw in one of the examples, the agent was uploading files, and I couldn't upload files and open the file viewer if I only had access to the browser. We've thought a lot about this. It might seem funny coming from Cursor, where we started as this VS Code fork. I think we inherited a lot of amazing things, but also a lot of legacy UI from VS Code.

With the web UI, we wanted to be very intentional about keeping it minimal and exposing the right set of primitive app surfaces—we call them—that are shared features of that cloud environment that you and the agent both use. The agent uses the desktop and controls it; I can use the desktop and control it. The agent runs terminal commands; I can run terminal commands. So that's our philosophy around it.

The other thing that's maybe interesting to talk about that we unshipped—and we may reship both of these things and decide at some point in the future that we've changed our minds on the trade-offs or gotten them to a point where—

Get it out there; let users tell you they want it.

Alessio Fanelli

Exactly. One of the other things is actually a Files app. At one point during internal testing, we had the ability to see, next to the desktop and terminal on the right-hand side of the tab there, a Files app where you could see and edit files.

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. So there's currently no way in Cursor Web to edit these files.

Yeah, except you open up the PR, go to GitHub, and do the thing.

Alessio Fanelli

Yeah, which is annoying.

Just tell the agent. I've criticized OpenAI for this because OpenAI's Codex app doesn't have a file editor. It has a file viewer, but isn't it a file editor? Do you use the file viewer a lot? No, I understand. But sometimes I want it. The only way to do it is to freaking go in the—

Alessio Fanelli

No, they have an Open in Cursor button, or Open in Antigravity, or opening whatever.

And people pointed that out. I was part of the early testers group. People pointed that out, and they were like, “This is a design smell.” It's like you actually want a VS Code fork that has all these things, but also a file editor, and they were like, “No, just trust us.”

Alessio Fanelli

Yeah. I think we as Cursor will want to, as a product, offer the whole spectrum. 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 you won't be doing that in Slack.

There are surfaces and ways of interacting where, in some cases, limiting the UX capabilities makes for a cleaner, simpler experience and drives people into these new patterns. Even locally, we kicked off joking about this: people don't really edit files or hand-code anymore. We want to build for where that's going and not where it's been.

A lot of cool stuff. I have a couple more observations about the design elements of these things. One of the things that I'm always thinking about is that Cursor and other peers of Cursor start from the dev tools and work their way toward cloud agents. Other people, like Lovable and Bolt, start with the vibe-code, full-cloud thing. They were already cloud agents before anyone else, and they'll give you the full deployment platform.

They own the whole loop. They own all the infrastructure. They have the logs, the live site, whatever, and you can do that whole cycle. Cursor doesn't own that cycle even today, right? You don't have Vercel or the deployment infrastructure you're going to have, which gives you power because anyone can use it, including any enterprise, whatever you're in for—I don't care—but it also gives you limitations as to how much you can fully debug end to end.

I'm just putting it out there: is there a future where there's full-stack Cursor, where there's cursorapps.com, where I host my Cursor site, which is basically a Vercel clone? I don't know.

Alessio Fanelli

I think that's an interesting question to be asking, and I think the logic that you laid out for how you would get there is logic that I largely agree with.

Yeah. Yeah.

Alessio Fanelli

I think right now we're really focused on what we see as the next big bottleneck. Because things like the Datadog MCP exist, I don't think 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.

Alessio Fanelli

Yeah, yeah, sure. Right now, this big bottleneck is getting the code out there. Unlike Lovable and Bolt, we focus much more on existing software, and the 0-to-1 greenfield is a very different problem.

Imagine going to Shopify and convincing them to deploy on your deployment solution. That's very different, and I think it will take much longer to see how that works. It may never happen, relative to a 0-to-1 app.

It's kind of tempting because 50% of your apps are Vercel, Next.js, Tailwind, and React. It's the stack; it's what everyone does. So it's kind of interesting.

Yeah. The other thing is the model's leverage is dying right now in cloud agents. It's stuck down in the bottom left. Sure, Codex is hot today, but do I care if it's suddenly switched to Opus? Probably not.

Alessio Fanelli

We definitely want to give people a choice across models because I feel like the meta changes very frequently. I was a big Opus 4.5 maximalist, and when Codex 5.3 came out, I hard-switched, so that's all I use now.

So, yeah, agreed. I don't know if anyone—basically, when I use it in Slack, Cursor does a very good job of exposing, “Here's the model we're using. Here's how you switch if you want.”

But otherwise, it's kind of abstracted away, which is beautiful because then you don't actually have to decide.

Alessio Fanelli

Yeah. I think we want to be doing more with defaults, 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, so I think we will want to do something like that for cloud agents as well. We haven't done it yet.

I think we have both people like Sam who are very savvy and want to know exactly what model they want, and people who want us to pick the best model for them. We have amazing people like Sam, and we're the experts. 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 labs versus model labs. To me, Cursor and other companies are examples of agent labs that are building a new playbook, different from a model lab, where it's very GPU-heavy, although obviously it has a research team.

My thesis is that every agent lab is going to have a router, because you're going to be asked, “What's what?” I don't keep up every day. I'm not a Sam. I want to use the arbiter of taste: put me on Cursor Auto. Is it free? Is it—not free?

Alessio Fanelli

Auto is not free, but there are different pricing tiers.

Put me on Cursor Auto. You decide for me based on all the other people you know better than me. I think every agent lab should basically end up doing this, because that actually gives you extra power. People stop caring or having loyalty with any one lab.

Alessio Fanelli

Yeah. Two other maybe interesting things that I don't know how much are on your radar are, one, the best-of-N thing we mentioned, where running different models head-to-head is actually quite interesting because—

Which exists in Cursor.

Alessio Fanelli

That exists in Cursor IDE and web. So the problem is, where do you run them? I can share my screen again if that's interesting.

Yeah, yeah. I mean, obviously parallel agents are very popular.

Alessio Fanelli

Yes, exactly: parallel agents.

In your mind, are best-of-N and parallel agents the same thing? I don't want to put words in your mouth.

Alessio Fanelli

Best-of-N is a subset of parallel agents where they're running on the same prompt. So this is what that looks like. Here in this dropdown picker, I can select multiple models.

And now if I do a prompt, I'm going to do something kind of silly. I am running these 5 models.

Okay. This is a straight clone of Cursor 2.0.

Alessio Fanelli

Yes, exactly. But they're running—the Cursor 2.0 experience can be desktop or cloud, and this is cloud specifically. The benefit over worktrees is that they have their own VMs and can run commands, and they won't try to kill ports that the other one is running, which are some of the pains.

These are all cloud worktrees.

Alessio Fanelli

No, these are all cloud agents with their own VMs.

Okay. But when you do it locally, sometimes people do worktrees, and that's been the main way that people have set up parallel agents. I've got to say, that's so confusing for folks.

Alessio Fanelli

Yeah. No one knows what worktrees are.

Exactly. I think we're phasing out worktrees.

Alessio Fanelli

Really?

Yeah.

Alessio Fanelli

Okay. But, yeah, one other thing I would say on the multimodel choice: this is another experiment that we ran last year and didn't decide to ship at that time, but may come back to. There was an interesting learning that's relevant for these different model providers.

It was something that would run a bunch of best-of-Ns but then synthesize and basically run a synthesizer layer of models. That was a set of other agents that would act as an LLM judge, but one that was also agentic and could write code. So it wasn't just picking, but also taking the learnings from 2 models and writing a new diff.

What we found was that, at the time at least, there were strengths to using models from different model providers as the base level of this process. Basically, you could get almost a synergistic output that was better than having a very unified bottom-model tier.

It's really interesting because, potentially, even in the future, when you have 1 model ahead of the other for a little bit, there could be some benefit from having multiple top-tier models involved in a model swarm or whatever agent swarm you're doing. They each have strengths and weaknesses.

Andrej called this a council, right?

Alessio Fanelli

Yeah. Yeah. Exactly. We actually have another internal command that Ian wrote: /counsel.

Yeah, I mean, yes, this idea is in various forms everywhere. For me, the productization of it that you guys have done is very flexible, but if I were to add another one on here, it would be too much. I don't want to get lost in that complexity.

Alessio Fanelli

Well, ideally, it's all something that the user can just choose, and it all happens under the hood in a way where you just get the benefit of that process at the end and a better output, basically, but don't have to get too lost in the complexity of judging along the way.

Okay. Another thing on the many agents and different parallel agents that's interesting is an idea that's been around for a while and has started working recently: subagents. This is one other way to get agents with different prompts, different goals, different models, and different vintages to work together, collaborate, and delegate.

Alessio Fanelli

Yeah. I always look for, “This is the year of the blah,” right? I think one of the things on the list is subagents.

I haven't used them in Cursor.

Are they fully formed? How do I— I almost need an introduction. Do I form them anew every time? Do I have fixed subagents? How are they different from slash commands? There are all these basic questions that no one stops to answer for people because everyone's too busy launching.

Alessio Fanelli

Honestly, you can see them in Cursor now if you just say, “Spin up 50 subagents.”

Cursor defines what subagents are?

Alessio Fanelli

Yeah. So basically—I shouldn't speak for the whole subagents team, because this is a different team that's been working on this—but what we saw internally is that they're great for context management for long-running threads, or if you're trying to just throw more compute at something. We've used them almost like a generic task interface, where the main agent can define what goes into the subagent. If I say, “Explore my codebase,” it might decide to spin up an Explore subagent, or it might decide to spin up 5 Explore subagents.

But I don't get to set what those subagents are, right? It's all defined by the meta-model.

Alessio Fanelli

I think I'd actually have to refresh myself on the subagent. There are some built-in ones, like the Explore subagent, that's sort of prebuilt. But you can also instruct the model to use other subagents, and then it will.

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.

Alessio Fanelli

So this is the desktop app.

That's all you need to do, right?

Alessio Fanelli

Yeah, that's all you need to do. So I said, “Use a subagent to explore,” and I can even click in and see what the subagent is working on here. It ran some find command, and this is a Composer under the hood. Even though my main model is Opus, it does smart routing. In this instance, Explore requires reading a ton of things, and so a faster model is really useful to get an answer quickly.

That's what subagents look like. I think we want to do a lot more to expose hooks and ways for people to configure them. Another example of a built-in subagent is the computer-use subagent in the cloud agent, where we found that those trajectories can be kind of long and involve a lot of images, as well as the execution of some testing or verification task. We want to use models that are particularly good at that.

That's one reason to use subagents. The other reason is that we want context to be summarized and reduced down at the subagent level. That's a really neat boundary at which to compress that rollout and testing into a final message that the agent writes, which then gets passed into the parent, rather than having to do some global compaction or something like that.

Awesome. Cool. While we're in this subagent conversation, I can't do a Cursor conversation and not talk about Wilson stuff. What is that?

What is there?

He built a browser. He built an OS.

Alessio Fanelli

Yes. He experimented with a lot of different architectures and basically ended up reinventing the software engineering org chart, which is all cool. But what's your take? Is there any whole behind-the-scenes story about that whole adventure?

Some of those experiments have found their way into a feature that's available in cloud agents now: the long-running agent mode. Internally, we call it Grind mode. There's a hint of Grind mode accessible in the picker today, because you can choose “Grind until done.” That was the result of experiments Wilson started in this vein. I think the Ralph Wiggum loop was floating around at the time, but it was something he also independently found and was experimenting with, and that was what led to this product and service.

And it's just the simple idea of having criteria for completion and not stopping until you complete. There's a bit more complexity in our implementation as well. You have to start out by aligning, and there's a planning stage where it will work with you. It won't start Grind execution mode until it's decided that the plan is amenable to both of you, basically.

Like, “I refuse to work until you make me happy.”

Alessio Fanelli

We found that it's really important. People would give a very underspecified prompt and then expect it to come back with magic. If it's going to go off and work for 3 minutes, that's one thing. When it's going to go off and work for 3 days, you should probably spend a few hours up front making sure that you've communicated what you actually want.

Yeah. And just to really drive home the point, we really mean 3 days. No human intervention.

Alessio Fanelli

I don't know what the record is, but some of these Grinds have run for a long time.

Yeah. Yeah.

Alessio Fanelli

The long-running agent available in Cursor is, if you want to think about it very abstractly, 1 worker node. What built the browser is a society of workers and planners and different agents collaborating. We started building the browser with 1 worker node. At the time, that was just the agent, and it became 1 worker node when we realized that the throughput of the system was not where it needed to be to get something as large-scale as the browser done.

Yeah.

This has also become a really big mental model for us with cloud agents. There's the classic engineering latency-throughput trade-off. The code is water flowing through a pipe. We think that over the coming months, the big unlock is not going to be 1 person with a model getting more done, like the water flowing faster. We'll be making the pipe much wider and parallelizing more.

Whether that's swarms of agents or parallel agents, both contribute to getting much more done in the same amount of time. Any 1 of those tasks doesn't necessarily need to get done that quickly. Throughput is a really big thing. If you see a system of 100 concurrent agents outputting thousands of tokens a second, you can't go back. You see a glimpse of the future.

Obviously, there are many caveats. No one is using this browser IRL, and there are a bunch of things that aren't quite right yet. But we're going to get to systems that produce real production code at this scale much sooner than people think. It forces you to think about what even happens to production systems. We've broken our GitHub Actions recently because we have so many agents producing and pushing code that CI/CD is overloaded.

Effectively, it's as if we grew headcount 10x when people run 10x as many agents. A lot of these systems will need to adapt. It also reminds me—you know, all 3 of us live in the app layer—but if you talk to the researchers doing RL infrastructure, it's the same thing. It's all these parallel rollouts, scheduling them, and making sure as much throughput as possible goes through them. It's the same thing.

Alessio Fanelli

We were talking briefly before we started recording. You were mentioning memory chips and some of the shortages there. The other thing that's hard to wrap your head around is the scale of the system that was building the browser. If Sam and I both have a system like that running for us, shipping our software, the amount of inference we're going to need per developer is mind-boggling.

When I think about that, I sometimes think that even the most optimistic projections for what we're going to need in terms of buildout are underestimating the extent to which these swarm systems can turn on at scale to produce code that's valuable to the economy.

You can cut this if it's sensitive, but do you have estimates of how much your token consumption is per developer?

Alessio Fanelli

Yeah. Or yourself? I don't need a company average. I just—

I feel like, for a while, I wasn't an admin on the usage dashboard, so I wasn't able to actually see, but—

Alessio Fanelli

Mine has gone up.

Oh, yeah. But, you know, I think—

In terms of how much work I'm doing, it's more like I have no worries about developers losing their jobs, at least in the near term, because I feel like—well, I mean, that's a broader discussion.

Alessio Fanelli

Oh, gosh. [Laughter] Yeah. You went there. I didn't go there. I wasn't going there.

I was just asking how much more you're using. There's so much stuff to be built, and I feel like I'm basically just trying to constantly— I have more ambitions than I did before, personally. So I can't speak to the broader thing, but for me, I'm busier than ever before. I'm using more tokens, and I'm also doing more things.

Alessio Fanelli

Yeah.

I don't have the stats for myself, but broadly, a thing that we've seen and expect to continue is Jevons paradox.

Alessio Fanelli

You can't do the podcast without seeing it.

Exactly. We've done it now. We said the words. We can wrap. Phase 1 was tab autocomplete: people paid about $20 a month, and that was great. Phase 2, where you were iterating with these local models, is where today people pay hundreds of dollars a month.

I think, as we think about these highly parallel agents running for a long time in their own VM systems, we are already at the point where people will be spending thousands of dollars a month per human, and potentially tens of thousands and beyond. It's not that we're greedy for capturing more money; what happens is that individuals get that much more leverage. If one person can do as much as 10 people, 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.

One more question about Cursor in general, and then open-ended for you guys to plug whatever you want to plug. How is Cursor hiring these days?

Alessio Fanelli

What do you mean by “how”?

So, obviously, LeetCode is dead.

Alessio Fanelli

Oh, okay.

Everyone says work trials. Different people have different levels of adoption of agents. Some people can really adopt them and become much more productive, but other people just need to be given a little bit of time. Sometimes they've never lived in a token-rich place like Cursor.

Alessio Fanelli

Once you live in a token-rich place, you just work differently. You need to have done that, and a lot of people haven't. Anyway, this is kind of open-ended: How has agentic engineering and agentic coding changed your opinions on hiring? Are there any broad insights?

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

Alessio Fanelli

Yeah, totally. To hear Sam's opinion, we haven't talked about this, the two of us. I think that we don't necessarily see being great at the latest thing with AI coding as a prerequisite. I do think that it's a sign that people are keeping up, curious, and willing to upskill themselves and understand what's happening, because, as we were talking about, the last 3 months have completely changed the game. What I do all day is very different.

It's kind of my job, and I can't—

Alessio Fanelli

Yeah, totally. I do think the fundamentals remain important in the current age. Models today still have weaknesses, and if you let them run for too long without cleaning up and refactoring, the code will get sloppy and there will be bad abstractions. You still need humans who have built systems before, know good patterns when they see them, and know where to steer things.

Yeah, I would agree with that. I would say that Cursor also operates very quickly, and leveraging agentic engineering is probably one reason why that's possible at this moment. In the past, it was just people coding quickly, and now there are also people who use agents to move faster. It's part of our process. We always look for and select for the ability to make good decisions quickly and move well in this environment. Being able to figure out how to use agents to help you do that is an important part of it, too.

Alessio Fanelli

Yeah. Okay. The fork in the road: either predictions for the end of the year, if you have any, or plugs.

Predictions are not going to go well.

Alessio Fanelli

I know. They're hard.

They're so hard. Get it wrong. It's okay. Sorry.

Alessio Fanelli

Well, one other plug that may be interesting, which I feel like we touched on but haven't talked a ton about, is that these new interfaces and this parallelism enable the ability to hop back and forth between threads really, really quickly.

A thing that we have felt with local agents is this pain around context switching. You have one agent that went off and did some work and another agent that did something else. Here, I just have 3 tabs open, but I can very quickly hop in. This is an example I showed earlier, but the actual workflow here is really different in a way that may not be obvious.

I start the morning and kick off 10 agents or something. The first one finishes, so I come in and watch the video. Either it's kind of close, in which case I might send a follow-up and say, “Hey, make it red,” or I might hop into the desktop and try it out. Within 90 to 120 seconds, I've kicked this one back off and either started the merge process—CI is running now, and I'll come back to it later—or it's off with some additional follow-up information. Then I can hop into the next one.

In the next one, I hop in and think, “Okay, this looks kind of interesting.” I actually try it out for real in the app. I want to see it in action, not just in the gallery. I can kick that off, and the agent will go and work on it because maybe I wanted to try out what the button looks like in the actual thing. Then I might hop in here as well and check the video or do something else.

You're really parallelizing much more: follow up here, check in there. It's much more of a higher-level abstraction. Having different desktops where you can hop back and forth, instead of thinking, “I checked out this branch—where was that worktree again?” is really solving for something that we've struggled with ourselves in Cursor and with these local agents. You think, “Where was that diff again? It's lost in some worktree. I'm never going to find it. My local thing is rebuilding. Just make another one,” and then you wait 5 more minutes for it to run.

This is really a new way of parallelizing that we've found to be really fun. You're just hopping in and injecting taste, thinking, “That doesn't quite feel right,” or, “Actually, this isn't architected quite right.” You're focusing on those interesting questions of taste.

For me, the cloud ecosystem also enables this to add productivity to my dead time—commuting, overnight, or something like that. I don't have to leave my computer open.

Alessio Fanelli

There is a Cursor mobile app.

If there is, I'm not sure. It's the current thing. I use it on my phone all the time, just on the web. It's a pretty good experience for checking in and unblocking. You can see the videos and stuff in the web app, which is awesome.

Alessio Fanelli

Yeah.

Yeah. I think this is one where the ADHD will inherit the earth. If your attention span is cooked but you can still manage this, it's actually good for you.

Alessio Fanelli

Yeah. But I also think this is where the coding tools start coming into conflict with the productivity tools, like Linear and the Kanban boards. What you have there is cool, but do you actually need a Kanban board? Vibe Kanban is out there, open source. I'm sure you guys have talked about it, but those things will start to conflict because the code doesn't matter anymore. It's the process of the human interacting and checking in, saying, “Get the World of Warcraft npm package to work,” or whatever. It's an interesting future productivity thing.

Yeah. I also think another big theme is that last year was the year of coding agents. This year, coding agents spill over into the real world, into cloud co-work and all the other stuff. I'm sure Cursor is going to focus on software, but OpenClaw is extremely mind-expanding in terms of, “I did not know that could happen.”

Alessio Fanelli

Yeah. It's all based on a coding-agent architecture, right?

Totally. One of the things that's interesting when talking to friends and family who are not in the software world is that I do think we're going to start seeing other industries go through what software development has started going through. That's partly because models are so good at writing software, and partly because the people building the new technology are such early adopters and are trying it out and applying it to themselves.

Certain kinds of shifts will happen in other industries too. 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: To what point do people get more leverage? When do you start changing the role to become much more generalist? We've seen some data on all of these questions, but we'll see a lot more in the coming months. That will happen everywhere.

Any parting thoughts or plugs of your own?

Alessio Fanelli

Not really. Good. We covered so much. We covered coming up with a prediction. I just think agents are going to keep getting better. I'm going to stop doing as much manual coding—probably 0 lines of code written in the whole month of December this year by myself. 100% agents is a personal prediction, but—

Oh, you're not at 0 today.

Alessio Fanelli

Um—

In what cases?

Alessio Fanelli

I think, honestly, it's like 1% when I get frustrated and think, “I don't want to tell an agent to change this one thing.” Prompting. Sometimes I feel like working on prompts, and sometimes I still go in and manually edit because it's such a bare transfer of intent that telling the agent what I want—

It's like writing an essay. I don't use agents to write essays yet because the process of writing is the thinking.

I still can't stand AI-generated writing. So, yeah, I also can't have the agent write prompts.

Alessio Fanelli

So, no DSPy, no GEPA, nothing like that here. We have some internal tooling around prompt optimization, but there's a fair amount of figuring out what concepts I need to communicate to the agent or the model.

I also noticed another thing I'm looking for is voice. I noticed that you didn't use your voice to code. Even when we do podcasts with them, they don't use their voice, and I'm like, at some point, when this gets good, you can stop typing.

We have some people who like that a lot internally, and I think we'll be experimenting in that space too, for sure. Do you use voice a lot?

Not a lot. Sometimes. That's bound to my Caps Lock, right? So I can press it. I just—

Alessio Fanelli

And when you use it, do you want it to talk back, or do you just want—

Yeah.

Alessio Fanelli

Just dump it in.

Yeah, yeah.

Alessio Fanelli

But the brain dump is good because you can interrupt yourself, go on a tangent, whatever. It just captures everything and slops it into the LLM. It's fine.

The way that we did this with Autotab was that people would record full-screen recordings with audio to teach the model how to do a task. One of the funny things that we learned was that people would use their Siri voice. They would start talking in short, stilted sentences and enunciate really clearly because the last time they used AI was 2 years ago, when you had to—

Apple has damaged an entire generation of people's expectations.

Alessio Fanelli

Exactly. We had to be like, no, you're very native, so you do this, but just dump everything in. You can say “um,” repeat yourself, or contradict yourself. The models are smart enough to figure it out.

But it's still very bad. Voice coding was always, in my opinion, the hardest part because you have to say technical things where spelling matters and capitalization matters, and that's all not in voice. So we'll see. So far, it's been more about emotional companionship and that kind of stuff, but at some point it's going to hit voice coding.

Alessio Fanelli

Yeah. I have a prediction for you. I predict that by the end of the year—the volume one, I think, will take longer than people think, and longer than we think, for cloud 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 more than 2 times the volume of local agents.

Okay, you're leaving me an opening. What's not good today?

Alessio Fanelli

There are a bunch of hard things. One of them is just getting those sandboxes to be really, really good. One 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 the whole thing was my favorite.

Alessio Fanelli

Yeah, we worked a lot on that. Sam and I, in particular, spent a lot of late nights making that good.

There's still a lot to do there. Setup is not a unitary thing where everything is either set up or not. Things break over time, you have new dependencies, you need access to new systems, and you change where your database lives. That's one part of it, and then the other part is having these agents run in the cloud and be more autonomous.

We've really started to see the lack of memory. Once you start getting the model operating the codebase, there are more particularities. It's not just a read-file tool; it needs to know, “How do I start up the backend? How do I check the status of the backend?” That's very particular to your codebase. Even if it's great at `npm run watch` or whatever the default things are, there are always quirks. Everyone has quirks.

Getting the model good at those things will require more work. We're working on that, but we think that will be one of the big unlocks: having agents onboarded not only in terms of their environment, but also in terms of their understanding of design trade-offs, how the codebase works, and how to be a good developer in any one codebase.

It's Cursor rules. It's going to be something else. Is it going to be a file? Are we just going to call the Markdown file a different name?

Is that your team, or is there a different team?

Alessio Fanelli

A different team. We learned at Cursor, the company, this year—there's a really great blog post that Jai and other people on the agent quality team put out about dynamic file context.

They were working on basically doing everything through the file system. A lot of my thinking personally on memory this past year has changed to be more aligned with that. It's about giving the agent pointers to things and annotations to things.

The second thing I've started to think differently about is that memory is a subset of agent self-auditability and self-awareness. The agent might want to propose annotations, links, or memory files to itself when it finds a gap in its functionality or in its own harness that might need to be filled by some piece of information on a semi-permanent basis.

There are a whole bunch of other things that are a side effect of self-auditability that are really interesting, like potentially finding conflicting instructions or skills and rules that might be bugging each other, as well as fixing developer-experience problems that it runs into. I think the dynamic file system stuff is probably very promising for memory. There's also this notion of needing to have the agent be a little bit more self-aware in terms of being able to identify gaps in its own functionality and decide how to fill them.

That's such a good point. 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. It needs to be self-aware about its own harness and its environment.

And you think this is not inherent in the model? You have to—

Alessio Fanelli

Well, specifics, right? If it's running in Cursor versus some other sandbox, that's a bit different.

Yeah. What does that even mean? How do you do that safely?

Alessio Fanelli

Do that? This is just research, right? This isn't—I think it will do that. It will manage its own context.

And so the system prompt is part of the context, and you can argue about—

Alessio Fanelli

Yeah, other things that it might decide to turn on or off depending on the situation.

I mean, self-awareness to us in this context is not the model itself having a notion of consciousness. It's more like knowing what system it's operating in, the constraints of that system, and potentially being able to have agency in optimizing itself to operate best in that system.

This was one of the first things I learned at Adept when we launched. We had made the model—or made the agent, or whatever we would call it at that time; it was far less agentic—make the product work very well at a certain number of things, but it didn't have complete self-awareness of its own boundaries.

People would be like, “Hey, can you do this thing?” The thing was there and could be done, and the product would be like, “Oh, no.” I'd be like, “But you can.” That was one of the earliest things I found.

Just believe in yourself.

Alessio Fanelli

I know. As a product developer, it needs to both be able to do the thing and have complete knowledge of its ability to do the thing. Those are not always obviously the same, and that's not necessarily part of the prompt at all.

Yeah, yeah.

Alessio Fanelli

It's something that I think has continued to be a theme in the ecosystem: users will often attribute increased intelligence to a system that is more highly self-aware and more able to manipulate itself to do well in a system, if that makes sense.

Yeah, this is more abstract than I ever thought we'd get at this tier of discussion.

Alessio Fanelli

It couples with the kind of conversations that you have. We talk about this stuff all the time in relation to improving agents in general. To your point about the agent layer and thinking a lot about models, the harness, the product, and the affordances—that all follows from that.

No, I mean, you guys are my sort of leading example of what an agent lab looks like and how it can be successful. People are always hungry for insights into how you guys operate, so thank you for taking the time to share.

Alessio Fanelli

Yeah, thanks for coming.

Yeah, thank you.