# Cursor's Third Era: Cloud Agents — ft. Sam Whitmore, Jonas Nelle, Cursor

Latent Space · 2026-03-06

<https://addtry.com/4a31e5ab-d75e-4c43-83c7-fa76cdcf54df>

Cursor's Sam Whitmore and Jonas Nelle detail their Cloud Agents launch, where agents get full cloud VMs to onboard repos, run code, and test changes end-to-end before returning PRs with demo videos and remote desktop access. The model decides whether to test (with /no-test to skip and /repro for bug reproduction videos). Videos cut review time by letting humans watch 20-second clips instead of giant diffs. Cursor supports parallel model swarms via best-of-N—running multiple models head-to-head on the same prompt—and subagents for context management, plus a long-running 'grind mode' for multi-day tasks. They predict cloud agents will surpass local agents in volume by year-end, driving per-developer spend to thousands per month and creating new bottlenecks in CI/CD and production pipelines.

## Questions this episode answers

### How do Cursor's cloud agents test code changes before submitting a PR?

Sam Whitmore and Jonas Nelle explain that Cursor Cloud Agents now operate in full cloud VMs, allowing them to onboard repos, start dev servers, and run end-to-end tests before delivering a pull request. The agents often produce a short demo video of their changes, which acts as an easy review entry point, and users can use the /no-test command to skip testing for trivial changes.

[1:36](https://addtry.com/4a31e5ab-d75e-4c43-83c7-fa76cdcf54df?t=96000)

### What is the /repro slash command in Cursor and how does it help fix bugs?

Jonas Nelle describes the /repro command, where a Cursor Cloud Agent first reproduces a reported bug inside its VM, records a video showing the bug, then fixes the bug and records a new video confirming the fix. This workflow, demonstrated on a bug where removed image attachments were still sent, turns difficult-to-reproduce issues into quick merges, often in 90 seconds.

[11:18](https://addtry.com/4a31e5ab-d75e-4c43-83c7-fa76cdcf54df?t=678000)

### How does Cursor enable parallel coding agents and what is 'best-of-N'?

Jonas Nelle and Sam Whitmore discuss parallel agents and best-of-N: users can select multiple models in Cursor to run the same prompt head-to-head, each in its own cloud VM. Sam notes an earlier experiment with a 'council' synthesizer agent that combined outputs from different providers, yielding synergistic results. They also mention subagents for delegating tasks like exploring codebases, with some built-in subagents for efficiency.

[41:26](https://addtry.com/4a31e5ab-d75e-4c43-83c7-fa76cdcf54df?t=2486000)

### What is Cursor's 'grind mode' and how does it work for long-running coding tasks?

Sam Whitmore reveals Cursor's 'grind mode,' an option for long-running cloud agents that work continuously until a task is done. Developed from experiments by Wilson, grind mode involves a planning stage where the agent aligns with the user before executing. Internally, the team has seen agents run for up to three days autonomously, handling complex tasks that require extended compute and iteration.

[48:07](https://addtry.com/4a31e5ab-d75e-4c43-83c7-fa76cdcf54df?t=2887000)

## Key moments

- **[0:00] Agentic Experiments**
  - [0:00] Cursor's agentic LLM judge could synthesize code from multiple models' outputs for synergistic results.
- **[0:54] Cloud Agents Launch**
  - [0:54] Cursor launched Cloud Agents with full VM access to onboard repos and test changes end-to-end.
  - [1:19] "If you were seeing tokens stream by and all you could do was sight-read code, I'd be so bad." — Jonas Nelle
  - [2:11] The agent not only wrote code but tested it end-to-end, including starting dev servers and iterating.
- **[2:12] Live Demo**
  - [3:02] Q: Does Cursor's Cloud Agent always test changes? A: It calibrates based on complexity; /no-test skips testing.
- **[3:43] Three Pillars**
  - [3:43] Cloud Agents return a video demo of the change to reduce code review bottlenecks.
  - [5:41] Sam Whitmore: demo videos reduce under-specification and provide a shared artifact for alignment with the agent.
- **[6:28] Agent Workflows**
  - [6:28] The agent used browser dev tools to test an error message by injecting 5,000 characters into a form field.
  - [8:09] "Just give the model pixels, give it a box — remove limitations so the bottleneck is intelligence." — Jonas Nelle
  - [9:17] Jonas Nelle: Opus 4.5, 4.6 and Codex 5.3 provided step changes in agent autonomy.
  - [10:53] Best-of-N model comparisons become practical with video reviews instead of giant code diffs.
  - [11:19] The /repro command makes the agent record a video of bug reproduction and then a video of the fix.
  - [12:06] The agent reproduced a bug where removed image attachments were still sent, then fixed it and recorded a video.
- **[14:13] Slash Commands**
  - [14:37] Jonas Nelle's custom /fix-bb command fixes BugBot comments using the original agent's context.
  - [15:41] Sam Whitmore highlights the /cloud-agent-diagnosis command, which uses Datadog MCP to debug agent runs with subagents.
  - [16:11] Sam Whitmore: spinning up an agent with another agent's transcript enables debugging or forking conversations.
  - [18:45] Cursor's Cloud Agents launched in June last year; agent usage has started overtaking tab completion.
  - [19:26] "When you type out the actual letters, we call it hand coding now. Oh, that's cute." — Jonas Nelle
  - [23:05] Jonas Nelle: the remaining human work is high-order questions like 'Is this the right UX?' — not code details.
- **[34:00] Design Decisions**
  - [34:56] Cursor removed the web file editor to foster a new workflow of delegating to the agent.
  - [36:52] Shawn Wang notes that while Lovable and Bolt offer full-stack cloud hosting, Cursor focuses on existing software and doesn't host.
- **[38:49] Model Routing**
  - [38:49] Cursor will add auto model routing to Cloud Agents, picking the best model for each task based on internal expertise.
- **[40:59] Councils**
  - [41:09] Best-of-N with multiple models runs each in its own Cloud Agent VM to avoid port conflicts.
  - [43:23] Sam Whitmore: an internal /council agent synthesizes best parts of outputs from different model providers for synergistic results.
- **[44:18] Subagents**
  - [44:18] Jonas Nelle: subagents are now working well for context management, using different models for sub-tasks like exploration.
  - [47:40] Sam Whitmore: 'grind mode' (long-running agent) was inspired by Wilson's experiments, allowing agents to work for days.
- **[47:41] Grind Mode**
  - [49:26] "We've had three-day runs" with grind mode agents working autonomously for days. — Jonas Nelle
  - [50:05] Jonas Nelle: the big unlock is throughput — swarms of agents working in parallel, not single-agent speed.
  - [51:12] Sam Whitmore: Cursor's CI/CD broke because agent-generated PRs overloaded GitHub Actions.
  - [53:07] "I'm busier than ever before, using more tokens, and I am also doing more things." — Sam Whitmore
  - [53:27] Jonas Nelle: Jevons paradox — as agent capabilities increase, spend per developer will rise from $20 to hundreds, then thousands monthly.
  - [54:22] Jonas Nelle: Cursor hiring values fundamentals and ability to upskill with AI, not just LeetCode or current agent expertise.
- **[1:04:38] Predictions**
  - [1:04:38] Jonas Nelle predicts cloud agents will surpass local agents in volume by the end of the year, more than 2x.
  - [1:05:10] Jonas Nelle: the /onboard command for repo setup is still too slow and doesn't handle all future changes.
  - [1:07:35] Sam Whitmore: memory should come from agent self-auditability, where agents propose annotations to fill their own knowledge gaps.
  - [1:08:25] Jonas Nelle: agents will need self-awareness to understand their harness and eventually edit their own system prompts.
  - [1:09:50] Sam Whitmore: a product's self-awareness of its own capabilities increases user-perceived intelligence and trust.

## Speakers

- **Swyx** (host)
- **Jonas Nelle** (guest)
- **Sam Whitmore** (guest)

## Topics

Agent Platforms

## Mentioned

Cursor (company), Datadog (company), Autotab (product), Bits (product), Bolt (product), BugBot (product), Cloud Agents (product), Codex (product), Datadog MCP (product), GitHub (product), Graphite (product), Lovable (product), Opus (product), React (product), Slack (product), Sonnet (product), Supabase (product), Tailwind (product), VS Code (product), Vercel (product)

## Transcript

### Agentic Experiments

**Sam Whitmore** [0:00]
This was another experiment that we ran last year and didn't decide to ship at that time, but may come back to. LLM judge, but one that was also agentic and could write code. So it wasn't just picking, but also, like, taking the learnings from two models or end models that it was looking at and writing a new diff.

And 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 almost, like, a synergistic output that was better than having, like, a very unified, like, bottom model tier.

**Jonas Nelle** [0:31]
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 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.

### Cloud Agents Launch

**Swyx** [0:54]
This week, one of the biggest launches that Cursor's ever done, um, is Cloud Agents. I mean, I think you, you had Cloud Agents before, but, like, this was like, well, you give Cursor a computer, right?

**Jonas Nelle** [1:05]
Yeah.

**Swyx** [1:06]
Um, so is this basically they bought Autotab and then they repackaged it? Is that, is that what's going on or

**Jonas Nelle** [1:12]
That's a big part of it, yeah. Cloud Agents already ran in their own computers, but they were sort of sight-reading code.

**Swyx** [1:18]
Yeah.

**Jonas Nelle** [1:19]
And those computers were not-- they were, like, blank comm- VMs typically that were not set up for the DevEx for whatever repo the agent's working on. One of the things that we talk about is if you put yourself in the model's shoes and you were seeing tokens stream by, and all you could do was sight-read code and spit out tokens and hope that you had done the right thing-

**Swyx** [1:36]
No chance

**Jonas Nelle** [1:37]
... I'd be so bad. Like, you-- 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, um, and have sort of a cloud computer with different apps in it is the big unlock that we've seen internally in terms of us-usage of this going from, "Oh, we use it for little copy changes," to, "No, no, no, no, no, we're really, like, driving new features, uh, with this kind of new type of agentic workflow."

**Swyx** [2:11]
All right. Let's see it.

### Live Demo

**Jonas Nelle** [2:12]
Cool. So this is what it looks like in cursor.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, uh, 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 it" PR that's sort of ready for your review.

Uh, one of the other intuition pumps we use there is if a human gave you a PR, asked you to review it, and you hadn't-- they hadn't tested it, you'd also be kind of 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, uh-

**Swyx** [3:02]
Simple question I wanted to get out front. Some PRs are way smaller, like just copy change. Does it always do the video or just sometimes?

**Jonas Nelle** [3:10]
Uh, sometimes.

**Swyx** [3:11]
Okay. So, so what's the judgment?

**Jonas Nelle** [3:13]
The model does it.

**Swyx** [3:13]
Model.

**Jonas Nelle** [3:14]
So we, uh, we do some default prompting with sort of what types of changes to test. There's a slash command that people can do called /no-test, where if you do that, the model will not test.

**Swyx** [3:26]
But the default is test?

**Jonas Nelle** [3:28]
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.md and specify, like, this type of, you know, if you're editing this subpart of my monorepo, never test it 'cause that won't work or whatever.

**Swyx** [3:43]
Cool.

### Three Pillars

**Jonas Nelle** [3:44]
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, 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, you come back, and the first thing that you would do is watch this video.

So this is sort of, uh, you know, video of it, um... In this case, I wanted a tool tip over this button, and so it went and, uh, showed me what that, 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 sort of, like, that component in action. Uh, and so that's pillar two is, like, these demo videos of what it built. Uh, and then pillar number three is I have full remote control access to this VM.

So I can go he-- in here, I can hover things, I can type. I have full, full control, uh, and same thing for the, for the terminal. Um, so, you know, 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 o-oftentimes is this worth iterating with to get it to that final stage where I am ready to merge it?

And 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 like, and there's no substitute to a live preview, and the VNC, kind of VM remote access gives you that.

**Swyx** [5:32]
Amazing. What, sorry, what is VNC?

**Jonas Nelle** [5:34]
Uh, it just the, the remote desktop. Uh, remote desktop, yeah.

**Swyx** [5:38]
Uh, Sam, any other details that you always wanna call out-

**Sam Whitmore** [5:41]
Yeah

**Swyx** [5:41]
... shooting this?

**Sam Whitmore** [5:42]
I mean, for me, the videos have been super helpful. I would say especially in cases where a common problem for me with cl- agents and cloud agents beforehand was almost, like, under-specification in my requests, where our plan mode and kind of going really back and forth and getting detailed implementation spec is a way to reduce the risk of under-specification.

But then similar to how human communication breaks down over time, I feel like you have this risk where it's like, okay, when I pull down, go to the trouble of pulling down and, like, running this branch locally, I'm gonna see that, like, I said this should be a toggle and you have a checkbox, and, like, why didn't you get that detail right?

And having the video up front just al- has that-- makes that alignment like you're talking about a shared artifact with the agent very, very clear, which has been just super helpful for me.

**Jonas Nelle** [6:26]
I can quickly run through some other-

**Swyx** [6:28]
Yes

### Agent Workflows

**Jonas Nelle** [6:28]
... examples. So this is a very front-end heavy one.

**Swyx** [6:31]
Yes.

**Jonas Nelle** [6:31]
So one question-

**Swyx** [6:32]
I was gonna say, is this only for front-end?

**Jonas Nelle** [6:33]
Exactly. One question you might have is, 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 sort of onboarding it is giving it access-

**Swyx** [6:54]
This is cloud agents working on cloud agents.

**Jonas Nelle** [6:55]
Yes. So this is a fun thing is-

**Sam Whitmore** [6:58]
It can get super meta.

**Jonas Nelle** [6:59]
It 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-

**Sam Whitmore** [7:06]
Yeah

**Jonas Nelle** [7:06]
... that. We have disabled its cloud agents starting more cloud agents, so we currently disallow that.

**Swyx** [7:12]
Someday you might.

**Jonas Nelle** [7:13]
Someday we might. Someday we might. Um, 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, um... Oh, this is actually really cool.

**Swyx** [7:24]
Wow, that's the dev tools.

**Jonas Nelle** [7:24]
That's the dev tools. 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 hits save, closes the dev tools, hits save, and gets this new, um, gets the new error message.

So that, uh, looks like the video actually cut off-

**Swyx** [8:01]
It did

**Jonas Nelle** [8:01]
... but here you can see the, here you can see the screenshot of the, uh, of the error message.

**Swyx** [8:06]
What? So-

**Jonas Nelle** [8:06]
So that is like front-end, back-end, kind of end-to-end feature-

**Swyx** [8:08]
Fully integrated

**Jonas Nelle** [8:09]
... to, to get that.

**Swyx** [8:09]
Yeah.

**Jonas Nelle** [8:09]
Um, and kind-

**Swyx** [8:10]
And you just, you just need a full VM, full computer, run everything, right? Okay, yeah.

**Jonas Nelle** [8:15]
Yeah, so we've had versions of this. This is one of the auto tab lessons where, uh, we started that in 2022, uh, no, in 2023, and at the time it was like browser use, you know, DOM, like all these different things, and I think, uh, we ended up very sort of AGI-pilled in the sense that just give the model pixels, give it a box, sort of a brain in a box is what you want, and you want to remove, uh, 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 set up like a human would, has just been for us internally a really big, big step change in capability.

**Swyx** [9:00]
Yeah. I, I would say, you know, let's call it a year ago, the, the models weren't even good enough to do any of this stuff, right? So-

**Sam Whitmore** [9:07]
Even six months ago. Yeah.

**Swyx** [9:09]
So like, uh, yeah, what, what people have told me is like round about Sonnet 4.5 is when this started being good enough to just automate fully by pixel.

**Jonas Nelle** [9:17]
Yeah, I, I think it's always a question of when is 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 sort of the autonomy grade capabilities of the model to just go off and figure out the details and come back when it's done.

**Swyx** [9:33]
Uh, I wanna appreciate a couple details. One, 10 stack router, I see it. Yeah, I'm a big fan. Do you know any... I have to name the 10 stack?

**Jonas Nelle** [9:39]
No.

**Sam Whitmore** [9:40]
No.

**Swyx** [9:40]
This is just a random lore. Uh, somebody, Sue Tanner.

**Jonas Nelle** [9:43]
Nice.

**Swyx** [9:43]
Uh, and then the other thing, uh, if you switch back to the video.

**Jonas Nelle** [9:46]
Yeah.

**Swyx** [9:46]
Uh, 'cause I wanna shout out this thing. Probably Sam did it, I don't know.

**Jonas Nelle** [9:49]
The chapters?

**Swyx** [9:50]
What is this called? Yeah, this is called chapters.

**Sam Whitmore** [9:51]
Yeah.

**Swyx** [9:51]
It's like a Vimeo thing. I, I don't know, but like it's so nice, the design details. Like the... And obviously a company called Cursor has to have a beautiful cursor.

**Sam Whitmore** [9:59]
And it is the Cursor cursor.

**Jonas Nelle** [10:00]
Like I see it.

**Sam Whitmore** [10:01]
You see it. It's branded.

**Jonas Nelle** [10:01]
Is that the Cursor cursor?

**Sam Whitmore** [10:01]
Yeah.

**Jonas Nelle** [10:02]
Yeah, yeah. Okay, cool.

**Swyx** [10:02]
And then I was like, you know, I complained to Evan, I was like, "Okay, but you guys branded everything but the wallpaper." And he was like, "No, that's a Cursor wallpaper." I was like, "What?"

**Sam Whitmore** [10:11]
Yeah. Rio picked the wallpaper. I think, yeah, the video, that was probably Alexi and yeah, a few others on the team with the chapters on the video. Matthew, Federico.

**Jonas Nelle** [10:18]
Yeah.

**Sam Whitmore** [10:18]
There's been a lot of teamwork on this. It's been a huge effort.

**Swyx** [10:22]
I, I just, I, I like, I like design details.

**Sam Whitmore** [10:23]
Yeah, yeah.

**Swyx** [10:24]
Like it's, it's... A- And so, and then when you download it, it adds like a little Cursor, uh, kinda TikTok clip thing at the end.

**Jonas Nelle** [10:30]
Yes, yes.

**Swyx** [10:31]
So it's like, it's like to make it really obvious it's from Cursor.

**Jonas Nelle** [10:34]
We did the TikTok branding at the end. This was actually in our launch video. Alexi demoed the cloud agent that built that feature. Um, 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. It's like, what are you gonna do?

You're gonna review all... That's horrible. But if you come back with four 20-second videos, yeah, I'll watch four 20-second videos. And then even if none of them is perfect, you can figure out like which one of those do you want to iterate with kind of to get it over the line.

**Swyx** [11:18]
Yeah.

**Jonas Nelle** [11:19]
Um, and so that's, that's really been really fun. Here's another example that we found really, really cool, which is, uh, we've actually turned Since into, uh, a slash command as well, /repro, where for bugs in particular, the model having full access to the, uh, 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, like are you confident it actually fixed it, to when this happens, you'll merge it in like, you

know, 90 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 Cursor is using its full desktop. By the way, this is one of the cases where if you just do, you know, browser use type stuff, you will have a bad time 'cause it now needs to upload files.

**Swyx** [12:38]
Yes.

**Jonas Nelle** [12:38]
Like, it just uses its native file viewer to do that. Um, 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 Cursor agent prompting Cursor agent 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.

**Swyx** [12:58]
I see. I see. Yeah, but you, you gotta enable that if you're, you're gonna use Cursor agent inside Cursor agent, yeah.

**Jonas Nelle** [13:02]
Exactly.

**Sam Whitmore** [13:03]
Yeah.

**Jonas Nelle** [13:04]
And so here, this is then the after video where it went... It does the same thing. It attaches images, removes some of them, hits send, and you can see here, once this agent is up, only one of the images is left in, in the attachments.

**Swyx** [13:17]
Yeah. Beautiful. Okay.

**Jonas Nelle** [13:18]
So easy merge.

**Swyx** [13:19]
So, yeah, when does it choose to do this? Because, like, this is an extra step.

**Jonas Nelle** [13:24]
Yes. I think I've not done a great job yet of calibrating the model on when to reproduce these things.

**Swyx** [13:29]
Yeah.

**Jonas Nelle** [13:29]
Sometimes it will do it of its own accord.

**Swyx** [13:31]
Yeah.

**Jonas Nelle** [13:32]
We've been conservative where we try to have it only do it when it's quite sure, because it does add some amount of time to how long it takes it to work on it. But we also have added things like the /repro command, where you can just do, you know, fix this bug /repro, and then it will know that it should first make you a video of it actually finding and making sure it can reproduce the bug.

**Swyx** [13:52]
Yeah. Yeah. One sort of ML topic this ties into is reward hacking, where while you write test that you up- they only pass, right? So first write test, it shows me it fails, then make your test pass, which is a classic, like red, green-

**Jonas Nelle** [14:04]
Yep

**Swyx** [14:04]
... like, uh-

**Jonas Nelle** [14:05]
TDD

**Swyx** [14:05]
... TDD thing.

**Jonas Nelle** [14:06]
Right.

**Swyx** [14:07]
No, very cool. Uh, was that the last demo? Is there a certain amount of-

**Jonas Nelle** [14:09]
Yeah. Anything I missed on the demos or points that you think-

**Sam Whitmore** [14:12]
I think that covers it well, yeah.

### Slash Commands

**Swyx** [14:13]
Cool. Um, before we stop the screen share, can you give me, like, a, just a tour of the slash commands? 'Cause I... There's so goddamn many and I'm like, "Well, what, what are the good ones?"

**Sam Whitmore** [14:22]
Yeah, we wanna increase discoverability around this too. I think that'll be, like, a future thing we work on.

**Swyx** [14:27]
Yeah.

**Sam Whitmore** [14:27]
But there's a, definitely a lot of good stuff now.

**Jonas Nelle** [14:29]
We have a lot of internal ones that I think will not be that interesting. Here's an internal one that I've made. I don't know if anyone else at Cursor uses this one.

**Swyx** [14:37]
Fix BB?

**Sam Whitmore** [14:38]
I've never heard of it.

**Jonas Nelle** [14:38]
Yeah.

**Swyx** [14:39]
Wow.

**Jonas Nelle** [14:39]
Fix BugBot. So this is a thing that we want to integrate more tightly-

**Swyx** [14:43]
So you made this for yourself

**Jonas Nelle** [14:44]
... coming up. I made this for myself. It's actually available to everyone in the team, but-

**Sam Whitmore** [14:47]
Yeah

**Jonas Nelle** [14:47]
... no one knows about it. But yeah, there will be BugBot comments, and so BugBot has a lot of cool things. We actually just launched BugBot Autofix, where you can click a button and, uh, 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, you know, is a regression and actually you meant to do something more like that, and so having the original prompt and all the context of the agent that worked on it.

And so here I could just do, you know, fix, uh, or I used to be able to do fix BB and it would, um, do that. Uh, no-test is another one that we've had. /repro is in here. We mentioned that one.

**Sam Whitmore** [15:36]
One of my favorites is Cloud Agent Diagnosis. This is one that, um, makes heavy use of the Datadog MCP.

**Swyx** [15:41]
Okay.

**Sam Whitmore** [15:42]
And, um, I think Nick and David on our team wrote, and basically if there is a problem with a cloud agent, um, we'll spin up a bunch of subagents-

**Swyx** [15:50]
Like a single instance

**Sam Whitmore** [15:50]
... yeah, we'll, we'll take the ID as an argument and spin up a bunch of subagents using the Datadog MCP to explore the logs and find, like, all of the problems that could have happened with that. It takes the debugging time, like, from, like, potentially...

I mean, you can do s- quick stuff quickly with the Datadog UI, but it takes it down to, again, like a single agent call as opposed to, like, trawling through logs yourself.

**Jonas Nelle** [16:11]
You should also talk about the stuff we've done with transcripts.

**Sam Whitmore** [16:13]
Yes. Also, um, so basically we've also done some things internally. There'll be some versions of this as we ship publicly soon where, um, you can spin up an agent and give it access to another agent's transcript, um, to either, um, basically debug something that happened, so kind of like act as an external debugger-

**Swyx** [16:32]
I see

**Sam Whitmore** [16:33]
... or continue the conversation almost, like, forking it.

**Swyx** [16:35]
A transcript includes all the chain of thought for the 11 minutes here, 45 minutes there-

**Sam Whitmore** [16:39]
Yeah, exactly

**Swyx** [16:40]
... the whole thing.

**Sam Whitmore** [16:40]
So basically acting as a, like, secondary agent that debugs the first. Um, so we, we've started to push more-

**Swyx** [16:48]
And they're all the same code, it is just the different prompts, but the s- the same-

**Sam Whitmore** [16:52]
Yeah. So basically-

**Swyx** [16:53]
... agent

**Sam Whitmore** [16:53]
... same cloud agent infrastructure, and then same harness, and then, like, when we do, um, things like include, like, there's some extra infrastructure that goes into piping in, like, an external transcript if we include it as an attachment.

Um, but, um, for things like the cloud agent diagnosis, that's mostly just using the Datadog MCP. Um, 'cause we also launched MCPs along with, um, along with this cloud agent, uh, launch, launch support for cloud agent MCPs that-

**Jonas Nelle** [17:18]
Oh, that was drowned out.

**Sam Whitmore** [17:19]
I know.

**Jonas Nelle** [17:20]
We will, we will be doing a bigger marketing moment for it next week.

**Sam Whitmore** [17:23]
But yeah.

**Jonas Nelle** [17:24]
But you can now use MCPs in, uh-

**Swyx** [17:26]
No, people will listen to this while we're like, "Okay"

**Jonas Nelle** [17:26]
... yeah, they'll be ahead of the curve.

**Sam Whitmore** [17:28]
No, you'll be ahead. Um, and, uh, I would... Uh, I, I actually don't know if the Datadog MCP is, like, publicly available yet. I realize this, uh-

**Jonas Nelle** [17:35]
We're not sure

**Sam Whitmore** [17:36]
... if we're beta testing it, but, um, it's been one of my favorites to use. Um, so...

**Swyx** [17:40]
I think the, that, that one's interesting for Datadog-

**Sam Whitmore** [17:43]
Yeah

**Swyx** [17:43]
... 'cause Data- Datadog wants to own that side, right-

**Sam Whitmore** [17:45]
Interesting

**Swyx** [17:45]
... with, with Bits. I don't know if you've tried Bits.

**Sam Whitmore** [17:47]
I haven't tried Bits.

**Swyx** [17:48]
Yeah. Um-

**Jonas Nelle** [17:49]
That is their, their cloud agent product.

**Swyx** [17:51]
Yeah. Yeah. They want to be like, "Well, we own your logs," and they give us our, some part of the, you know, self-healing software that everyone wants.

**Jonas Nelle** [17:59]
Yeah.

**Swyx** [18:00]
But obviously Cursor has a strong opinion on coding agents and, uh, you're, you're kind of, like, taking away from the... Which, which, like, obviously you're going to do, and not every company's like Cursor, but, uh, it's interesting if you're a Datadog, like, what do you do here?

Do you expose your logs through MCP-

**Jonas Nelle** [18:14]
Yeah

**Swyx** [18:15]
... and let other people do it? Or do you try to own that as, because it's extra business for you?

**Jonas Nelle** [18:19]
Yeah.

**Swyx** [18:20]
It's, like, an interesting one.

**Sam Whitmore** [18:21]
It's a good question. All I know is that I love the Datadog MCP.

**Swyx** [18:25]
Yeah. Uh, and like, yeah, it, it's gonna be no, no surprise that people, like, will demand it, right?

**Sam Whitmore** [18:30]
Yeah.

**Swyx** [18:31]
It is, you know, it's like any system or record company, like, this-

**Sam Whitmore** [18:34]
Yeah

**Swyx** [18:34]
... it's, it... Like, how much do you give away, you know? Uh, cool. Uh, I think that's that for, uh, the sort of cloud agents tour. Um, cool. A- a- and we just kind of talk about... Like, cloud agents have been, uh...

When, when did Cursor launch cloud agents? Do you, do you know?

**Jonas Nelle** [18:47]
In June last year.

**Swyx** [18:48]
June last year? Yeah, so it's, like, been a slowly evolving thing. You did, like, a bunch of... Like, Michael did a, a, a post for himself where he, like, showed this chart of, like, agents overtaking tab. Right? And I'm like, "Wow, this is like the biggest transition in code."

**Jonas Nelle** [19:02]
Yeah

**Swyx** [19:03]
Like, in, in, like, the, the last year.

**Jonas Nelle** [19:05]
Yeah, I think that kind of got drowned out.

**Sam Whitmore** [19:07]
Yeah.

**Jonas Nelle** [19:07]
I think it's a very interesting-

**Swyx** [19:08]
Not at all. I, I, I think it's been-

**Jonas Nelle** [19:10]
Okay

**Swyx** [19:10]
... highlighted-

**Jonas Nelle** [19:11]
Okay

**Swyx** [19:11]
... by, uh, our friend Andrej Karpathy today.

**Jonas Nelle** [19:13]
Okay.

**Swyx** [19:13]
Um, talk more about it. Like, what, what does it mean?

**Jonas Nelle** [19:15]
Yeah, yeah.

**Swyx** [19:15]
Like, is it... I, I just got given, like, the, the Cursor tab key.

**Jonas Nelle** [19:18]
Yes, yes.

**Swyx** [19:19]
That's like-

**Sam Whitmore** [19:19]
Cool.

**Swyx** [19:20]
I know, but it's gonna be, like, put in a museum.

**Jonas Nelle** [19:22]
It is.

**Sam Whitmore** [19:23]
I have to say, I haven't used tab in a little bit myself.

**Jonas Nelle** [19:26]
Yeah, I think that what it looks like to code with AI, or code generally, create software even, if you wanna go higher level, is changing very, very rapidly. No- not a hot take, but I think from our vendor's 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, you know, 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, uh, looking at text files and editing code. Like, we call it hand coding now.

When you, like, type out the actual letters, it's like a, you know-

**Swyx** [20:05]
Like, "Oh, that's cute."

**Jonas Nelle** [20:06]
Yeah. "Oh, that's cute."

**Swyx** [20:07]
So Boomer.

**Jonas Nelle** [20:07]
So Boomer. Um, and so that, I think, has been sort of 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 like, "It's great, but I actually just wanna give more to the agent, and I don't want to do like 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 sort of 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 GIFs, and you're sort of, like, in the weeds and giving it, you know, 30-second to three-minute tasks, to you're giving it, you know, three-minute to 30-minute to three-hour tasks.

And you're getting back videos and sort of trying out previews rather than immediately looking at GIFs every single time.

**Swyx** [20:56]
Yeah. Anything to add?

**Sam Whitmore** [20:57]
One other shift that I've noticed, um, as our cloud agents have really taken off internally, has been a shift from primarily individually driven development to almost this, like, collaborative nature of development. For us, Slack is actually almost like a development, um, an ID basically.

Because-

**Swyx** [21:14]
That's why I'm like, maybe, maybe don't b- even build a custom UI. Like, maybe like, you know, that's like a debugging thing, but actually it's Slack.

**Sam Whitmore** [21:21]
I feel like, yeah, there's still so much to... left to explore there. But uh, basically for us, like, Slack is where a lot of development happens. Like, we will have these issue channels, um, or just like just product discussion channels where people are always @Cursoring, and that kicks off a Cloud Agent.

And, um, for us at least, we have team follow-ups enabled. So if Jonas kicks off a @Cursor in a thread, I can follow up with it and kind of like add more context. And so it turns into almost like a discussion service where people can kind of like collaborate on UI.

Oftentimes I will kick off an investigation and then, like, um, sometimes I even ask it to, like, get blame and then tag people who should be brought in, 'cause it can tag people in Slack, and then k- other people will come in-

**Swyx** [22:02]
Cursor can tag other people who are not involved in the conversation.

**Sam Whitmore** [22:06]
Yes.

**Jonas Nelle** [22:06]
Can just do @Jonas if Sam is talking to-

**Sam Whitmore** [22:08]
Yeah, like it... Yeah, it can figure out, like-

**Swyx** [22:09]
That's cool. You sh- you guys should make a big deal out of that.

**Sam Whitmore** [22:11]
I know. Um, there's a lot to... I feel like there's a lot more to do with our Slack surface area, um, ex- to show people externally. But yeah, basically, like, it can bring other people in, and then other people can also contribute to that thread.

And you can end up with a PR, again, with the artifacts visible, and then people can be like, "Okay, cool. We can merge this." So for us, it's like the ID is almost, like, moving into Slack in some ways as well.

**Swyx** [22:34]
I have the same experience, um, with... m- but it's not developers. It's me, designer, salespeople.

**Sam Whitmore** [22:40]
Yeah.

**Swyx** [22:40]
You know? So me on, like, technical marketing vision, designer on design, and then salespeople on like, "Well, here's the legal terms of what we agreed on." And then they all just collaborate and, like, correct, uh, the agents.

**Jonas Nelle** [22:52]
A thing that we found in these threads is the work that is left that the humans are discussing in these threads is the nugget of what is actually interesting and, and relevant. It's not like, you know, the boring details of where does this if statement go.

It's like, do we wanna ship this? Is this the right UX? Is this the right form factor?

**Swyx** [23:10]
Yeah.

**Jonas Nelle** [23:10]
Uh, you know, how do we make this more obvious to the user? It's like those really interesting kind of higher order questions that are so easy to collaborate with and leave the implementation to the, to the Cloud Agent.

**Sam Whitmore** [23:21]
Totally. And no more discussion of like, "Am I gonna do this? Are you gonna do this?" Cursor's doing it. You just have to decide you like it.

**Swyx** [23:27]
Sometimes the... I don't know if there's a... this prob- You guys probably figured this out already, but sometimes you need like a mute button. So like, Cursor, like, we're gonna take this offline but still online. Uh, but like, we need to talk among the humans first before you, like, s- could stop responding to everything, right?

**Jonas Nelle** [23:42]
Yeah. This is a design decision where currently Cursor won't chime in unless you explicitly @mention it.

**Swyx** [23:48]
Yeah.

**Sam Whitmore** [23:49]
Yeah. So it's not always listening.

**Swyx** [23:50]
Yeah, yeah, yeah.

**Sam Whitmore** [23:51]
Yeah.

**Jonas Nelle** [23:51]
One can see all the intermediate messages.

**Swyx** [23:53]
Have you, have you done the recursive, like, can Cursor @ another Cursor or, like, spawn another Cursor?

**Sam Whitmore** [23:58]
Oh.

**Jonas Nelle** [23:58]
We've done some versions of this. So-

**Swyx** [24:00]
'Cause, you know, 'cause it can add humans.

**Jonas Nelle** [24:01]
Yes. One of the other things we've been working on that's sort of 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 know, you solve one bottleneck, and three new ones pop up.

**Swyx** [24:15]
Yeah.

**Jonas Nelle** [24:15]
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." Uh, which is like, it's so easy to get to, "I have a PR for that," but it's kind of 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 a 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-

**Swyx** [24:46]
I mean, isn't that what-

**Jonas Nelle** [24:47]
... to merge

**Swyx** [24:47]
... uh, isn't that what Graphite's for? Like-

**Jonas Nelle** [24:49]
Graphite is a big part of that. Uh, the Cloud Agents testing-

**Swyx** [24:53]
Is it, is it fully integrated, or it's still different companies?

**Jonas Nelle** [24:56]
Working on, like... 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.

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

**Swyx** [25:18]
Sorry, this, uh, this was completely unplanned, but, like, there, I heard people arguing one to, like, you need AI to review AI.

**Sam Whitmore** [25:25]
Mm.

**Swyx** [25:26]
And then there's another approach, thought, school of thought, where it's like, no, reviews are dead. Like, just show me the video. That's kind of it, like

**Sam Whitmore** [25:35]
Yeah. I feel like, again, for me, the video is often, like, alignment, and then I often still, like, wanna go through a code review process. Um-

**Swyx** [25:42]
Like s- like, like still look at the files and everything. Yeah

**Sam Whitmore** [25:43]
There's, there's a spectrum, of course. Like, the video c- if it's really well done and it does, like, uh, like, fully, like, tests everything, you can feel pretty confident. But it's still helpful to, to look at the code.

Um, I make, pay a lot of attention to BugBot. I feel like BugBot has been a great, um, really highly adopted internally. We often, like, won't... We tell people, like, "Don't leave BugBot comments unaddressed," 'cause we have such high confidence in it.

So people always address their BugBot comments.

**Jonas Nelle** [26:06]
Once you've had, like, two cases where you merged something and then you went back later, there was a bug in it, you merged it, you went back later, and you were like, "Oh, BugBot had found that. I should have listened to BugBot."

Once that happens two or three times, you learn to wait for BugBot.

**Sam Whitmore** [26:17]
Yeah. So, so I think for us there's, like, that code-level review, where, like, it's looking at the actual code, and then there's kind of like the, um, like, feature-level review, where you're looking at the features. There's, like, a whole number of different, like, areas.

Uh, there'll probably eventually be things like performance level review, security review-

**Swyx** [26:34]
Mm

**Sam Whitmore** [26:35]
... things like that where it's, like, more, uh, more different aspects of how this feature might affect your code base that you want to potentially leverage an agent to help with.

**Jonas Nelle** [26:44]
And some of those, like BugBot, will be kind of 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 DevX 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, you know, uh, release frequently, release slowly, like, have different stages where you release, have checkpoints, automated ways of detecting regressions.

Uh, and so I think we're gonna need-

**Swyx** [27:22]
Like stack diffs, merge-

**Jonas Nelle** [27:23]
Stack diffs

**Sam Whitmore** [27:24]
Yeah

**Jonas Nelle** [27:24]
... merge queues. Exactly. A lot of those things are going to be important.

**Swyx** [27:27]
Full disclosure, I think the majority of people still don't know what stack diffs are. Uh, and you know, I, I, like, I have many friends in Facebook and, like, I, I'm pretty friendly with Graphite. I've just, I've never needed it, 'cause I don't work on this, at larger team.

And, like, it's just, like, democratization of, like, you know, here's, here's what we've already worked out at s- at very large scale, and here's how you can, it benefits you, too. Like, l- uh, I think 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, like, actually collaboration software

**Jonas Nelle** [27:57]
Yep

**Swyx** [27:58]
And, like, I don't think a lot of dev tools have figured that out yet, that, that transition from, like, large down to small.

**Jonas Nelle** [28:03]
Yeah. Cursor is probably an inverse story.

**Swyx** [28:06]
This is small down to large

**Jonas Nelle** [28:07]
Yeah. Where historically, Cursor, part of why, uh, we grew so quickly was anyone on the team could pick it up. And in fact, people would pick it up, you know, on the weekend for their side project and then, uh, bring it into work, 'cause they loved using it so much.

**Swyx** [28:20]
Yeah.

**Jonas Nelle** [28:20]
Um, and I think a thing that we've started working on a lot more, not us specifically, but as a company and, and other folks at Cursor, is making it really great for teams and making it that, you know, the 10th 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 plugins, um, 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, uh-

**Sam Whitmore** [28:53]
Oh, yeah

**Jonas Nelle** [28:53]
... you've also been using a lot. Uh, so I see-

**Sam Whitmore** [28:56]
That's also pre-launch, but I feel like it's so good.

**Jonas Nelle** [28:58]
Yeah. My Cursor should be configured if Sam feels strongly that that's just amazing and required.

**Swyx** [29:03]
Is it, is it automatically shared, or you have to, like, go and-

**Jonas Nelle** [29:07]
Uh, it depends on the MCP. So some are obviously auth per user.

**Swyx** [29:10]
Yeah

**Jonas Nelle** [29:10]
And so Sam can't auth my Cursor with my Slack MCP, but some are team, team auth, and those can be set up, uh, by admins.

**Swyx** [29:17]
Yeah. Yeah, that's cool. Um, yeah, I mean, I think, you know, we, we, we had, uh, Aman on the pod when Cursor was five people, and, like, everyone was like, "Okay, well, what's the thing?" And then it's, it's usually something, something teams and org and enterprise.

But, like, it's actually working . But, like, usually at that stage when you're five, when you're just a VS Code fork-

**Jonas Nelle** [29:38]
Yeah

**Swyx** [29:38]
... like, it's like, how do you get there?

**Jonas Nelle** [29:40]
Yeah.

**Swyx** [29:40]
Will people pay for this? Uh, people do pay for it.

**Jonas Nelle** [29:43]
Yeah. And I think for cloud 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.

**Swyx** [29:57]
Yes.

**Jonas Nelle** [29:57]
You know, if you need, like, some insane Docker layer caching thing for builds not to take like 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.

**Swyx** [30:12]
This is a good chance for me to just ask some technical sort of check the box questions. Uh, can I choose the size of the VM?

**Jonas Nelle** [30:18]
Not yet. We are planning on adding that. We have-

**Swyx** [30:20]
Because obviously you want, like, L, XXL, whatever, right?

**Jonas Nelle** [30:23]
Yeah

**Swyx** [30:23]
Like, it's like the Amazon, like, sort of menu items.

**Jonas Nelle** [30:25]
Yes, yes. Exactly. We will add that.

**Swyx** [30:27]
Yeah. In some ways you have to basically become like a EC2 almost. Like, you rent a box.

**Jonas Nelle** [30:33]
You rent a box, yes.

**Swyx** [30:34]
Right

**Jonas Nelle** [30:34]
We talk a lot about brain in a box.

**Swyx** [30:36]
Yeah

**Jonas Nelle** [30:37]
Uh, so at Cursor, we want to be a brain in a box.

**Swyx** [30:38]
But, like, is the mental model different? Is it more serverless? Is it more persistent? Is it something else?

**Sam Whitmore** [30:46]
We want it to be a bit persistent. I mean, the desktop should be kind of something you can return to af- even after some days. Like, maybe you go back there, like, still thinking about a feature for some period of time, so.

**Swyx** [30:56]
Like full, like sus- like suspend the memory and bring it back and then keep going.

**Sam Whitmore** [30:59]
Exactly.

**Swyx** [31:00]
That's an interesting one, because, like, uh, what I actually do want, like, from, like, a Manus, an OpenCloud, whatever, is, like, I want to be able to log in, uh, with my credentials to the thing, but, like, not actually store it in any, like, secret s-store or whatever.

'Cause it's like this is my most sensitive stuff.

**Sam Whitmore** [31:14]
Yeah

**Swyx** [31:14]
This is, like, my email, whatever. Um, and just have it- Like, you know, persist through, like, the image. I don't know how it was under a hood, but, like, to rehydrate and then just keep going from there. But I don't think a lot of infra works that way.

A lot of it's stateless, where, like, you save it to a Docker image, and it, it's only whatever you can describe in a Docker file, and that's it. Because that's the only thing you can clone multiple times-

**Jonas Nelle** [31:35]
Yeah

**Swyx** [31:35]
... in parallel.

**Jonas Nelle** [31:36]
Yeah, we have a bunch of different ways of setting them up. So there's a Docker file-based approach. Um, the main default way is actually snapshotting.

**Swyx** [31:44]
Like a Linux VM.

**Jonas Nelle** [31:45]
Like a VM, right. You, um, run a bunch of install commands, and then you snapshot more or less the, 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.

**Swyx** [31:57]
Yeah.

**Jonas Nelle** [31:58]
Um, and that's a bit distinct from what Sam was talking about with the, uh, hibernating and re-rehydrating, where that is a full memory snapshot as well. So there, if I had, like, the browser open to a specific page, and we bring that back, that page will still be there.

**Swyx** [32:10]
Was there any discussion internally in just building this stuff about, like, y- you know, every time you show the video, it's actually, you show a little bit of the desktop and the browser, and it's kind of not necessary if you just show the browser.

Like, if, if you know, if you know you're just demoing a front end application, why not just show the browser, right? Like, it's, uh-

**Sam Whitmore** [32:26]
We do have some panning and kind of zooming.

**Swyx** [32:28]
Yeah.

**Sam Whitmore** [32:28]
Like, it can decide the... when it's actually recording and cutting the video to highlight different things.

**Swyx** [32:34]
Yeah.

**Sam Whitmore** [32:34]
I think we played around with different ways of segmenting it and kind of, uh... Yeah, there's been some different revs on it, for sure.

**Jonas Nelle** [32:41]
Yeah, I think one of the interesting things is the version that you see now in cursor.com actually is, like, half of what we had at peak, where we've decided to unship or unshipped quite a few things. So two of the interesting things to talk about, one is directly in answer to your question, where we had a native browser that you would have locally.

It was basically an iframe that, via port forwarding, could load the URL, could talk to localhost in the VM. So that gets you basically-

**Swyx** [33:10]
So in your machine's browser, like-

**Jonas Nelle** [33:13]
In your local browser.

**Swyx** [33:14]
Yeah, yeah, yeah.

**Jonas Nelle** [33:14]
You would go to localhost:4000, and that would get forwarded to localhost:4000 in the VM via, via port forwarding.

**Swyx** [33:22]
Yeah, yeah.

**Jonas Nelle** [33:22]
We unshipped that.

**Swyx** [33:22]
Like an ngrok.

**Jonas Nelle** [33:23]
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, you know, VS Code fork, and, uh, I think inherited a lot of amazing things, but also a lot of legacy UI from VS Code.

### Design Decisions

**Jonas Nelle** [34:01]
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 our, our philosophy around it. The other thing that is maybe interesting to talk about that we unshipped is, uh...

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 we-

**Swyx** [34:36]
Put it out there. Let, let users tell you they want it and then-

**Jonas Nelle** [34:38]
Exactly

**Swyx** [34:39]
... all right, fine.

**Jonas Nelle** [34:40]
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, the tab there earlier, to also have a Files app where you could see and edit files.

**Swyx** [34:56]
Right.

**Jonas Nelle** [34:56]
And we actually felt that 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, we thought was really valuable.

And so there's currently no way in Cursor Web to edit these files.

**Swyx** [35:15]
Yeah, except you, like, open up the PR and go to GitHub and, like, do the thing.

**Jonas Nelle** [35:18]
Yeah.

**Swyx** [35:19]
Which, uh, is annoying.

**Jonas Nelle** [35:20]
Just tell the agent.

**Swyx** [35:21]
I have criticized OpenAI for this, um, because OpenAI's Codex app doesn't have a file editor. Like, it has file viewer, but it doesn't have a file editor.

**Jonas Nelle** [35:29]
Do you use the file viewer a lot?

**Swyx** [35:30]
No. I understand, but, like, sometimes I want it. The only way to do it is, like, freaking go into... Uh, no, they have a, they have a open in Cursor button or open in Antigravity or, you know, open in whatever, and people point to that.

Uh, yeah, so I was, you know, I was part of, like, the early testers group. People pointed to that, and they were like, "This is, like, a q- like, 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."

**Jonas Nelle** [35:58]
Yeah, I think w- 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, uh, like, you won't be doing that in Slack. Uh, 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 s- kicked off joking about this, uh, people, like, don't really edit files hand code anymore.

Uh, and so we want to build for where that's going and-

**Swyx** [36:37]
Yeah

**Jonas Nelle** [36:37]
... not where it's been.

**Swyx** [36:38]
A lot of cool stuff. And, okay, uh, I have a couple more observations about the design elements about these things. One of the things that I'm always thinking about is, well, Cursor and, and other, uh, peers of Cursor start from, like, the dev tools and work their way towards cloud agents.

Other people, like the Lovables and Bolts of the world, start with, like, here's, like, the vibe code, full cloud thing. They were already cloud agents before anyone else was cloud agents really. And, and we'll give you the full deploy platform, and so we own the whole loop.

We own, own all the infrastructure. We o- we, we have the logs. We have the, uh, the live site, whatever. And you can do that cycle. Cursor doesn't own that cycle even today, right? You, you don't have the Vercel.

You don't have the whatever deploy infrastructure that you, that you're gonna have, which gives you powers because- Anyone can use it and any enterprise who, whatever you're in for, I don't care. But then also gives you limitations as to how much you can actually fully debug end to end.

I guess I'm just putting out there that, like, is there a future where there's, like, full stack Cursor where, like, cursorapps.com, where, like, I host my Cursor site or this, which is basically a Vercel clone, right? Like, I don't know.

**Jonas Nelle** [37:39]
I think that's a, an interesting question to be, 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.

**Swyx** [37:48]
Yeah.

**Jonas Nelle** [37:48]
I think right now we're really focused on kind of what we see as the next big bottleneck, and because things like the Datadog MCP exist-

**Swyx** [37:55]
Yeah

**Jonas Nelle** [37:56]
... I don't think that the best way we can help our customers ship more software is by building a hosting solution right now.

**Swyx** [38:02]
By the way, these are things I've actually discussed with some of the companies I just named.

**Jonas Nelle** [38:05]
Yeah, yeah, yeah. For sure. Right now, just this, this big bottleneck is getting, getting the code out there. And also, unlike, uh, uh, Lovable and The Bolt, we focus much more on sort of existing software and the zero to one greenfield is just a very different problem.

You know, imagine going to, like, a Shopify and convincing them to deploy on your deployment solution. That's very, very different, and I think will take, uh, much longer to see how that works, may never happen, um, relative to, oh, it's like a zero to one app.

**Swyx** [38:35]
I'll say it's kind of tempting because look, like, 50% of your apps are Vercel, Supabase, Tailwind, React. Like, you know, it's the stack. It's, it's what everyone does. So I don't know. It's kind of interesting.

**Jonas Nelle** [38:49]
Yeah.

### Model Routing

**Swyx** [38:49]
The other thing is the models that you're dying, right? Right now in Cloud Agents, it's, like, stuck down bottom left. Sure, it's Codex High today, but, like, do I care if it suddenly switched to Opus? Probably not.

**Sam Whitmore** [39:00]
We definitely want to give people a choice across models because I feel like it, the meta changes very frequently. I was a big, um, like, Opus 4.5 maximalist, and when, um, Codex 5.3 came out, I hard, hard switched, so that's all I use now.

**Swyx** [39:13]
So yeah, a-agreed. Uh-

**Sam Whitmore** [39:15]
Yeah

**Swyx** [39:15]
... I don't have any issues. We basically, like, when I use it in Slack, right, uh, Cursor does a very good job of exposing, uh-

**Sam Whitmore** [39:21]
Yeah

**Swyx** [39:21]
... Cursor, so if, if people go use it, here's the model we're using.

**Sam Whitmore** [39:24]
Yeah.

**Swyx** [39:24]
Here's, here's how you switch if you want. But otherwise, it's, like, kind of extracted away, which is, like, beautiful because then you, actually you should decide.

**Jonas Nelle** [39:31]
Yeah, I think we want to be doing more with defaults-

**Swyx** [39:34]
Yeah

**Jonas Nelle** [39:35]
... where we can suggest things to people. A thing that we have in the editor, the desktop app, is auto, which will sort of route your request and do sort of things there. So I think we will want to do something like that for cloud agents as well.

We haven't done it yet. Uh, 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, you know, we are the experts.

**Swyx** [40:04]
Yeah.

**Jonas Nelle** [40:04]
We have both the traffic and the internal taste and experience to know what we think is best.

**Swyx** [40:08]
Yeah. So, you know, I have this ongoing thesis of agent lab versus model lab, and to me, Cursor and other companies are, are example of an agent lab that is, you know, building a new playbook that is different from a model lab where it's, like, very GPU heavy, although it obviously has a research, uh, team.

And yeah, my thesis is like you just, e-every agent lab is going to have a router. You, 'cause you are going to be asked, like, what's, what... Like, I don't keep up to every day. I'm not a Sam.

I don't keep up every day for using you as example the arbiter of taste. Um, put me on Cursor Auto. Is, is, is it free? Is it, it's not free.

**Jonas Nelle** [40:40]
Uh, auto is not free, but there's different pricing tiers. Yeah.

**Swyx** [40:43]
Put me on Cursor Auto. Then you decide for me based on, like, all, all the other people you know better than, than me. And, like, I think every agent lab, uh, should basically end up doing this because that, that actually gives you extra power because you, like, people stop caring or having loyalty-

**Jonas Nelle** [40:58]
Mm-hmm

**Swyx** [40:58]
... to any one lab.

### Councils

**Jonas Nelle** [40:59]
Yeah. Two other maybe interesting things that I don't know how much they're on your radar are, one, the best-of-N thing we mentioned, where running different models head-to-head is actually quite interesting because-

**Swyx** [41:09]
Which exists in Cursor-

**Jonas Nelle** [41:11]
That exists in Cursor-

**Swyx** [41:12]
... IDE only

**Jonas Nelle** [41:12]
... IDE and web. So the problem is where do you run them?

**Swyx** [41:15]
Okay.

**Jonas Nelle** [41:15]
Um, and so I, I can share my screen again-

**Swyx** [41:17]
Yeah, yeah

**Jonas Nelle** [41:17]
... if that's interesting.

**Swyx** [41:18]
Yeah, yeah. I mean, obviously, parallel agents, very topical.

**Jonas Nelle** [41:21]
Yes, exactly. Parallel agents.

**Swyx** [41:23]
You don't mind, are they the same thing, best-of-N and parallel agents? I don't want to put words in your mouth.

**Jonas Nelle** [41:26]
Best-of-N is a subset of parallel agents where they're running on the same prompt. 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.

**Swyx** [41:39]
Yeah.

**Jonas Nelle** [41:39]
And now if I do a prompt, I'm going to do something kind of silly. I am running, uh, these five models.

**Swyx** [41:46]
Okay, this is a straight clone of Cursor 2.0. Yeah.

**Jonas Nelle** [41:49]
Yes, exactly. Uh, but they are running, uh, so the Cursor 2.0, 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, like, won't try to kill ports that the other one is running, which are some of the pains people have.

**Swyx** [42:06]
These are all Cloud Worktrees?

**Jonas Nelle** [42:08]
No, these are all cloud agents with their own VMs.

**Swyx** [42:11]
Okay. But when-

**Jonas Nelle** [42:12]
When you do it locally, sometimes people do Worktrees, and that's been the main way that people have set up parallel agents so far.

**Swyx** [42:16]
I gotta say, that's so confusing for folks.

**Jonas Nelle** [42:18]
Yeah.

**Swyx** [42:18]
No one knows what Worktrees are.

**Jonas Nelle** [42:20]
Exactly. I think we're phasing out Worktrees.

**Swyx** [42:23]
Really?

**Jonas Nelle** [42:23]
Yeah.

**Swyx** [42:24]
Okay.

**Sam Whitmore** [42:24]
But yeah, and one other thing I would say though on the multi-model choice, so this is another experiment that we ran last year and, um, didn't decide to ship at that time but may come back to. And there was an interesting learning that's relevant for, um, these different model providers.

Um, it was something that would run a bunch of best-of-Ns but then synthesize and kind of, um, basically run like a synthesizer layer of models and, uh, that was kind of other agents-

**Swyx** [42:51]
Yeah, LM Judge

**Sam Whitmore** [42:52]
... that would, like, take-

**Swyx** [42:52]
Yeah

**Sam Whitmore** [42:52]
... LM Judge, but one that was also agentic and could write code.

**Swyx** [42:55]
Yeah.

**Sam Whitmore** [42:55]
So it wasn't just picking, but also, like, taking the learnings from y- two models or end models that it was looking at and writing a new diff. And 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.

Um, like basically you could get almost like a synergistic output that was better than having like a very unified, like bottom model tier. Um, so, so it was really interesting 'cause it's like po- potentially even though even in the future when you have like maybe one model is ahead of the other for a little bit, there could be some benefit from having like multiple top-tier models involved in like a model swarm or whatever agent swarm that you're doing.

That they each have strengths and weaknesses. Yeah.

**Swyx** [43:38]
Uh, Andrej called this a council, right? Like-

**Sam Whitmore** [43:40]
Yeah, yeah, yeah, exactly. We actually... Oh, that's another internal command we have that, um, Ian wrote, /council.

**Swyx** [43:45]
Oh, interesting.

**Sam Whitmore** [43:45]
Which will descend. Yeah.

**Swyx** [43:47]
I mean, yes. So this, this idea is in various forms everywhere, and like, uh, I think for me, like for me, the productization of it, you guys have done like a-

**Sam Whitmore** [43:55]
Yeah

**Swyx** [43:55]
... like this is very flexible, but if I were to add another-

**Sam Whitmore** [43:59]
Yeah

**Swyx** [43:59]
... what your thing is on here, it, it would be too much. I don't want let's say.

**Sam Whitmore** [44:03]
Well, ideally it's all... it's something that the user can just choose, and it all happens under the hood in a way where like 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.

**Swyx** [44:17]
Okay.

### Subagents

**Jonas Nelle** [44:18]
Another thing on the many agents and different parallel agents that's interesting is an idea that's been around for a while as well that has started working recently, is subagents. And so this is one other way to get agents of the different prompts and different goals and different models, different vintages to work together and collaborate, um, and delegate.

**Swyx** [44:42]
Yeah. Um, I'm very... Like, I, I... Like one of my f- I'm always looking for like, this is the year of the blah, right?

**Sam Whitmore** [44:47]
Yeah.

**Swyx** [44:48]
I think one of the things on the blahs is subagents. I think this year sort of. Um, but I haven't used them in Cursor. Um, are they fully formed? Or-

**Sam Whitmore** [44:57]
Like-

**Swyx** [44:57]
Or what, how do... Like, I obviously need like an intro because do I form them from new every time? Do I, do I have fixed subagents? Uh, how are they different from slash commands? Like, there's all these like really basic questions that no one stops to answer for people because everyone's just like too busy launching week after week.

**Sam Whitmore** [45:15]
Yeah. Honestly, I mean, well you can, you can see them in Cursor now if you just say like spin up like 50 subagents to explore the code-

**Swyx** [45:21]
So Cursor defines what subagents, you know?

**Sam Whitmore** [45:23]
Yeah. So basically, um, I think... Well, I shouldn't speak for the whole subagents team. This is like a different team that's been working on this, but, um, a thesis or thing that we kind of saw internally is that like they're great for context management, for kind of long-running threads, or if you're trying to just throw more compute at something.

We have strongly used almost like a generic task interface where then the main agent can define like what goes into the subagent. So if I say like, "Explore my code base," it might decide to spin up an explore subagent and, um...

or might despi- decide to spin up like five explore subagents.

**Swyx** [45:55]
Right-

**Sam Whitmore** [45:55]
Um

**Swyx** [45:55]
... but I don't get to set what those subagents are, right? It's, it's all defined by the model.

**Sam Whitmore** [45:59]
I think I actually would have to refresh myself on the subagent interface.

**Swyx** [46:01]
You see, this is quite so hard to get.

**Jonas Nelle** [46:03]
Um, there are some built-in ones like the explore subagent is sort of pre- pre-built. Um, but you can also instruct the model to use other subagents, and then it will. Um, and one other example of a built-in subagent is, um, I actually just kicked one off in Cursor, and I can show you what that looks like.

**Swyx** [46:20]
Yes. 'Cause I tried to do this in pure prompt space.

**Jonas Nelle** [46:23]
So this is the desktop app-

**Swyx** [46:24]
Yeah, okay. Uh, yeah, yeah

**Jonas Nelle** [46:24]
... and, uh-

**Swyx** [46:25]
That's all you need to do, right? Yeah

**Jonas Nelle** [46:26]
... that's all you need to do. So I said, "Use a subagent to explore," and I think... Yeah, so I can even click in and see what the subagent is working on here. It ran some find command, and this is a composer, uh, 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, um, to get an answer quickly.

But that, this is what subagents look like, and I think we want to do a lot more to expose hooks and ways for people to configure these. Um, another example of a cos- sort of built-in subagent is the computer use subagent in the Cloud Agents, where we found that those trajectories can be kind of long and involve a lot of images obviously, and sort of execution of some testing verification task.

We want to use the models that are particularly good at that, so that's one reason to use subagents. And then the other reason to use subagents is we want, uh, contexts to be sort of summarized, reduced down at a subagent level.

That's a really neat boundary at which to compress that rollout and testing into a final message that that agent writes that then gets passed into the parent rather than having to do some global compaction or something like that.

**Swyx** [47:40]
Awesome. Cool. Uh, while we're in this subagents conversation, I can't do a Cursor conversation and not talk about Wilson's stuff. What is that?

### Grind Mode

**Sam Whitmore** [47:48]
What is what?

**Swyx** [47:48]
Like there, uh... He built a browser, he built an OS-

**Sam Whitmore** [47:51]
Oh

**Swyx** [47:51]
... yes, and he sort of experimented with a lot of different architectures and basically ended up reinventing the software engineer org chart. This is all cool, but like what's your take? What's... Is there any cool behind-the-scene- the-scenes stories about that kind of, that whole adventure?

**Sam Whitmore** [48:07]
Some of his 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. Um- ... and I think there's like some hint of grind mode, uh, accessible in the picker today 'cause you can do, choose grind until done.

And so that was really the result of experiments that Wilson started-

**Swyx** [48:24]
Yeah

**Sam Whitmore** [48:24]
... in this vein where he kind of, I think the Ralph Wiggum loop was like floating around at the time, but it was something he also independently found and he was experimenting with, and that was kind of what led to this product surface.

**Swyx** [48:35]
I- and it's just simple idea of like have criteria for completion and do not stop until you complete.

**Sam Whitmore** [48:41]
There's a bit more complexity as well in, in our for implementation. Um, like there's a specific pl- you have to start out by aligning and there's like a planning stage where it will work with you, and it will kind of not get like start grind execution mode until it's decided that the plan, um, is amenable to both of you, basically.

**Swyx** [49:00]
It's like I refuse to work until you make me happy.

**Jonas Nelle** [49:04]
We found that it's really important where people would like give like very underspecified prompt and then expect it to come back with magic, and if it's gonna go off and work for three minutes-

**Swyx** [49:13]
Yeah

**Jonas Nelle** [49:13]
... that's one thing, but it's gonna go off and work for three days- Probably should spend, like, a few hours up front making sure that you have communicated what you actually want.

**Swyx** [49:21]
Yeah. And just to, like, really drive home the point, we really mean three days. The no, no human-

**Jonas Nelle** [49:26]
Oh, yeah, we've had three-day runs

**Swyx** [49:27]
... no human, uh, intervention whatsoever.

**Sam Whitmore** [49:29]
I don't know what the record is, but it, it's been a long time with the grinds.

**Jonas Nelle** [49:32]
Yeah, yeah. And so the thing that is available in Cursor, the long-running agent, is sort of... 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 sort of different agents collaborating, um, because we started building the browser with one worker node.

At the time, that was just the agent. Uh, 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, large of a scale as the browser done.

**Swyx** [50:05]
Yeah.

**Jonas Nelle** [50:05]
And so this has also become a really big mental model for us with cloud, cloud agents is, uh, you know, there's the classic engineering latency throughput trade-offs, uh, 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 p- 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 any one of those tasks doesn't necessarily need to get done that quickly. And so, um, throughput is this really big thing where if you see the system of, like, 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, many caveats, like no one is using this browser IRL. There's, like, 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, like, 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, like, overloaded, 'cause suddenly it's like effectively we grew... Cursor's growing very quickly anyway, but you grow head count, you know, 10X when people run 10X as many agents.

Um, and so a lot of these systems... Exactly. A lot of these systems will need to adapt.

**Swyx** [51:34]
It also re- reminds me, you know, you- we, we all, the three of us live in the app layer, but if you talk to the researchers who are doing RL infrastructure, it's the same thing. It's like all these parallel rollouts and, like, uh, scheduling them and making sure as much throughput as possible, uh, goes through them.

**Jonas Nelle** [51:49]
Yeah.

**Swyx** [51:49]
It's the same thing.

**Jonas Nelle** [51:50]
We were talking briefly before we started recording. Uh, you were mentioning sort of, uh, 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, you know, 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-

**Swyx** [52:28]
Yeah

**Jonas Nelle** [52:28]
... churn at scale to produce code that is valuable, um, to the economy and, you know.

**Swyx** [52:34]
Yeah. You can cut this if, if it's sensitive, but I was just cur- Do you have estimates of how much your token consumption is?

**Jonas Nelle** [52:39]
Like per developer?

**Swyx** [52:41]
Yeah, or, or yourself. I don't ne- I don't need, like, company average. I just-

**Sam Whitmore** [52:44]
I feel like I've tr- for a while, I wasn't an admin on the usage dashboard, so I, like, wasn't able to actually see, but it was a l-

**Swyx** [52:50]
Mine has gone up.

**Sam Whitmore** [52:51]
Oh, yeah.

**Swyx** [52:52]
But like, you know, I think it's like-

**Sam Whitmore** [52:53]
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 in the near term-

**Swyx** [53:00]
Oh, really?

**Sam Whitmore** [53:00]
... 'cause I feel like... Well, I mean, that's a more broad discussion.

**Swyx** [53:03]
Yeah, yeah. You-

**Sam Whitmore** [53:04]
But-

**Swyx** [53:04]
You went there. I didn't go. I wasn't going there. I was just like, how, how-

**Sam Whitmore** [53:07]
I just feel like there's so-

**Swyx** [53:07]
How much more are you using?

**Sam Whitmore** [53:09]
There's so much stuff to be built, and so I feel like I'm basically just trying to constantly, like... I, I have more ambitions than I did before-

**Swyx** [53:16]
Yes

**Sam Whitmore** [53:17]
... personally.

**Swyx** [53:17]
Yes.

**Sam Whitmore** [53:17]
So can't speak to the broader, the broader thing.

**Swyx** [53:20]
Yeah.

**Sam Whitmore** [53:20]
But for me, it's like I'm busier than ever before. I'm using more tokens, and I am also doing more things.

**Swyx** [53:26]
Yeah.

**Jonas Nelle** [53:27]
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 Jevons paradox-

**Swyx** [53:34]
Yep

**Sam Whitmore** [53:34]
That-

**Jonas Nelle** [53:35]
... uh, where-

**Swyx** [53:36]
You can't do a AI podcast without saying it.

**Jonas Nelle** [53:37]
Exactly. We've done it now. We, we can wrap. We've done... We've said the words. Uh, you know, phase one, tab auto-complete, people paid like 20 bucks a month, and that was great. Phase two, where you were sort of 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 long times in their own VM system, we are already at that point where people will be spending thousands of dollars a month per, per human, and I think potentially tens of thousands and, and beyond, where it's not like we are sort of greedy for, like, capturing more, more money, but what happens is just individuals get that much more leverage.

And so, you know, if one person can do as much as 10 people, like, 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.

**Swyx** [54:22]
One more question on, on just the Cursor in general, and then, uh, you know, open-ended for you guys to plug whatever you wanna plug. How is Cursor hiring these days?

**Sam Whitmore** [54:30]
What do you mean by how?

**Swyx** [54:31]
Uh, so obviously LeetCode is dead.

**Sam Whitmore** [54:34]
Oh, okay.

**Swyx** [54:34]
Um, everyone says work trial. Different people have different levels of adoption of agents. Some people can really adopt, uh, can, can be much more productive. But other people, you just need to give them a little bit of time, and sometimes they've never lived in a token-rich place like Cursor.

**Jonas Nelle** [54:50]
Mm-hmm.

**Swyx** [54:50]
And once you live in a token-rich place, you're, you, you just work differently.

**Jonas Nelle** [54:53]
Yeah.

**Swyx** [54:53]
You need to have done that. And a lot of people... A- anyway, I'm just kinda open-ended, like, how has agentic engineering, agentic coding changed your opinions on hiring? Is there any, like, broad, like, insights?

**Jonas Nelle** [55:05]
Just-

**Swyx** [55:05]
Yeah. Um, 'cause basically I'm asking this for other people, right?

**Jonas Nelle** [55:08]
Yeah, totally. Totally. Uh, to hear Sam's, Sam's opinion. We haven't talked about this, uh, the two of us. I think that we don't see sort of necessarily Being great at the latest thing with AI coding is a prerequisite.

I do think that that's a sign that people are sort of k-keeping up and curious and willing to upskill themselves in, like, 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.

**Swyx** [55:35]
Like it's kind of my job, and I can't.

**Jonas Nelle** [55:37]
Yeah, yeah. Yeah, yeah. Totally. I do think that still, like as, as Sam was saying, sort of 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 kind of sloppy and there'll be bad abstractions.

And so you still do need humans that, like, have built systems before, know good patterns when they see them, and know kind of where to steer things.

**Sam Whitmore** [56:03]
Yeah. I would agree with that. I would say, like, again, Cursor also operates very quickly, and leveraging agentic engineering is probably one reason why that's possible in this current moment. I think in the past it was just, like, people coding quickly, and now there's, like, people who use agents to move faster as well.

So it's kind of like part of our process, we'll always look for like, um... We'll select for kind of that ability to, like, make good decisions quickly and like, you know, move well in this environment. Um, and so I think being able to kind of like figure out how to use agents to help you do that is an important part of it too.

**Swyx** [56:37]
Yeah. Okay. Uh, the forking road, either predictions for the end of the year, if you have any, or plugs.

**Jonas Nelle** [56:44]
Predictions are not going to go well.

**Sam Whitmore** [56:45]
I know. It's hard.

**Jonas Nelle** [56:46]
They're so hard.

**Swyx** [56:47]
Get it, get it wrong. It's okay. Just, uh...

**Jonas Nelle** [56:49]
Well, 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, really quickly.

And so a thing that we have-

**Swyx** [57:05]
You wanna show something or-

**Jonas Nelle** [57:05]
Yeah, I can show something. A thing that we have felt with, uh, local agents is this pain around, um, 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, you know, I just have three tabs open, let's say, but I can very quickly, you know, hop in here. Um, 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, you know, I start the morning, I kick off 10 agents or something.

The first one of them finishes, come in, watch the video. Either is kind of 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.

Um, and within, you know, 90, 120 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 kind of interesting. Um, actually try it out for real in the app. I want to see it, um, 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, you know, check the video here or, or, or do something.

And so you're really parallelizing much more and, uh, you know, follow up here, check in there. It's much more this higher level of abstraction and having the, uh, 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?"

**Swyx** [58:44]
Yeah.

**Jonas Nelle** [58:45]
It's really like solving for that, which we've ourself have struggled with in Cursor and, and, and these local agents to be like, "Where was that diff again? It's lost in some work tree. Never gonna find it."

**Swyx** [58:56]
Oh, it's-

**Jonas Nelle** [58:56]
"Oh, my local thing is rebuilding. Um, or, or just make another one," right? Uh, that, that's what you end up with, and then you wait for five more minutes for it to run. Um, and so this is really like a new way of, of just parallelizing that we found to be really fun, honestly.

**Swyx** [59:10]
Yeah.

**Jonas Nelle** [59:11]
Where you're just hopping in and injecting taste and you're like, "Hmm, that doesn't quite feel right. Oh, actually this is not architected quite right." But you're just focusing on those, like, taste interesting questions.

**Sam Whitmore** [59:21]
And for me, the cloud ecosystem too also enabled this to be like something that is kind of like adding productivity to my dead time, like commuting or kind of like overnight or something like that. The fact that I don't have to leave my computer open.

**Swyx** [59:34]
There's no Cursor mo- there is a Cursor mobile app.

**Sam Whitmore** [59:36]
If there is, I'm not sure it's like the current thing. And we... I use it on my phone all the time, just on the web, so pretty good experience there for checking in-

**Swyx** [59:45]
Yeah

**Sam Whitmore** [59:45]
... um, and unblocking. Um, I think, yeah, I mean, you can see the videos and stuff in the, in the web app, which is awesome. Yeah.

**Swyx** [59:51]
Yeah. Well, I mean, I think, I think this is, uh, uh, one that, that the, the ADD one inherit the earth. Like that- If you're, if you're like, your attention span is cooked, but like, you, you know, you still, you still can manage, like, actually this is good for you.

**Jonas Nelle** [1:00:06]
Yeah, yeah.

**Swyx** [1:00:06]
Uh, but also, uh, I think this is where the coding tools start coming into conflict with the productivity tools, where like the linear-

**Jonas Nelle** [1:00:14]
Mm-hmm

**Swyx** [1:00:14]
... right? The, the Kanban boards. Because what you have there is cool, but you know what, you actually need a Kanban board. Like, which people have like Vibe, Vibe Kanban is, is out there open source. Uh, I'm sure you guys have like talked about it.

But like it will start to conflict because actually the code doesn't matter anymore. It's, it's the process of like the human interacting and checking in-

**Sam Whitmore** [1:00:32]
Mm

**Swyx** [1:00:32]
... and like seeing, like getting the World of Warcraft, uh, sound package to go like work, work or whatever, like job done or... I don't know. It's, it's, it's like an interesting like future productivity thing.

**Sam Whitmore** [1:00:42]
Yeah.

**Swyx** [1:00:43]
I also think like another big theme like last year, and then let's call it the year of code agents. This year, another like code agents spill over to the real world into, into cloud coworker and all the other stuff.

**Jonas Nelle** [1:00:51]
Yeah.

**Swyx** [1:00:51]
I'm sure Cursor is gonna focus on, on software, but like let's call it like open claw is like extremely mind expanding in terms of like, I did not know that could happen.

**Jonas Nelle** [1:01:02]
Yeah.

**Swyx** [1:01:04]
And it's all like based on a coding agent based, right? You know?

**Jonas Nelle** [1:01:07]
Totally. And I think one of the things that like talking to, you know, friends and family that are not, uh, in the software world that's interesting is I do, uh, speaking of predictions, I do think that we are going to start see other industries go through what software development has started going through.

**Swyx** [1:01:24]
Yeah.

**Jonas Nelle** [1:01:24]
I think by virtue of how good models are at writing software and How early adopter the people building the new technology are in 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, um, in terms of, you know, 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.

**Swyx** [1:01:57]
Sammy, uh, parting thoughts? Any thoughts of your own?

**Sam Whitmore** [1:02:00]
Not really.

**Jonas Nelle** [1:02:02]
It's fine.

**Sam Whitmore** [1:02:02]
Feel like we covered so much good ground.

**Jonas Nelle** [1:02:03]
We covered, we covered a lot.

**Sam Whitmore** [1:02:04]
Co- coming up with a prediction, I mean, I just think agents are gonna keep getting better, gonna-

**Jonas Nelle** [1:02:09]
Yeah

**Sam Whitmore** [1:02:09]
... stop doing as much manual coding, probably zero lines of code written in the whole month of December this year by myself. 100% agents is a personal prediction, but-

**Swyx** [1:02:18]
Oh, you're not at zero today?

**Sam Whitmore** [1:02:20]
Um-

**Swyx** [1:02:20]
What, what, in what cases?

**Sam Whitmore** [1:02:22]
I think honestly it's, like, 1%. If I, like, just am, like, get frustrated-

**Swyx** [1:02:26]
Yeah

**Sam Whitmore** [1:02:26]
... and I'm like, "I don't wanna, like, go have it, tell an agent to, like, change this one thing," but-

**Jonas Nelle** [1:02:30]
Prompting sometimes, I feel like working on prompts sometimes-

**Sam Whitmore** [1:02:32]
Yeah

**Jonas Nelle** [1:02:33]
... I still go in and manually edit because it's so, like, bare intent transfer that, like, telling the agent what I want, it's like writing an essay where, like, I don't use agents to write essays yet because the process of writing it is the thinking.

**Sam Whitmore** [1:02:46]
I still can't stand AI-generated writing. So yeah, I ca- also can't have the agent write prompts.

**Swyx** [1:02:50]
Uh, so no DSPy, no JePA, nothing like that here?

**Jonas Nelle** [1:02:54]
Uh, we have some internal, uh, tooling around some of, some of the prompt optimization things, but, uh, there's a fair amount of just, like, what concepts do I need to communicate to the agent, to the model?

**Swyx** [1:03:04]
I al- also noticed, like, you know, another thing I'm also, also looking for is voice. I noticed that you didn't use your voice to code. Uh, even OpenAI, when, when we do a podcast with them, they don't use their voice.

**Jonas Nelle** [1:03:13]
Yeah.

**Swyx** [1:03:14]
And I'm like, well, at some point this gets good. You can stop typing.

**Sam Whitmore** [1:03:18]
We have some people who like that a lot internally, and I think we'll be experimenting in that space too for sure.

**Jonas Nelle** [1:03:23]
Do you use voice a lot?

**Swyx** [1:03:24]
Not a lot, sometimes. I, I mean, that's bound to my caps lock, right? So I can press it.

**Jonas Nelle** [1:03:28]
Yeah.

**Swyx** [1:03:28]
I just-

**Jonas Nelle** [1:03:28]
And when you use it, do you want it to talk back-

**Swyx** [1:03:31]
No

**Jonas Nelle** [1:03:31]
... or you just want-

**Swyx** [1:03:32]
No

**Jonas Nelle** [1:03:32]
... just dump in context?

**Swyx** [1:03:33]
Do my bidding.

**Jonas Nelle** [1:03:34]
Yeah, yeah.

**Swyx** [1:03:34]
But, like, m- the brain dump is good.

**Jonas Nelle** [1:03:36]
Yeah.

**Swyx** [1:03:36]
Because you can interrupt yourself, you can go on a tangent, whatever. It just captures everything-

**Jonas Nelle** [1:03:39]
Yeah

**Swyx** [1:03:39]
... and slop it into LLM, it's fine.

**Jonas Nelle** [1:03:41]
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, and one of the funny things that we learned was people would use their Siri voice where they would, like, start talking in, like, short, stilted sentences and enunciate really clearly because they were used to...

they last used AI, like, two years ago, where you had to, like-

**Swyx** [1:04:04]
Apple has damaged, like, an entire generation of, like, people's expectations of AI.

**Jonas Nelle** [1:04:07]
Exactly, and we had to be like, "No, like, y- I mean, you're very native, so you, you do this, but just, like, dump everything in. You can say um, you can repeat yourself, you can, like, contradict yourself. The models are smart enough to figure it out."

**Swyx** [1:04:19]
Yeah. But it's still very bad. Like, so voice coding was always, I consider it, like, the hardest part because you have to say, like, technical things that is spelt, like spelling matters-

**Jonas Nelle** [1:04:27]
Mm.

**Swyx** [1:04:28]
You know, capitalization matters and, like, it's all not in, not in voice, so we'll see. Uh, so far it's been more sort of emotional companionship, that kind of stuff-

**Jonas Nelle** [1:04:36]
Yeah

**Swyx** [1:04:36]
... but at some point it's gonna hit voice, uh-

**Jonas Nelle** [1:04:37]
Sure

**Swyx** [1:04:37]
... coding.

### Predictions

**Jonas Nelle** [1:04:38]
Yeah. Um, I have a prediction for you.

**Swyx** [1:04:40]
Yeah.

**Jonas Nelle** [1:04:40]
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 mult- like more than 2x the volume of local agents.

**Swyx** [1:05:07]
Okay. Y- you're leaving me an opening. What's not good today?

**Jonas Nelle** [1:05:10]
Yeah. There's a bunch of hard things. So one of them is just getting those sandboxes to be really, 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-

**Swyx** [1:05:26]
Perfect

**Jonas Nelle** [1:05:26]
... and the agent just goes off and installs things.

**Swyx** [1:05:28]
Yes. I think out of the whole thing, that was my favorite.

**Sam Whitmore** [1:05:30]
Yeah.

**Jonas Nelle** [1:05:30]
Yeah, we worked a lot on that. Sam and I in particular-

**Sam Whitmore** [1:05:33]
Yeah

**Jonas Nelle** [1:05:33]
... um, spent a lot of late nights just making that good, but, um, there's still a lot to do there, right? Like, set up one, two, two things maybe-

**Swyx** [1:05:41]
It's still too slow

**Jonas Nelle** [1:05:42]
... off the bat. It's too slow. Um-

**Swyx** [1:05:44]
My fault.

**Jonas Nelle** [1:05:45]
Working on it. Uh, 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, um, having these agents run in the cloud and, and be more autonomous. We've really started to see the lack of memory and, uh, Sam, you know, as someone who's thought a lot about this, uh, once you start getting the model kind of doing, operating the code base, there's more particularities that are not, like, 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 code base, and even if it's great at NPM run watch or whatever the, like, you know, default things are, there's always quirks.

Like, everyone has quirks, and getting the model good at those things will require more work, and we're working on that, but we think that that will be one of the big unlocks is having them be onboarded, not only in terms of their environment, but also in terms of their understanding of design trade-offs, how the code base works, how to be a good developer in any one code base.

**Swyx** [1:06:49]
It's law of Cursor rules, it's gonna be something else. Is it gonna be a file? Is it-

**Sam Whitmore** [1:06:54]
Um-

**Swyx** [1:06:54]
We just call another markdown file a different name and...

**Sam Whitmore** [1:06:57]
I, I don't know. I mean, one thing that we learned at, we being Cursor the company this year, um, there, there's a really great blog post, um, that the, uh, Juday and other, other people on the agent quality team put out about, um, dynamic file context.

**Swyx** [1:07:10]
Is that, is that your team or is that a different team?

**Sam Whitmore** [1:07:12]
Different team, yeah. Um, and they were working on basically, um, doing a lot-

**Swyx** [1:07:17]
Everything file system

**Sam Whitmore** [1:07:17]
... everything is file system. And so a lot of my thinking personally on memory this past year has changed to be more aligned with that, where it's, like, giving the agent pointers to things, annotations to things. The second thing I think, um, that I've kind of started to think differently about memory is memory is a subset of agent self-auditability and self-awareness.

So basically, like the agent might wanna propose annotations or links or memory like files to itself when it finds that there's like some gap in its functionality-

**Jonas Nelle** [1:07:46]
Mm.

**Sam Whitmore** [1:07:46]
-in its own harness-

**Jonas Nelle** [1:07:47]
Mm.

**Sam Whitmore** [1:07:48]
-that might need to be filled by like some piece of information on a semi-permanent basis. But there's a whole bunch of other things that are a side effect of self-auditability that are really interesting, like potentially finding like conflicting instructions or like skills and rules that like might like be like, "Eh, these are kind of like bugging each other," and also things like fixing like DevX problems that it ru-runs into.

I think that basically like the dynamic file system stuff is probably like, um, very promising for memory, and there's also this notion of needing to have the agent be a little bit more self-aware in terms of like being able to identify gaps in its own functionality and decide how to fill them.

**Jonas Nelle** [1:08:25]
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 kind of self-aware about its own harness and its environment. And then-

**Swyx** [1:08:42]
And do you think this is not inherent in the model? You have to do-

**Jonas Nelle** [1:08:44]
Well, it's specifics, right? Like if it's running in Cursor versus some other sandbox-

**Swyx** [1:08:48]
Is it-

**Jonas Nelle** [1:08:48]
-that's a bit different. Um, and then the other part of it that starts to get really interesting is when the model starts editing its own system prompt.

**Sam Whitmore** [1:08:57]
Yeah.

**Jonas Nelle** [1:08:57]
What does that even mean? How do you do that safely? And in a way-

**Swyx** [1:09:01]
Can the agent do that? This is just research, right? This isn't... This is like-

**Jonas Nelle** [1:09:03]
Well, I think it will do that, yeah. It will manage its own context.

**Sam Whitmore** [1:09:06]
Yeah.

**Jonas Nelle** [1:09:07]
And so system prompt is part of the context, and you can argue about-

**Sam Whitmore** [1:09:10]
Yeah, like other things that it might decide to turn off or on, depending.

**Jonas Nelle** [1:09:13]
Mm-hmm.

**Sam Whitmore** [1:09:13]
And all this, I mean, self-awareness to us in this context is kind of like, um, not like the model itself having a notion of consciousness, but more like knowing like what system it's operating in and the, the constraints of that system, and potentially being able to have agency in like optimizing itself to operate best in the, in that system.

Um, this was like one of the first things I learned at Dot when we launched, was that, um, I like... We had like made the model or made the agent or whatever we would call it at that time, it was far less agentic.

We made the product work very well at a certain number of things, but it didn't have complete self-awareness of like its own boundaries.

**Swyx** [1:09:50]
Mm.

**Sam Whitmore** [1:09:51]
So people would be like, "Hey, can you do this thing?" And like the thing was there and could be done, and the, and the, and the product would be like, "Oh, no." And I'd be like, "But you can."

And so like, basically, like that was one of the earliest things I found-

**Swyx** [1:10:03]
Just believe in yourself.

**Sam Whitmore** [1:10:04]
I know. As a product developer, like it needs to both be able to do the thing, and it needs to have complete knowledge of its ability to do the thing.

**Swyx** [1:10:11]
Mm-hmm.

**Sam Whitmore** [1:10:11]
Those are not always obviously the same like part of the prompt at all.

**Swyx** [1:10:15]
Yeah.

**Sam Whitmore** [1:10:16]
It's something that I think has continued to be a theme in the ecosystem, um, that users will often attribute increased intelligence to a system that is more highly self-aware, um, and is more ab-able to like manipulate itself to do well in a system, if that makes sense.

**Swyx** [1:10:31]
Yeah.

**Sam Whitmore** [1:10:31]
Mm.

**Swyx** [1:10:32]
This is more abstract than I ever thought we'd get- -in this Cursor discussion.

**Sam Whitmore** [1:10:36]
Yeah.

**Swyx** [1:10:36]
Cool that this is the kind of conversation that you have and like it-

**Sam Whitmore** [1:10:38]
And we talk about this stuff all the time

**Swyx** [1:10:39]
... leads to improving-

**Sam Whitmore** [1:10:40]
Yeah

**Swyx** [1:10:40]
... agents in, in general.

**Jonas Nelle** [1:10:42]
Yeah, I think to your point, right, about the, the agent layer and thinking a lot about models and the harness and the product and the affordances, like that-

**Swyx** [1:10:50]
Yeah

**Jonas Nelle** [1:10:50]
... falls from the-

**Swyx** [1:10:51]
No, I mean, you guys are like my sort of leading example what an agent lab looks like and like can be successful and like, uh, I think people are always hungry for insights into how you guys operate, so thank you for taking the time to share.

**Jonas Nelle** [1:11:03]
Yeah.

**Sam Whitmore** [1:11:04]
Thanks for coming.

**Swyx** [1:11:04]
Yeah. Thank you.

---

This library is powered by PodHood (https://podhood.com), the podcast website platform.
