SpaceXAI Splits Grok Bot From Cursor, Gives Bots Cloud Computers
Lenny's Podcast
Giving each persistent AI bot its own isolated cloud computer while stripping away developer interfaces and exposed reasoning bridges the gap from 90% chatbot babysitting to 100% autonomous task completion.
SpaceXAI incubated and launched Grok Bot from first line of code to internal beta in four weeks, rolling out to the public three weeks later following viral internal adoption across SpaceX. (4:12)
The team chose to build Grok Bot from scratch rather than retrofitting Cursor, pairing a 100% cloud-first architecture with dedicated virtual computers per bot to interact directly with UI pixels. (8:40)
Manual onboarding of 200–300 initial users revealed an emergent pattern: users independently spun up 5–10 domain-specific bots and appointed one as an orchestrating 'Chief of Staff.' (11:20)
Grok Bot adopted a 'colleague-pilled' product philosophy that hides raw chain-of-thought traces and manual tool controls, focusing on delivering 100% finished tasks rather than requiring constant supervision. (39:21)
Detailed notes
## Background
Published on YouTube by Lenny's Podcast on September 8, 2026, this episode features an in-depth interview with Roman Ugarte of SpaceXAI (formerly of Cursor). According to the show notes, the conversation explores how a small, isolated team built the knowledge-work agent Grok Bot from scratch in a month, their manual onboarding of early users, their "colleague-pilled" product philosophy, and lessons on competitive moats from scaling Cursor.
## TL;DR
Roman Ugarte explains how SpaceXAI built Grok Bot from the first line of code to an internal beta in four weeks, deliberately creating a standalone product rather than bolting features onto Cursor. By giving each persistent AI bot its own cloud-based virtual computer and aggressively hiding technical UI clutter—like raw tool calls and reasoning traces—the team unlocked reliable, autonomous task completion for non-technical knowledge workers. Through manual onboarding of nearly 300 users, they observed organic workflows emerge, such as promoting a primary bot to a "Chief of Staff" that manages other specialized bots. Beyond product architecture, Ugarte shares how Cursor and SpaceXAI maintain "scramble energy" at scale, why competitive moats are discovered rather than planned, and why AI products must constantly reinvent themselves and delete old scaffolding as foundation models improve.
## Atmosphere & style
The conversation carries an energized, builder-focused tone, driven by host Lenny Rachitsky's genuine enthusiasm as an active power user of the product and Ugarte's candid, pragmatic reflections. Rather than speaking in abstract AI hype, the dialogue feels grounded in tactical product intuition—moving briskly through war stories of one-month "cave sprints," painful onboarding calls, and ruthless feature cutting. It feels like sitting in on a high-velocity post-mortem between two product-obsessed insiders unpacking what it actually takes to make bleeding-edge technology feel effortless.
## Bulletin
- [04:12](https://www.youtube.com/watch?v=maSdsTLaMuU&t=252s) SpaceXAI incubated and launched Grok Bot from first line of code to internal beta in four weeks, rolling out to the public three weeks later following viral internal adoption across SpaceX.
- [08:40](https://www.youtube.com/watch?v=maSdsTLaMuU&t=520s) The team chose to build Grok Bot from scratch rather than retrofitting Cursor, pairing a 100% cloud-first architecture with dedicated virtual computers per bot to interact directly with UI pixels.
- [11:20](https://www.youtube.com/watch?v=maSdsTLaMuU&t=680s) Manual onboarding of 200–300 initial users revealed an emergent pattern: users independently spun up 5–10 domain-specific bots and appointed one as an orchestrating 'Chief of Staff.'
- [39:21](https://www.youtube.com/watch?v=maSdsTLaMuU&t=2361s) Grok Bot adopted a 'colleague-pilled' product philosophy that hides raw chain-of-thought traces and manual tool controls, focusing on delivering 100% finished tasks rather than requiring constant supervision.
## Key takeaways
- [04:12](https://www.youtube.com/watch?v=maSdsTLaMuU&t=252s) Building from scratch in physical isolation allowed a small team to deliver a working end-to-end knowledge work prototype in one month without roadmaps or org-chart clutter.
- [09:29](https://www.youtube.com/watch?v=maSdsTLaMuU&t=569s) Launching as a distinct product avoided alienating non-technical users with developer-oriented interfaces and legacy coding brand associations.
- [11:20](https://www.youtube.com/watch?v=maSdsTLaMuU&t=680s) Personally conducting 200 to 300 onboarding calls created urgent daily feedback loops to resolve setup bugs and exposed universal user orchestration workflows.
- [14:30](https://www.youtube.com/watch?v=maSdsTLaMuU&t=870s) Hiding internal tool calls, chain-of-thought streams, and virtual desktop clicks in favor of a simple typing indicator created a calmer, more human user experience.
- [16:17](https://www.youtube.com/watch?v=maSdsTLaMuU&t=977s) Testing with users outside the tech industry, such as a local coffee shop owner, uncovered critical integration issues with tools like Shopify that internal dogfooding failed to catch.
- [28:42](https://www.youtube.com/watch?v=maSdsTLaMuU&t=1722s) The team aggressively unshipped UI elements, drop-downs, and manual triggers under the mantra 'kill as many pixels as we can,' moving 99% of automation setup to natural language.
- [30:02](https://www.youtube.com/watch?v=maSdsTLaMuU&t=1802s) Provisioning each bot with its own isolated cloud-based virtual computer solved credential sharing and local machine runtime issues while enabling navigation of non-API software.
- [39:21](https://www.youtube.com/watch?v=maSdsTLaMuU&t=2361s) The 'colleague-pilled' philosophy resolves product debates by modeling bot interactions on human teammate behaviors rather than SaaS application patterns.
- [42:19](https://www.youtube.com/watch?v=maSdsTLaMuU&t=2539s) A single conversational product can bridge professional and personal domains because delegating work tasks and personal chores relies on identical underlying agent mechanics.
- [01:00:44](https://www.youtube.com/watch?v=maSdsTLaMuU&t=3644s) An AI reaching 90% task completion still imposes the cognitive load of supervision; reaching 100% completion unlocks the 'no-look pass' where users can walk away entirely.
- [01:03:30](https://www.youtube.com/watch?v=maSdsTLaMuU&t=3810s) SpaceXAI sustains speed at scale through 'scramble energy,' defining a startup by high agency and non-permission-seeking culture rather than headcount.
- [01:11:45](https://www.youtube.com/watch?v=maSdsTLaMuU&t=4305s) Moats in AI are discovered through continuous adaptation: building temporary scaffolding ahead of frontier models and deleting it once base models advance.
- [01:15:11](https://www.youtube.com/watch?v=maSdsTLaMuU&t=4511s) The fastest path to value for new users is connecting communication channels like Slack and email and asking the bot to propose five concrete tasks it can autonomously handle.
## Detailed walkthrough
### [00:00](https://www.youtube.com/watch?v=maSdsTLaMuU&t=0s) The Vision and the Buzz Around Grok Bot
The ambition behind Grok Bot centers on a radical shift in how people interact with artificial intelligence: moving past conventional chat prompts into a world where users manage a dedicated staff of digital peers. As Roman Ugarte summarizes, "The ultimate vision of Grok Bot is incredibly simple. You should have a team of AI bots that help you with your job and help you with your life." In contrast to existing conversational interfaces that require constant hand-holding, Grok Bot is designed around the premise of "a colleague with a computer," an abstraction that dramatically expands the scope and complexity of tasks a user feels comfortable handing off.
Lenny highlights that Grok Bot has quickly become the hottest AI product in the ecosystem—an exceptionally high bar in an intensely competitive landscape. For Roman, the breakthrough came from solving non-coding tasks with true autonomy, turning an insight from one of his widely circulated tweets into reality: "an AI that does 100% of the job feels categorically different from one that gets you 90% there." Achieving that complete delegation required two fundamental, non-obvious architecture and product decisions during the first days of development.
Roman arrived at Grok Bot after joining Cursor as employee number 15, where he spent two years leading growth as the organization scaled to over 1,000 people before its acquisition by SpaceX. Stepping in to lead product for Grok Bot, Roman guided the effort from its earliest internal prototype to its breakout public reception.
---
[02:09](https://www.youtube.com/watch?v=maSdsTLaMuU&t=129s) Hands-On Onboarding and Overcoming Skepticism
Reflecting on the whirlwind weeks following Grok Bot's launch, Lenny describes becoming completely hooked on the software, running roughly 15 bots simultaneously and opening the product dozens of times a day. He recounts attending a recent Grok Bot meetup packed with hundreds of enthusiasts in a standing-room-only crowd swapping advanced workflows. For Lenny personally, the software swiftly cannibalized the time he used to spend in tools like Cowork and Codex.
```mermaid
flowchart LR
accTitle: Grok Bot Incubation Pipeline
accDescr: Progression from isolated 4-week prototype sprint to internal company rollout and public launch.
subgraph Phase1["Incubation (4 Weeks)"]
direction TB
A["Blank Slate & Tiny Team"] --> B["Physical Isolation & Private Slacks"]
B --> C["Rapid Micro-Decisions"]
end
subgraph Phase2["Internal Testing"]
direction TB
D["Company All-Hands Demo"] --> E["Spontaneous Viral Adoption across SpaceX"]
end
subgraph Phase3["Public Release"]
direction TB
F["Infrastructure Hardening"] --> G["GA Launch (3 Weeks Later)"]
end
Phase1 --> Phase2
Phase2 --> Phase3
```
Roman recalls that Lenny's initial enthusiasm was far from guaranteed when Roman manually onboarded him a month earlier. During that white-glove session, Lenny had approached the tool with healthy skepticism until Roman asked him to test a real-world task live.
- Lenny prompted the bot simply: "come up with a tweet to promote my last episode."
- Without extra guidance or context, Grok Bot independently discovered what his most recent podcast episode was, analyzed the source material, and generated a highly polished promotional tweet.
- Seeing the agent complete the entire loop autonomously was the "wow" moment that instantly converted Lenny into an active user.
---
[04:12](https://www.youtube.com/watch?v=maSdsTLaMuU&t=252s) The Origin Story: A One-Month Cave Sprint
The concept for Grok Bot grew out of deep intuition gained while building developer agents at Cursor. While the team had mastered creating developer-focused software, they recognized an untapped opportunity to construct an equally capable agentic system tailored for broad knowledge work. Rather than orchestrating a sprawling corporate initiative, leadership formed a tiny, close-knit team consisting of just a handful of people and sent them "into a cave for about a month" with a single directive: build an amazing knowledge-work product that brings agents to the rest of the enterprise.
To move with maximum velocity, the incubation unit operated in complete physical and operational isolation from the broader company:
- The team occupied a separate, cordoned-off section of the office.
- Collaboration occurred in private Slack channels away from broader organizational noise.
- They avoided multi-quarter roadmaps and endless stakeholder reviews, enabling them to make dozens of high-stakes micro-decisions every day.
- Exactly one month elapsed between writing the first line of code and delivering a functioning, end-to-end prototype.
---
[06:05](https://www.youtube.com/watch?v=maSdsTLaMuU&t=365s) Internal All-Hands Rollout and Viral Company Adoption
Once the prototype was functional, the team faced its first true pressure test: rolling it out across all of SpaceX and SpaceXAI. At an internal all-hands meeting, the team presented what they had built and invited colleagues to test it. While the creators were already daily drivers of the software, Roman knew that builders inherently love their own tools because they understand all the underlying mechanics and edge cases. The real question was whether ordinary team members would willingly abandon their existing tools.
The response was immediate and overwhelming. Within the first week, an outpouring of organic adoption swept across unexpected departments. Knowledge workers who had previously relied on ChatGPT or standard chat interfaces shifted their entire day-to-day workflow over to Grok Bot, treating it as their primary operational workspace. Witnessing this enthusiastic internal conversion gave the team the conviction to immediately pivot into hardening the infrastructure for scale, leading directly to their general availability (GA) public launch just three weeks later.
---
[08:40](https://www.youtube.com/watch?v=maSdsTLaMuU&t=520s) The Fork in the Road: Fresh Product vs. Feature in Cursor
As competitor labs like Anthropic and OpenAI expanded their coding foundations into broader knowledge products—developing tools like Cowork or repurposing Codex—the Grok Bot team faced a pivotal fork in the road: should knowledge-work capabilities simply be added as a new tab or feature set inside Cursor, or did the concept demand an entirely fresh product built from scratch?
Lenny presses Roman on how contentious that fork really was. Roman confirms that building Grok Bot completely apart from Cursor was far from an obvious or easy call at the time. The decision sparked intense internal debates, but in retrospect, it became one of the foundational choices that defined the tool's distinct identity and eventual breakthrough success.
[09:29](https://www.youtube.com/watch?v=maSdsTLaMuU&t=569s) Starting from Scratch vs. "Shipping Your Org Chart"
Roman explains that building Grok Bot as a brand-new product—where the team controlled every pixel of the experience and maintained a single, consistent vision for the future of knowledge work—contributed heavily to its success. Internally, there had been plenty of debate about whether to just build it into Cursor or one of their other coding products. People already used those coding agents for non-coding tasks all the time, and while the agents were excellent at them, non-technical users constantly ran into small paper cuts, found the interface intimidating, or bumped up against the developer-centric brand association.
Looking at the broader market, the team noticed competitors taking the single-surface route: bolting on new tabs for every new form factor. To Roman, that approach feels cluttered, and users can immediately sense the lack of a unified vision. Instead of one coherent philosophy of how work should happen, users are handed "three different visions that all kind of share a screen and you can hop between, but it is kind of a shipping your org chart style thing that I think users are reacting negatively to." By starting completely from scratch, they could prioritize an "amazingly simple and amazingly powerful experience" first, while leaving the door open to later bring users over from other surfaces into this more bot-native environment.
Lenny points out what a valuable takeaway this is, contrasting it with OpenAI's Codex, which went the exact opposite direction by consolidating everything into a single product. He notes that there are many ways to make a product work, and the initial path you choose shapes where you end up—even if you sometimes look back later and question the decision.
[11:20](https://www.youtube.com/watch?v=maSdsTLaMuU&t=680s) Manually Onboarding 300 Users and the "Chief of Staff" Pattern
Another unusual decision the small team made was manually onboarding between 200 and 300 early users—including Lenny himself—over an intense two-week period. Roman laughs that he is glad Lenny got a smooth onboarding, because the first few were "pretty painful" and "kind of rough." However, forcing the core team to sit in the room on a 20-minute call while a user's virtual computer failed to spin up, or watching someone get completely lost in the setup flow, created immediate urgency. Walking out of those calls, the team's reaction was always: "that can never happen again, we need to solve this tomorrow because tomorrow I'm onboarding this person and it needs to go better."
Beyond catching bugs, manual onboarding helped the team test whether internal SpaceX usage habits were just company groupthink or genuinely universal patterns. Because SpaceX employees were constantly sharing Grok Bot tips and tricks in Slack, distinct workflows had emerged internally, and the team was careful not to "lead the witness" or bias outside users during onboarding.
```mermaid
flowchart TD
accTitle: Evolution of Grok Bot Usage Patterns
subgraph Week1["Weeks 1–2: Multi-Bot Pattern"]
U1["User"] --> B1["Bot 1 (Domain A)"]
U1 --> B2["Bot 2 (Domain B)"]
U1 --> B3["Bots 3–10 (Other Lanes)"]
end
subgraph Week2["End of Week 2: Chief of Staff Pattern"]
U2["User"] --> CoS["Chief of Staff Bot (Promoted PA)"]
CoS -->|"Fans out tasks & manages"| S1["Specialist Bot 1"]
CoS -->|"Fans out tasks & manages"| S2["Specialist Bot 2"]
CoS -->|"Fans out tasks & manages"| S3["Specialist Bot 3"]
end
```
Roman shares a prime example of an organic workflow that emerged internally and was validated externally:
- **Weeks 1–2 (Multi-bot lanes):** Initially, employees typically spun up five to ten separate bots, assigning each a different scope or domain as shorthand for different lanes of work.
- **End of Week 2 (The "Chief of Staff" promotion):** Employees began taking their standout performer—usually their primary personal assistant bot—and promoting it to "Chief of Staff." From then on, the user mostly talked only to the Chief of Staff, which would fan out tasks and manage the rest of the bot team.
- **Humorous interactions:** People shared funny screenshots in internal Slack of themselves formally telling a bot it was being promoted, and the bot replying to ask if it was getting a raise or a higher token budget.
- **Validating without forcing:** Rather than instructing early access users to build a Chief of Staff bot, the team watched to see if external users would arrive at the setup organically. When many of them did, the team felt confident adopting a slightly more opinionated take in the product—gently encouraging the pattern without making it a rigid, "one-way door."
[14:30](https://www.youtube.com/watch?v=maSdsTLaMuU&t=870s) Hiding Internal Mechanics and Tool Calls
During those early onboarding sessions, the team also paid close attention to how much under-the-hood activity users actually wanted to see. One of the most striking differences between Grok Bot and competing AI products is that Grok Bot hides almost all of its internal mechanics.
Roman explains the philosophy behind this: as models grow smarter, you should treat them like human teammates. Just as you wouldn't ask a human colleague for second-by-second updates on every button they press or website they visit, demanding that level of granularity from a bot is overwhelming and creates more harm than good. Instead, Grok Bot went completely in the other direction:
- **Slack-like presence:** When you message a bot with a task, it simply starts working. All you see is a typing indicator and a little green active circle—much like Slack—showing that the bot is online, doing work, and will get back to you with progressive updates as it sees fit.
- **No raw plumbing:** Users never see raw tool calls, chain-of-thought text streams, or every click the bot makes on its virtual computer.
- **User feedback on visibility:** While some early users requested high-level visibility—saying, "I would love to see my bot's to-do list" or a rough view of how it is prioritizing tasks—nobody missed the endless stream of raw text and chain-of-thought sequences. This confirmed for the team that hiding the mechanics was the right call.
[16:17](https://www.youtube.com/watch?v=maSdsTLaMuU&t=977s) Escaping the Silicon Valley Bubble: The Coffee Shop Owner
Lenny notes that doing 200 to 300 live onboarding calls with a tiny team is a massive time commitment that many might view as a distraction from building, and asks if that specific volume is necessary to figure out what a product needs. Roman clarifies that the magic wasn't just the volume, but the deliberate diversity of the early access group.
While they certainly onboarded influential tech tastemakers and AI power users like Lenny, they intentionally sought out unconventional profiles completely outside their normal orbit to check their blind spots. Roman highlights two key reasons for this: first, Grok Bot was meant to be a general product that would likely prove *most* powerful for non-developers; second, the team recognized that they lived in a "Silicon Valley AI bubble"—which is great for pushing the frontier, but dangerous when building for mainstream business customers.
To break out of that bubble, they onboarded users like a local coffee shop owner—a friend of a friend of someone at the company—who had gotten excited after seeing a core team member demo the TestFlight app. That coffee shop owner became both an incredible power user and a goldmine of product feedback:
- The team maintained a lively message thread with the owner, who surfaced numerous bugs and feature requests rooted in the day-to-day reality of running a small business.
- Whenever the Shopify integration was being flaky, or the bot wasn't writing product copy in the right style, the owner provided rich, practical feedback that the team never would have uncovered simply by dogfooding the product internally at SpaceX.
[18:41](https://www.youtube.com/watch?v=maSdsTLaMuU&t=1121s) The Rapid Timeline and Aggressively Unshipping Features
The timeline behind Grok Bot's development was remarkably fast. The team moved from writing the first line of code to an internal beta in just four weeks, followed by roughly three weeks of intense iteration before the public launch. At the time of recording, the product had only been live publicly for three weeks, leaving Lenny marveling at how a product that felt like it had fundamentally shifted the landscape had existed for less than two months in total.
When asked what changed most during the three-week internal beta, Roman explains that the team spent much of that window aggressively "unshipping" features. Two weeks before launch, the surface was cluttered with experimental ideas and pseudo-developer visibility tooling. The team had initially exposed the model’s internal reasoning traces, specific stored memories, and underlying mechanics directly inside the main UI so the engineers wouldn't have to open a separate observability pane to debug issues. However, they realized they needed to ruthlessly cut anything the end user didn't need to actively think about.
Alongside cutting interface jank, the second major focus was getting the product to "just work." Users do not want drop-down menus, complex toggles, or endless bells and whistles; they want to describe a meaningful task, send the agent off, and receive finished work or a draft they can steer in the next cycle. Delivering on that promise was not about traditional feature roadmaps, but about behind-the-scenes "hill climbing" on five critical backend engineering challenges that silently make or break an agent:
```mermaid
flowchart TD
accTitle: Ruthless Simplification vs Backend Reliability
accDescr: Contrasting UI simplification with behind-the-scenes backend hill climbing.
subgraph Backend ["Backend Reliability (Hill Climbing)"]
Task --> AgentWork["Agent executes autonomously"]
AgentWork --> Obstacles["Overcoming real-world blockers:<br/>• Precise mouse clicking<br/>• Web logins & sessions<br/>• Navigating non-API tools"]
Obstacles --> Result["Returns completed work or steering checkpoint"]
end
```
- **Aggressive trimming:** Abstracting away raw model telemetry and memory displays to keep the user focused purely on work delegation.
- **Backend hill climbing:** Systematically identifying real-world sticking points—such as clicking buttons accurately or authenticating into external tools—and measuring week-over-week task completion reliability across real user workloads.
---
[21:48](https://www.youtube.com/watch?v=maSdsTLaMuU&t=1308s) Making It "Just Work": Go-to-Market and Recruiting Use Cases
One of the most rabid early user bases inside the company was the sales and go-to-market organization. Sales workflows rely heavily on tools lacking clean APIs or Model Context Protocol (MCP) support. Other AI tools routinely stalled out on these workflows, but Grok Bot felt like handing an assistant a fresh laptop and letting them run. In the early beta, small UI friction points—such as the agent lacking the pixel-level visual fidelity or fine-grained mouse control needed to click a specific target in a Salesforce dashboard—would completely block a workflow. When the infrastructure team resolved these browser and screen-interaction bottlenecks, the impact was immediate. Instead of watching an abstract telemetry chart tick up, the team received immediate outpourings of gratitude from sales reps whose week-long blocked tasks suddenly succeeded overnight.
Another team that stress-tested Grok Bot was the talent acquisition organization led by Adam Ward. Internal hiring philosophy dictates that someone does not need to be actively looking for a job to be recruited; the goal is to pinpoint the best person in the world for a specific problem and pursue them relentlessly. Grok Bot transformed talent sourcing from manual resume screening into an always-on, autonomous research engine:
```mermaid
flowchart LR
accTitle: Grok Bot Autonomous Recruiting Pipeline
accDescr: Pipeline of how Grok Bot monitors academic conference sites and connects candidates to internal employees.
A["Scrape conference websites<br/>(Download unindexed PDFs)"] --> B["Extract untracked<br/>co-author names"]
B --> C["Populate research spreadsheet"]
C --> D["Cross-reference SpaceX network"]
D --> E["Ping team member on Slack<br/>for warm introduction"]
```
Instead of browsing LinkedIn, Grok Bot was assigned high-friction sourcing tasks: navigating academic conference websites every morning to download research paper PDFs not yet indexed on Google Scholar, logging newly discovered co-authors into a spreadsheet, cross-referencing candidates against existing employees across SpaceX, and pinging colleagues on Slack to request warm introductions. Automating this tedious research freed recruiters to focus purely on high-touch engagement and closing top candidates.
---
[26:50](https://www.youtube.com/watch?v=maSdsTLaMuU&t=1610s) The "Grok Bot Can Now" Product Philosophy
Lenny highlights the discipline required to unship features, noting that AI systems are naturally biased toward generating more code and ideas rather than telling builders what to cut—making human editorial restraint an essential skill. Roman expands on this with an internal design heuristic they use whenever evaluating new features: drafting the hypothetical launch tweet. If the team cannot write a genuinely compelling public update about a feature that users will tangibly feel, they drop it.
More importantly, the team enforces a linguistic shift that keeps the product grounded in capabilities rather than UI complexity:
| Legacy Software Framing | Grok Bot Framing | Product Focus |
|:--- |:--- |:--- |
| **"Grok Bot now has..."** | **"Grok Bot can now..."** | Replaces buttons, drop-downs, and toggles with expanded autonomous capabilities and real-world tools. |
Roman explains that framing updates as "Grok Bot now has" inevitably results in traditional software bloat—adding another button, an extra drop-down menu, or an integration toggle. In contrast, framing improvements around "Grok Bot can now" treats the agent like a human colleague acquiring new skills. The metric of progress is not how much software is added to the interface, but whether the agent can independently accomplish tasks that were previously impossible.
[28:42](https://www.youtube.com/watch?v=maSdsTLaMuU&t=1722s) Unshipping Pixels: Defining Automations in Natural Language
What users truly care about is having bots that reliably do impactful work behind the scenes in a way that "just works," and equipping those bots with the capabilities to pull that off. In the context of unshipping features, Roman explains that the team realized many things in Grok Bot are actually capabilities that simply don't need UI elements. Their mantra became: "let's kill as many pixels as we can." Instead of forcing users to directly control settings through an interface, the bot can just manipulate those things behind the scenes on the user's behalf.
A prime example of this philosophy is how automations and routines are set up. In competing products—including tools in the coding realm—creating an automation typically requires going into a sidebar, pressing a plus button, selecting a trigger event, choosing the subsequent action, and maybe describing it in natural language. Because that workflow is so clunky, people rarely set up automations. Grok Bot took the opposite approach: users should just define automations in natural language and never have to see an automation-creation interface at all. You simply tell your bot, "remind me that at 8 a.m. every day, please," and it just does it. Today, 99% of automations on the platform are built this way, and Roman notes there are many more places where they plan to apply this same invisible-UI approach.
```mermaid
flowchart TD
accTitle: Traditional UI vs. Grok Bot Natural Language Automations
accDescr: Compares the multi-step sidebar UI flow of competitors with Grok Bot's single-step natural language approach.
subgraph Comp["Competitor Approach (High Friction)"]
C1["Open sidebar & press '+'"] --> C2["Select trigger event"]
C2 --> C3["Select follow-up action"]
C3 --> C4["Describe in text (Low adoption)"]
end
subgraph Grok["Grok Bot Approach (99% of Automations)"]
G1["Tell bot: 'Remind me at 8 a.m. every day'"] --> G2["Bot configures routine behind the scenes"]
end
```
[30:02](https://www.youtube.com/watch?v=maSdsTLaMuU&t=1802s) Cloud-First Architecture and Giving Every Bot Its Own Computer
Lenny brings up the reactions he got on X when he tweeted about how much he loved Grok Bot at launch: many replies asked, "Wait, can't you just do all this with Codex and Co-work?" Technically, Lenny notes, everything you can do with Grok Bot can be done with other foundational models and coding assistants. So he asks Roman the big question: what did the Grok Bot team do so differently that made the product break out? Roman attributes their success to two early decisions that did not feel obvious at the time, but in hindsight proved critical.
The first decision was committing to a 100% cloud-first architecture so users never have to think about local versus cloud execution. Right now, Roman says, there is "so much jank" when users try to conceptualize where an agent's runtime lives—wondering where workflows are running, whether their laptop has to stay awake, or whether kicking something off from their phone requires tethering to their computer back home. Competing products haven't made a clean break to the cloud, resulting in daily "paper cuts" for users. By putting Grok Bot entirely in the cloud as a persistent colleague with the exact same state everywhere, it becomes a separate entity from your device—allowing you to text it, kick off tasks from your phone, and, in the future, call it from anywhere to do real work.
The second decision took that concept a step further: not only should the agent loop run in the cloud, but every bot must have its own dedicated computer. Part of this is practical, because many tasks lack well-supported MCPs and APIs; humans don't do their jobs via MCPs and APIs, they use a computer to click on pixels and type into input boxes, so bots need those baseline capabilities too. Beyond that, Roman points out the absurdity of the current moment in AI, where people onboard super-intelligent AI colleagues and ask them to share their personal machine. Making Lenny laugh, Roman compares it to hiring a new human teammate and saying: "It's your first day. I'm going to onboard you. You don't have your own laptop. You're going to sit next to me, we're going to share this laptop forever and constantly trip over each other. You're going to have access to my credentials, I'm going to have access to your credentials." Just as humans don't operate that way, AI colleagues need their own isolated machines and onboarding flows.
[33:12](https://www.youtube.com/watch?v=maSdsTLaMuU&t=1992s) The Fresh-Start Advantage Over Existing Coding Assistants
Lenny asks why other companies didn't take this approach, guessing that competitors were constrained by building on top of their existing coding assistant platforms. Roman agrees, emphasizing how freeing it is to start from scratch. The team had actually already built or attempted many of Grok Bot's underlying primitives in other ways—such as cloud infrastructure for coding agents, and the developer pattern of bringing specific, named agents into Slack to talk to as discrete entities.
For most companies, the strong default would have been to retrofit those concepts into an existing surface. Instead, the Grok Bot team decided to start from a blank slate to get the experience right for two specific things: general knowledge work (a brand-new audience) and the current moment in model capability, where models can accomplish a ton if given the right tools and infrastructure. Roman humbly notes that these primitives weren't "strokes of genius" on their part; they were already gaining attention and product-market fit in products like OpenClaw. Competitors were seeing the exact same market feedback and opportunity, but when a company has heavy sunk costs and is stuck in an existing paradigm, it is very painful to build something new from scratch.
Lenny summarizes the core keys to Grok Bot's breakout success—and jokes along the way about how the team single-handedly shifted the industry's vocabulary ("we're all moving from agents to bots now. Nice job"):
- **A cloud-based computer for every bot**, rather than running locally on the user's machine.
- **A named, specific bot per task or use case**, acting as a persistent entity rather than a fleeting chat thread or a one-off job.
- **An obsession with making sure "it just works,"** backed by the time the team invested before launch to ensure reliability.
[35:56](https://www.youtube.com/watch?v=maSdsTLaMuU&t=2156s) Lessons and Inspiration from OpenClaw
Prompted by Roman's mention of OpenClaw, Lenny recalls his own visceral first reaction to using OpenClaw ("holy shit, this is the future, how could we not have this"), followed by the release of Hermes and the broader industry race to build an OpenClaw that works easily for everyone. He asks how the OpenClaw story informed Grok Bot's design. Roman explains that as they watched the market react to OpenClaw and used it themselves, they saw that OpenClaw got two major things right.
First, OpenClaw proved that even at current intelligence levels, models can go remarkably far if you simply give them access to the actual tools you use to do your job and their own computer. In many cases where people complain that AI is "dumb" or less impactful than promised, that failure is actually downstream of the model being harnessed in the wrong way. Second, OpenClaw shifted the mental model of AI toward personification—viewing these systems as colleagues, teammates, and helper entities that have access to your life and can extend you further.
Where Grok Bot extended the OpenClaw paradigm was in accessibility, scale, and polish:
- **Eliminating the hacky setup:** Relying on a home VPN and a Mac mini setup was clearly never going to scale to millions of users, nor would it be how businesses adopt the technology. Grok Bot made setup effortless right out of the box.
- **Sanding down rough edges and hiding power-user abstractions:** To create a delightful product that "just works," the team worked to strip away technical concepts that AI power users take for granted, such as "skills," asking themselves how to design Grok Bot so a user never even has to know what a skill is.
[38:23](https://www.youtube.com/watch?v=maSdsTLaMuU&t=2303s) Abstracting Primitives and the Shift from OpenClaw to Grok Bot
Continuing his point on hiding internal complexity, Roman emphasizes that users should never have to manually type a slash command to get value out of the product. Instead, those underlying capabilities should be created automatically in the background as useful primitives that the bots can access on their own, so that "it's not incumbent on them to always be on the cutting edge of AI." That invisible orchestration is where the team has pushed hardest to innovate, though Roman notes there is still plenty of room to go further.
Hearing this prompts Lenny to reflect on his own hardware setup: a Mac Mini sitting at home with his "formerly alive OpenClaw" on it. While acknowledging that OpenClaw continues to provide value and praising the wave of innovation that era inspired, Lenny points to a striking milestone that captures just how dramatically the landscape has shifted. Claire Vo—who had been perhaps the single biggest public proponent of OpenClaw, integrating it into the core of how she lives, manages life with her kids, and runs her work—recently shut down every single one of her OpenClaw instances and switched entirely to Grok Bot. As Lenny remarks, "it sounds funny, but that's actually a huge milestone of just how much things have shifted."
[39:21](https://www.youtube.com/watch?v=maSdsTLaMuU&t=2361s) The Ultimate Vision and the "Colleague-Pilled" Framework
When Lenny asks what the long-term, ideal platonic version of Grok Bot looks like, Roman lays out a vision that is "incredibly simple": every user should have a team of AI bots helping them with both their job and their personal life. Crucially, it needs to genuinely feel like working with autonomous human teammates—colleagues you can steer without micromanaging, who already have access to all the tools needed to execute ambitious work. To reach that future, the team uses a strict product North Star: in every design decision, they force themselves to stop thinking like they are building a traditional SaaS application and start thinking like they are building capable AI teammates.
Internally, the team calls this mindset being "colleague-pilled." Roman explains that whenever the team gets stuck in a product debate where both sides have sensible arguments and traditional "product land" thinking offers no clear-cut winner, they zoom out from the "tech-companiness of it all" and ask a simple question: *"How would a human do this? Like what would you want from your teammate in this exact situation?"* Almost immediately, the debate dissolves and the room reaches a nearly unanimous consensus on how they would want a human coworker to behave. While delivering on that answer still carries complex product and model implications, identifying the right direction "doesn't require you being a genius."
```mermaid
flowchart LR
accTitle: The Colleague-Pilled Product Decision Framework
accDescr: How the Grok Bot team resolves ambiguous SaaS product debates by reframing the problem around human teammate behavior.
subgraph Debate["1. Product Deadlock"]
A["Feature Debate"] --> B["Two Sensible SaaS Options"]
end
subgraph Reframe["2. Colleague-Pilled Filter"]
C["Zoom Out from Tech Mindset"] --> D["Ask: What Would We Want from a Human Teammate?"]
end
subgraph Execution["3. Resolution"]
E["Unanimous Team Consensus"] --> F["Solve Model & Product Implications"]
end
B --> C
D --> E
```
As a concrete example of this framework in action, Roman points to how the team is designing voice interaction for Grok Bot:
- **The human collaboration analog:** When two coworkers are messaging back and forth on Slack trying to share complex context, it often becomes much easier to just click "huddle" for five minutes, talk it through, share screens to point at what is on their minds, hop off, and resume working asynchronously.
- **The AI gap:** No AI product on the market has nailed that fluid, impromptu screen-and-voice huddle experience yet, despite it being deeply integral to how humans collaborate every day—making it a prime target for what Grok Bot wants to build next.
[42:19](https://www.youtube.com/watch?v=maSdsTLaMuU&t=2539s) Work Versus Personal: Redefining Power Tools in a Single Product
Lenny loves the phrase "colleague-pilled," noting how it connects earlier themes from their conversation—such as giving each bot its own dedicated computer and a real name—before raising a broader industry question: will users ultimately rely on two separate AI assistants for work and personal life, or will a single product handle both?
Roman starts by diagnosing why people often misjudge conversational AI tools. Because of the baggage left over from "the last decade or two of horrible B2B software," people look at a clean, deceptively simple interface like ChatGPT or Grok Bot and assume it isn't a serious work product or a true "power tool." In the previous generation of software, the archetypal power tool was something like Photoshop: an intricate interface packed with precision dials where the user acts as an "ultimate cockpit flyer" who knows what every knob does and manipulates them manually. In the AI era, power tools look completely different:
| Dimension | Legacy Power Tools (e.g., Photoshop) | Future AI Power Tools (e.g., Grok Bot) |
|:--- |:--- |:--- |
| **User Role** | "Ultimate cockpit flyer" manually turning precision dials | Manager expressing intent and providing high-level steering |
| **System Complexity** | Exposed upfront via dense menus, knobs, and controls | Abstracted away; controls appear only when direct manipulation is needed |
| **Primary Interface** | Complex visual workspace | Conversational interface resembling a messaging app |
Because the interface for steering a teammate is naturally conversational, Grok Bot looks deceptively casual at a glance. Roman laughs that when he walks past a colleague's desk and sees Grok Bot open on their monitor, for a split second he still thinks, *"Oh, are they on like a messaging app?"*—before realizing it is the primary workhorse tool they are using to execute their job.
Turning directly to the work-versus-personal divide, Roman agrees that people and enterprises will naturally want clear boundaries between their professional and personal lives for common-sense security and privacy reasons. However, from a product perspective, delegating day-to-day work tasks so you can focus on high-leverage projects is fundamentally the exact same problem set as delegating low-leverage errands in your personal life. Because the underlying form factor and problem-solving mechanics are identical, Roman's instinct is that a single product will win both domains. Lenny enthusiastically notes the massive total addressable market ("Bam. That's a big TAM right there"), adding that the primary hurdle will simply be preventing cross-contamination—ensuring personal contexts cannot infiltrate or exfiltrate company data—while pairing enterprise-grade safeguards like SOC 2 compliance with an experience that still feels fun.
[45:55](https://www.youtube.com/watch?v=maSdsTLaMuU&t=2755s) Sponsor Break: Mercury Spend and the Bot Computer Abstraction
Lenny takes a brief break to highlight the episode's sponsor, Mercury, and its built-in expense management product, Spend:
- **Product-led business banking:** As a longtime customer who moved all of his business banking to Mercury, Lenny describes it as what online banking feels like when built by product people rather than traditional bankers.
- **Granular card controls (even for AI agents):** Instead of the classic startup trap where an entire company shares a single credit card until someone overspends or loses a receipt—triggering a two-day end-of-month investigation—Mercury Spend lets founders issue individual cards, set per-person or per-team limits, automatically ingest receipts via Gmail or text, and even provision dedicated cards with custom limits and policies for AI agents.
- **Regulatory details:** Mercury is a fintech company (not an FDIC-insured bank), with banking services provided through Choice Financial Group and Column N.A., Members FDIC, and the IO card issued by Patriot Bank, Member FDIC, pursuant to a license from Mastercard.
Returning to the interview, Lenny shifts to technical architecture, asking for the simplest way to conceptualize the "computer" that comes with a Grok Bot account: is it a single cloud virtual machine (VM) with multiple logins, or does every individual bot get its own isolated VM instance? Roman begins unpacking this by extending the human teammate analogy even further: if he and Lenny were coworkers on the same team, the number of times Lenny would need to physically take over Roman's computer, grab the mouse, start clicking around, and say, *"You're doing this wrong, you should go here instead and type in manually,"* would hopefully be pretty close to zero.
Continuing his point about treating AI like a human teammate, Roman explains that while computer use is already good and rapidly improving, in very short order the "computer concept" will be completely abstracted away from the user. Users should never have to click into a remote virtual machine or manually take over the controls just to steer an agent off a wasteful path. In the medium term, knowing the agent has a computer is a helpful mental model for users, even if they never directly interact with that desktop themselves.
Instead of the current paradigm—where users spin up a brand-new chat for every discrete unit of work and end up constantly copying and pasting context between threads—Roman argues that Grok Bot should be understood as a team of long-lived agents organized by roles and swim lanes. Rather than disposable one-off sessions, these agents retain a very long memory of past interactions, learn from the user, and get smarter over time. Crucially, they have access to everything a human colleague would have: APIs, MCPs, and their own dedicated computer that they can freely manipulate.
Lenny shares a mind-expanding demo he saw at a recent meetup from Shub on the go-to-market team: because each agent has its own computer, Shub was actually running Grok Bot *inside* Grok Bot to handle testing and watch for regressions, prompting Lenny to joke about how many levels deep you can go "before the universe collapses on itself." Roman laughs and confirms he does the exact same thing with a dedicated QA tester bot. Whenever there is a bug report or a new desktop app build, he gives the bot ten core workflows to test release after release, instructing it to log results into an extensive Notion document and compare performance against past client versions. Breaking out of the mindset of "AI chat with a set of connections" and shifting to "a colleague with a computer" dramatically raises the ceiling of what people think to delegate to AI.
[51:04](https://www.youtube.com/watch?v=maSdsTLaMuU&t=3064s) Grok Bot as an Always-On Infovore and Proactive Chief of Staff
When Lenny asks for other mind-expanding setups, Roman admits he gets "kind of nerdy about optimizing my setup" and describes a pattern with massive depth: using Grok Bot as an "infovore." By consuming huge quantities of information and filtering out the noise, the bot removes cognitive load, gives you peace of mind, and surfaces only what matters.
```mermaid
flowchart LR
accTitle: Roman's V3/V4 Infovore Architecture
subgraph Inputs["Information Firehose"]
X["Every Grok Bot mention on X"]
IC["Internal company context"]
end
subgraph Agent["Chief of Staff Bot"]
GB["Infovore Grok Bot"]
QA["QA Tester Bot"]
end
subgraph Outputs["Proactive Action"]
MSG["Messaging services (outreach)"]
PG["Urgent user paging / Daily roundup"]
end
X --> GB
IC --> GB
GB <-->|"Repro bugs & feedback"| QA
GB --> MSG
GB --> PG
```
While a V1 implementation simply sits on top of Slack and email with high-level instructions on what role the user has, when to send a direct notification, and what to save for a daily roundup, Roman estimates his personal setup is at "V3 or four":
- **A complete firehose of inputs:** He hooks his bot up to every mention of Grok Bot on X alongside internal company context.
- **Cross-agent collaboration:** The infovore bot talks directly to his QA tester bot to automatically reproduce bugs or verify feedback reported online.
- **Direct action:** It connects to his messaging services so he can rapidly act on feedback and reach out to users.
- **Emergency paging:** Some users have even given Grok Bot pager access so it can page them while they are out grabbing coffee if something super urgent happens—a high-trust setup that requires zero false positives, and which those users report has been very helpful and successful so far.
Roman views this as a preview of the next major shift in AI: moving to an always-on "chief of staff" entity that surveils the landscape, preserves your focus, and is much more proactive in reaching out to you than you are to it.
[53:35](https://www.youtube.com/watch?v=maSdsTLaMuU&t=3215s) Go-to-Market Strategy: From Nights-and-Weekends Consumer Fun to Enterprise Teams
Lenny remarks on how impressed he is by the team's speed and aggressive market-capture strategy—handing out tons of free accounts to grab market share before foundation labs catch up, and heavily emphasizing concrete use cases and templates on Twitter so new users aren't left wondering what to do with such a novel tool. Asked how his prior experience leading growth at Cursor informs this go-to-market push, Roman explains that culturally they obsess over building practical AI that transforms companies rather than "demoware" or shiny prototypes.
He sees knowledge work following the exact same adoption curve that coding went through around 2023. Back then, developers used basic pre-AI IDEs at their day jobs, went home on nights and weekends to build side projects with Cursor or other cutting-edge AI coding tools, and felt like they were experiencing the future. Returning to work on Monday felt like "walking through molasses," prompting them to demand their companies adopt the tool.
Today, Grok Bot is sparking that same personal "aha moment" on X, with users showing off fun consumer use cases like controlling a home robot vacuum cleaner or negotiating a lower price on a Tesla charger installation. However, Roman emphasizes that Grok Bot is not a consumer product; the real next step is transforming businesses by bringing bots into teams to contribute economically valuable work. Consequently, their go-to-market push is heavily prioritizing businesses and tackling the hard, unanswered questions of moving from single-player mode to multiplayer enterprise reality: how a bot operates inside a broader team, how it navigates complex company systems with deep context and history, and what persistent memory looks like across an entire organization rather than for a single individual.
[57:46](https://www.youtube.com/watch?v=maSdsTLaMuU&t=3466s) The Three Pillars of SpaceXAI
Lenny observes that Grok Bot appears to be the breakthrough primitive for bringing AI agents to the rest of the company beyond software engineering. He emphasizes that while the product itself is remarkable, the team's distribution savvy is just as critical in today's crowded landscape. Seeking clarity on the broader corporate landscape following Cursor’s acquisition by SpaceX, Lenny asks Roman to break down the different brands—SpaceXAI, Cursor, Grok Build, and Grok Bot—and how they fit together.
Roman outlines SpaceXAI as being structured around three core pillars. The first pillar is dedicated to specialized developer tooling, anchored by Cursor and Grok Build. While people already use Grok Bot for engineering-adjacent tasks—such as initiating cloud agents, handling QA, or merging pull requests—shipping production-grade software demands a dedicated, professional work surface where "every pixel is optimized for that end user." The second pillar is general knowledge work, represented by Grok Bot, which is expanding into a full-fledged AI teammate that employees can delegate company workflows to across new surfaces. The third pillar is model training, where SpaceXAI focuses on building the smartest, most capable models in the world.
Roman notes that what sets SpaceXAI apart from other leading AI research labs is a cultural groundedness. Rather than chasing vague, aspirational concepts like artificial general superintelligence, the team is fundamentally applied and engineering-driven. The people training the models approach the problem with a builder's mindset focused on creating useful, practical AI—a direct philosophy that flows seamlessly between the foundational models and the end-user products.
```mermaid
flowchart TD
accTitle: The Three Pillars of SpaceXAI
accDescr: A structural overview showing how SpaceXAI divides its focus across developer tools, general knowledge agents, and applied foundation models.
Root["SpaceXAI Core Strategy"]
subgraph P1["Developer Tools"]
Cursor["Cursor"]
GrokBuild["Grok Build"]
end
subgraph P2["Knowledge Work"]
GrokBot["Grok Bot"]
end
subgraph P3["Foundation Models"]
AppliedModels["Applied, Useful Models<br/>(Engineering Mindset)"]
end
Root --> P1
Root --> P2
Root --> P3
```
- **Pillar 1: Professional Coding Surfaces:** Centered on Cursor and Grok Build. Designed specifically for production software development, recognizing that general chat or lightweight bot interfaces cannot replace a dedicated IDE experience.
- **Pillar 2: General Knowledge Work:** Powered by Grok Bot, aimed at non-coding knowledge workers across enterprise teams to act as an autonomous coworker.
- **Pillar 3: Practical Model Development:** Building top-tier frontier models guided by an applied engineering culture rather than chasing abstract notions of superintelligence.
---
[01:00:44](https://www.youtube.com/watch?v=maSdsTLaMuU&t=3644s) The 90% Trap vs. The 100% "No-Look Pass"
Lenny references one of Roman's standout tweets: *"An AI that does 100% of the job feels categorically different from one that gets you 90% there. I've significantly updated what I think AI is capable of."* He asks Roman to unpack the psychology behind that statement. Roman explains that working on Grok Bot marked the very first time he could delegate a non-coding task to AI, walk away completely without monitoring it, and return to find it fully finished. While software engineers experienced this shift over the past eighteen months—fundamentally altering their day-to-day workflow until it became unrecognizable compared to two years ago—most knowledge workers remained trapped in the clunky 2022 chatbot interaction loop: opening a fresh thread, typing a prompt, babysitting each step, receiving an incomplete result, and endlessly re-prompting.
Roman argues that a 90% complete output offers almost none of the relief of true delegation. If you assign a task to a colleague you only 90% trust, the mental burden remains entirely on you: you are constantly anticipating errors, wondering when you will need to step in, and planning how to steer them. "You're not—that's not 90% task completion. You're still doing the thing and it feels that way and it's weighing on you in the same way."
In contrast, reaching 100% reliability unlocks what Roman calls the "no-look pass." It mirrors the feeling of tossing the ball to a teammate you completely trust, saying "you got this," and never glancing back because you know they will score. That qualitative leap from hand-holding to autonomous execution transforms the psychological experience of using AI from a cognitive chore into pure magic.
- **The Developer vs. Knowledge Worker Divide:** Software engineers adapted to deep agentic workflows over a year ago, while non-technical workers have remained stuck in back-and-forth prompt threads.
- **The Cognitive Tax of 90% Trust:** Needing to supervise or correct an AI means the user never offloads the mental overhead of the task.
- **The "No-Look Pass":** Complete delegation occurs only when the user has enough confidence in the agent to fire off context, step away, and return to a finished deliverable.
---
[01:03:30](https://www.youtube.com/watch?v=maSdsTLaMuU&t=3810s) Scramble Energy: Moving Fast at Scale
Lenny remarks on the breakneck execution speed of the SpaceXAI team, recounting his own experience inside a shared Slack channel where feature rollouts and marketing initiatives happen overnight—such as preparing promo codes for tomorrow or deciding to stand up a template marketplace in two days flat. He asks Roman how the organization maintains this cadence without sacrificing software quality or drifting away from its long-term vision.
Roman reflects on the company's trajectory, noting that when he joined Cursor, the team consisted of around 15 people. They subsequently scaled past 1,000 employees before becoming part of the broader SpaceXAI organization. In high-growth companies, conventional wisdom suggests that bureaucracy inevitably creeps in; leaders hire from big-tech scale-ups and insist "we're still a startup," even when everyone internally knows the company has slowed to a crawl. Roman takes pride in the fact that SpaceXAI has actively resisted this inertia by preserving what he describes as "scramble energy."
To Roman, a startup is never defined by funding rounds or headcount; it is defined by a specific operating state that is slightly chaotic, disorganized, and hyper-empowering. While that environment is not for everyone, it creates a workplace where individual agency is maximized and "you really do get out of a system what you put in." By staffing the team with exceptional talent, giving them high-trust autonomy, and maintaining a clear vision, the organization continues to ship with the urgency of a 15-person room despite operating at enterprise scale.
- **Hypergrowth Timeline:** Scaled from an early team of 15 at Cursor up to 1,000+ employees, before integrating into SpaceXAI.
- **Defining a Startup by Energy, Not Size:** Rejecting headcount or venture funding as metrics for a startup, framing it instead as a culture of rapid, disorganized, high-impact momentum.
- **High-Trust Autonomy:** Ensuring engineers and operators can ship within 24 to 48 hours without getting blocked by layers of middle management.
---
[01:06:35](https://www.youtube.com/watch?v=maSdsTLaMuU&t=3995s) Defying the Odds Against AI Giants
Lenny sets up a core question about Cursor's extraordinary market position, pointing out that from the outside looking in, Cursor should never have succeeded. The company ventured into one of the most fiercely contested verticals in technology history, going head-to-head with the best-funded, fastest-growing AI foundation model labs in the world—most notably OpenAI and Anthropic. Lenny prepares to dive deep into how a small challenger product not only survived against frontier model providers building their own coding tools, but established a dominant, market-defining position.
[01:07:03](https://www.youtube.com/watch?v=maSdsTLaMuU&t=4023s) How Cursor Kept Winning in a Hyper-Competitive Market
Reflecting on Cursor's trajectory from an outsider's perspective, Lenny notes that the company's ability to achieve a massive exit and sustain its success comes down to two things: how rapidly the team adjusts to market reality—evolving from simple autocomplete to chatting with agents, then moving to the cloud, and now launching Grok Bot—and consistently building the best-in-class experience for capabilities that also exist elsewhere. Whether it is Cursor as the premier IDE for coding or Grok Bot as a knowledge-work agent, Lenny asks what Roman considers the core driver behind Cursor's ability to not just survive, but thrive so consistently in a fiercely competitive market.
Roman admits the answer is somewhat fuzzy because it is entirely downstream from company culture, the people they hire, and how those people approach problems. Above all, the team has never been complacent: "we've never felt like we've won and it's always been about the next thing." Across the company, there is a deep-seated belief that because AI moves so fast, their job is to translate raw capabilities into amazing products that "meet the moment." What met the moment two years ago looks nothing like what meets the moment today. Roman stresses that if the company cannot completely reinvent its priorities, core product, and user experience every six months—a cycle that has recently felt even shorter—they will lose. It is this refusal to believe they have "gotten it right" and a commitment to constantly updating their beliefs that led directly to investments like Grok Bot.
To underscore this point, Roman reminds listeners that AI coding has been crowded since the very beginning. When Cursor first launched, it went up against Microsoft and a handful of 10 to 20 other startups. Remarkably, none of those original competitors are at the forefront of AI coding today. Their disappearance wasn't caused by a single bad decision or a lack of resources, Roman argues, but rather by a "cultural inability to move quickly and to change to meet the moment as the moment's changing."
[01:10:04](https://www.youtube.com/watch?v=maSdsTLaMuU&t=4204s) Core Company Values: "Deleting the Product" and "Just Do the Thing"
When Lenny asks if there are specific phrases or core values the team uses to remind everyone how they operate, Roman highlights two principles he returns to constantly:
- **Deleting the product:** Looking back at every past iteration of Cursor—and looking ahead to future iterations of Grok Bot—progress is defined by things going away rather than new features being bolted on. When models aren't smart enough to handle a task natively, engineers build temporary "scaffolding, product overhang style things" to bridge the gap. As models improve, that scaffolding must be stripped away. The team has to be comfortable making hard removal decisions that might upset a small subset of users (or even colleagues internally) in order to keep the product simple, powerful, and aligned with the future.
- **Just do the thing:** Tied directly to their pace of execution, this mantra preserves urgency even as the company scales. Roman emphasizes that everyone is in the same boat trying to win, and "this is not an ask for permission culture." If someone spots a problem that needs fixing, they are expected to go fix it and pull in whatever resources are necessary—a high-agency mindset that has made many employees successful at Cursor and is deeply shared with SpaceXAI.
[01:11:45](https://www.youtube.com/watch?v=maSdsTLaMuU&t=4305s) Why Moats Are Discovered, Not Planned
Turning to the topic of defensibility, Lenny points out that many observers view Cursor as a fascinating case study: a company operating in a market with seemingly no traditional moats that nonetheless keeps winning. From the outside, Cursor's two main advantages appear to be its proprietary data feedback loop—learning from how users accept autocompletes to train better custom models—and a best-in-class, high-DAU product experience refined over time. He asks Roman what advice he has for founders trying to figure out their own moats in the AI era, where projecting 12 to 24 months ahead feels like an eternity.
Roman argues that if Cursor—or any successful company of its vintage—had started by obsessing over moats or working backward from an abstract strategy diagram, they never would have built the product or achieved their outcome. Instead, the magic of Cursor came from "an obsession with building a useful thing today." The team treated product development as a recurring prompt: look three to six months into the future to see what smarter models will soon make solvable, and ask, "how could we pull that stuff to today?" Even if bringing that capability forward required heavy custom engineering on top of the model or reshaping the UI so users could interact with it, they built it immediately—fully intending to delete all that custom scaffolding three months later once the underlying models made it a basic commodity, and then immediately shifting to the next three-month horizon.
```mermaid
flowchart LR
accTitle: Cursor's Rolling 3-Month Frontier Loop
accDescr: How Cursor builds trust and discovers moats by repeatedly pulling future capabilities into the present and deleting scaffolding once models catch up.
subgraph Cycle["The Recurring Frontier Loop"]
direction LR
A["Spot capability 3–6 mos out"] --> B["Build engineering scaffolding today"]
B --> C["Delete scaffolding when models catch up"]
C --> A
end
subgraph Outcome["Compounding Byproducts"]
direction TB
D["User trust & time in product"]
E["Distribution & data moats"]
D --> E
end
Cycle --> Outcome
```
Repeating that cycle over and over earned deep user trust; developers invested their time in Cursor because they knew the team would consistently bring them to the next frontier. Roman advises founders to ground themselves in making the currently impossible possible today, pulling users from one frontier to the next, and letting distribution and data advantages compound naturally as a byproduct. Lenny loves this framing—build something people are obsessed with and don't overthink defensibility—noting it echoes a takeaway from another recent podcast episode: "moats are discovered, not planned ahead of time."
[01:15:11](https://www.youtube.com/watch?v=maSdsTLaMuU&t=4511s) Getting Started with Grok Bot: Context Over Hacky Knobs
For his final question before the lightning round, Lenny asks for practical Grok Bot advice—both foundational keys to success for brand-new users downloading the app for the first time, and power tips for experienced users.
Roman intentionally steers clear of "super hacky pro tip stuff," explaining that the team's core philosophy is that secret knobs and tricks shouldn't exist in the first place—you should simply be able to delegate a task to Grok Bot and trust it to get done. Instead, for someone looking at a fresh install screen, his number one piece of advice is to **give Grok Bot the context it needs to be successful**. Just like onboarding a new human teammate, you want to connect it to the everyday tools where your work actually lives—such as Slack, email, and core company records—and then literally ask Grok Bot what it can do for you, letting it explore those connections on its own.
[01:16:27](https://www.youtube.com/watch?v=maSdsTLaMuU&t=4587s) Practical Tips for Grok Bot: Onboarding and Power-User Scaffolding
Reflecting on how to get started with Grok Bot, Roman shares a prompt strategy he used before the product even had onboarding screens. During his own initial setup, he connected his core data streams—email and Slack—and gave the bot an open-ended directive: go through both platforms, identify five concrete tasks it could take off his plate, and outline what access or instructions it would need to do so. The bot came back with five proposals; two were exceptionally useful right out of the box, prompting Roman to immediately spin off two dedicated bots to handle them. That was his personal "wow moment," cementing the realization that Grok Bot was fundamentally different from past AI tools: it wasn't just helping draft an email, "it was like do a chunk of work." He strongly advises all first-time users to adopt that exact exercise as their entry point.
For advanced users, Roman describes how his workflow has evolved toward orchestrating multiple collaborating bots. Rather than reading fragmented outputs across different chat windows, he has built a scaffolding where bots push generated artifacts to a single, structured data store or database. Every morning, he can review synthesized daily digests in one clean, highly legible format. He urges power users to invest in defining clear shared destinations where their fleet of bots can deposit work asynchronously.
- **Beginner onboarding prompt:** Connect primary communication channels (email, Slack) and instruct Grok Bot: *"Go through my Slack, go through my email and suggest like five things that you can take off of my plate and what it would take for you to do that."*
- **Power-user architecture:** Create a centralized repository or database for multi-bot outputs, allowing long-lived agents to collaborate and publish automated executive digests directly to a single interface.
---
[01:18:00](https://www.youtube.com/watch?v=maSdsTLaMuU&t=4680s) Lightning Round: Books, Movies, Semantic Search, and Desiderata
Lenny transitions into the signature four-question lightning round, touching on reading recommendations, media, emerging AI tools, and guiding life philosophies:
- **Favorite books:** Roman highlights two recurring recommendations. First is Kurt Vonnegut’s *Cat's Cradle*, which he has bought for many friends over the years. Second is *The War of Art* by Steven Pressfield, an essential read on overcoming internal creative "resistance" that Roman still revisits frequently, often just reading a page or two for a quick reset.
- **Movies and TV shows:** Every year, Roman makes a point to rewatch *Casablanca*—partly for its cinematic brilliance and partly because Peter Lorre’s character, Ugarte, represents the rare instance of Roman's exact surname appearing in popular media. On television, he frequently revisits *Monk*, a nostalgic childhood favorite that doubles as a vivid time capsule of San Francisco in the late 1990s and early 2000s.
- **AI products outside of Grok Bot:** Self-described as an "AI semantic search nerd," Roman loves tools that allow intuitive vector querying across unconventional data sets. He was an early adopter of Metaphor (now Exa) and continues using Exa for complex, non-traditional internet queries. He also enjoys bespoke community-built semantic search tools, such as vector-embedded visual search over collections like the Museum of Modern Art (MoMA).
- **Life motto / guiding text:** Roman turns to *Desiderata*, the famous 1927 prose poem by Max Ehrmann. Having taped a copy to his bedroom door as a teenager, he has carried the tradition to every apartment he has lived in since, finding that its measured reflections offer renewed perspective and grounding every time he reads them.
---
[01:21:20](https://www.youtube.com/watch?v=maSdsTLaMuU&t=4880s) Closing Thoughts, Feedback, and Wrap-Up
Reflecting on the whirlwind pace of modern AI, Lenny notes how remarkable it is to capture this specific inflection point in knowledge work agents, observing that revisiting the conversation in a year will reveal just how much early teams got right versus what was completely unexpected. With the Grok Bot public beta barely three weeks old, Roman emphasizes that the team considers the product to be in its absolute "early innings."
Rather than pitching a finished software suite, Roman makes an open call for user critique and community feedback. Because the team works on an ultra-rapid iteration cycle, incoming feature requests and user pain points from early adopters are directly dictating the engineering roadmap on a weekly basis. Lenny wraps up by commending Roman and the entire SpaceXAI engineering team for turning a clean-slate prototype into a viral tool in under two months, concluding the interview with standard show logistics for ratings, reviews, and past episode archives at `lennyspodcast.com`.
## Notable quotes
> [00:00](https://www.youtube.com/watch?v=maSdsTLaMuU&t=0s) The ultimate vision of Grok Bot is incredibly simple. You should have a team of AI bots that help you with your job and help you with your life. — Roman Ugarte
> [09:29](https://www.youtube.com/watch?v=maSdsTLaMuU&t=569s) three different visions that all kind of share a screen and you can hop between, but it is kind of a shipping your org chart style thing that I think users are reacting negatively to. — Roman Ugarte
> [11:20](https://www.youtube.com/watch?v=maSdsTLaMuU&t=680s) that can never happen again, we need to solve this tomorrow because tomorrow I'm onboarding this person and it needs to go better. — Roman Ugarte
> [28:42](https://www.youtube.com/watch?v=maSdsTLaMuU&t=1722s) let's kill as many pixels as we can. — Roman Ugarte
> [30:02](https://www.youtube.com/watch?v=maSdsTLaMuU&t=1802s) It's your first day. I'm going to onboard you. You don't have your own laptop. You're going to sit next to me, we're going to share this laptop forever and constantly trip over each other. You're going to have access to my credentials, I'm going to have access to your credentials. — Roman Ugarte
> [33:12](https://www.youtube.com/watch?v=maSdsTLaMuU&t=1992s) we're all moving from agents to bots now. Nice job — Lenny Rachitsky
> [38:23](https://www.youtube.com/watch?v=maSdsTLaMuU&t=2303s) it's not incumbent on them to always be on the cutting edge of AI. — Roman Ugarte
> [39:21](https://www.youtube.com/watch?v=maSdsTLaMuU&t=2361s) How would a human do this? Like what would you want from your teammate in this exact situation? — Roman Ugarte
> [01:00:44](https://www.youtube.com/watch?v=maSdsTLaMuU&t=3644s) An AI that does 100% of the job feels categorically different from one that gets you 90% there. I've significantly updated what I think AI is capable of. — Roman Ugarte
> [01:00:44](https://www.youtube.com/watch?v=maSdsTLaMuU&t=3644s) You're not—that's not 90% task completion. You're still doing the thing and it feels that way and it's weighing on you in the same way. — Roman Ugarte
> [01:07:03](https://www.youtube.com/watch?v=maSdsTLaMuU&t=4023s) we've never felt like we've won and it's always been about the next thing. — Roman Ugarte
> [01:10:04](https://www.youtube.com/watch?v=maSdsTLaMuU&t=4204s) this is not an ask for permission culture. — Roman Ugarte
> [01:11:45](https://www.youtube.com/watch?v=maSdsTLaMuU&t=4305s) moats are discovered, not planned ahead of time. — Lenny Rachitsky
> [01:15:11](https://www.youtube.com/watch?v=maSdsTLaMuU&t=4511s) Go through my Slack, go through my email and suggest like five things that you can take off of my plate and what it would take for you to do that. — Roman Ugarte
## Mentioned
Roman Ugarte, Lenny Rachitsky, Adam Ward, Claire Vo, Shub, Grok Bot, Grok 4.6, Grok Build, SpaceXAI, SpaceX, Cursor, Anthropic, Cowork, OpenAI, Codex, ChatGPT, ChatGPT Work, Devin, OpenClaw, Hermes, Slack, TestFlight, Shopify, Salesforce, Model Context Protocol (MCP), LinkedIn, Google Scholar, X, Mac mini, Photoshop, SOC 2, WorkOS, Mercury, Mercury Spend, Superhuman, Stripe, Gmail, Notion, Choice Financial Group, Column N.A., Patriot Bank, Mastercard, Tesla, Microsoft, Exa, Metaphor, Museum of Modern Art (MoMA), Kurt Vonnegut, Cat's Cradle, Steven Pressfield, The War of Art, Casablanca, Peter Lorre, Monk, Max Ehrmann, Desiderata
## Video description
Roman Ugarte helped incubate and build Grok Bot, the popular new knowledge-work agent from SpaceXAI. A small, isolated team took it from first line of code to a working internal product in four weeks, and to a hugely successful public launch just three weeks later. Before Grok Bot, Roman led Growth at Cursor, where he helped scale the company from 15 people to over 1,000 before its acquisition by SpaceX.
*In our in-depth conversation, we discuss:*
1. The origin story of Grok Bot
2. The key decision to build it from scratch instead of adding it to Cursor
3. Why the team personally onboarded nearly 300 of its first users
4. The two early product decisions that made Grok Bot so successful
5. Their “colleague-pilled” product philosophy
6. Roman’s advice on moats, and what has allowed Cursor to keep winning in the most competitive market in the world
*Brought to you by:*
WorkOS—Make your app enterprise-ready, with SSO, SCIM, RBAC, and more: https://workos.com/lenny
Mercury—Radically different banking, now with Command: https://mercury.com/
*Episode transcript:* https://www.lennysnewsletter.com/p/how-we-built-grok-bot-in-a-month
*Archive of all Lenny's Podcast transcripts:* https://www.dropbox.com/scl/fo/yxi4s2w998p1gvtpu4193/AMdNPR8AOw0lMklwtnC0TrQ?rlkey=j06x0nipoti519e0xgm23zsn9&st=ahz0fj11&dl=0
*Where to find Roman Ugarte:*
• X: https://x.com/romanugarte_
• LinkedIn: https://www.linkedin.com/in/romanugarte
• Website: https://x.ai
*In this episode, we cover:*
(00:00) Introduction
(02:09) The origin story: building from scratch in one month
(08:40) Why Grok Bot was built as a separate product
(11:20) Manually onboarding a couple hundred people
(14:29) Hiding internal mechanics from users
(18:41) Timeline from beta to public launch
(19:14) Unshipping features and simplifying
(23:50) Early use cases and feedback
(26:50) Product philosophy: “Grok Bot can now”
(30:02) Cloud-first architecture
(33:12) The fresh-start advantage
(35:54) The vision: a true team of AI colleagues
(39:20) The “colleague-pilled” framework
(42:36) Work versus personal: one product or two?
(47:14) Long-lived agents, persistent memory, and the computer abstraction
(51:04) Grok Bot as an always-on infovore and chief of staff
(53:35) How fast the team moves and what preserves the startup feeling
(58:20) SpaceXAI pillars
(1:00:44) The first 90% vs. the last 10%
(1:03:30) Moving fast at scale
(1:06:40) How Cursor kept winning in the most competitive market in the world
(1:10:04) Company values: “deleting the product” and “just do the thing”
(1:11:45) Moats: discovered, not planned
(1:15:11) Tips for new users and power users
(1:18:00) Lightning round and final thoughts
*Referenced:*
• Grok Bot for iOS: https://apps.apple.com/us/app/grok-bot/id6794501026
• Grok Bot for Android: https://play.google.com/store/apps/details?id=ai.x.grok.bot&hl=en_US
• How I AI: Grok Bot + Grok 4.6—what’s great (and what’s still hype) & Lessons from spending $20,000 on Devin in one month: https://www.lennysnewsletter.com/p/how-i-ai-grok-bot-grok-46whats-great
• Codex: https://chatgpt.com/codex
• ChatGPT Work: https://chatgpt.com
• Shopify: https://www.shopify.com
• Salesforce: https://www.salesforce.com
• The playbook for building high-talent-density teams | Adam Ward, Head of Talent at Cursor: https://www.lennysnewsletter.com/p/the-playbook-for-building-high-talent
• Superhuman: https://superhuman.com
• Stripe: https://stripe.com
• OpenClaw: https://openclaw.ai
• Listen: OpenClaw: A power user’s guide to the most powerful personal AI tool since ChatGPT: https://www.lennysnewsletter.com/p/listen-openclaw-a-power-users-guide
• Hermes: https://hermes-agent.nousresearch.com
• From skeptic to true believer: How OpenClaw changed my life | Claire Vo: https://www.lennysnewsletter.com/p/how-openclaw-changed-my-life-claire-vo
• Cursor: https://cursor.com
• Grok Build: https://x.ai/build
• Roman’s post on X, “An AI that does 100% of the job feels categorically different from one that gets you 90% there”: https://x.com/romanugarte_/status/2087344044435505175
• Notion: https://www.notion.com
• Casablanca: https://www.imdb.com/title/tt0034583
• Monk: https://www.imdb.com/title/tt0312172
• Exa: https://exa.ai
• Desiderata - Words for Life: https://allpoetry.com/desiderata---words-for-life
*Recommended books:*
• Cat’s Cradle: https://www.amazon.com/dp/038533348X
• The War of Art: Break Through the Blocks and Win Your Inner Creative Battles: https://www.amazon.com/War-Art-Through-Creative-Battles/dp/1936891026
_Production and marketing by https://penname.co/._
_For inquiries about sponsoring the podcast, email podcast@lennyrachitsky.com._
Lenny may be an investor in the companies discussed.
According to Roman Ugarte, Grok Bot's breakthrough stems from treating AI as an autonomous, cloud-hosted coworker rather than a conversational prompt or an added IDE feature. By starting from scratch, assigning each bot a dedicated computer, and ruthlessly stripping interface complexity, the team shifted user interaction from conversational micromanagement to full task delegation.
The "Colleague-Pilled" Paradigm and Invisible UI (39:21)
The core philosophy behind Grok Bot is what the team calls being "colleague-pilled": resolving product debates by asking how an effective human teammate would behave rather than following traditional SaaS conventions. This principle led the team to hide mechanical plumbing. Instead of displaying streaming reasoning traces, tool calls, or mouse clicks, Grok Bot maintains a Slack-like presence with a simple typing indicator. Ugarte notes that because human coworkers do not narrate every keystroke, AI should provide completed work or concise updates without cluttering the interface.
This approach extends to capability design. The team evaluates updates through the framing "Grok Bot can now" rather than "Grok Bot now has," focusing on autonomous skills over interface widgets. As a result, 99% of automations on the platform are set up via natural language rather than multi-step configuration menus. Ugarte argues that achieving 100% completion unlocks a trusted "no-look pass," whereas 90% completion leaves users trapped with the cognitive burden of monitoring and correction.
Dedicated Cloud Computers and Multi-Bot Architecture (30:02)
Grok Bot diverged from existing AI assistants through two architectural choices: committing to a 100% cloud-first runtime and giving every bot its own dedicated computer. Cloud execution eliminates local state problems, allowing users to kick off persistent tasks from mobile or desktop seamlessly. Dedicating a virtual computer to each bot allows agents to manipulate standard graphical interfaces directly, bypassing the need for clean APIs or Model Context Protocol (MCP) support that many enterprise tools lack.
This environment supports long-lived, role-specific agents that retain memory over time rather than disposable chat threads. In practice, early users evolved from running independent task bots to implementing a "Chief of Staff" structure, where a lead bot delegates assignments to specialist agents and consolidates results. The isolated computer architecture has even allowed team members to run Grok Bot inside Grok Bot to perform automated QA and regression testing.
The Blank Slate Versus "Shipping the Org Chart" (9:29)
Rather than adding a knowledge-work tab inside Cursor, the team launched Grok Bot from a clean slate. Ugarte explains that competitors often "ship their org chart" by crowding multiple product visions onto a single screen, which clutters the interface and intimidates non-technical users. Building independently allowed the team to control every visual element and design specifically for enterprise knowledge work.
The initial prototype emerged from a four-week "cave sprint" by a tiny, isolated team operating without corporate roadmaps or formal review layers. When presented at an internal all-hands meeting, the tool quickly went viral across SpaceX, with sales teams automating CRM workflows and recruiters autonomously screening unindexed conference papers. That spontaneous internal adoption gave the team confidence to harden infrastructure and launch publicly within three weeks.
Operational Scramble and Discovered Defensibility (70:04)
SpaceXAI prioritizes rapid iteration and high individual agency over preplanned moats, operating under internal mantras like "just do the thing" and "deleting the product." Ugarte notes that product progression often requires actively removing scaffolding once underlying models become capable of handling tasks natively, even if cuts upset some users. In his view, defensibility cannot be strategized years in advance; teams must discover moats by pulling what models will solve three to six months from now into the present.
To avoid the insular assumptions of the Silicon Valley AI ecosystem, the team conducted 200 to 300 manual onboarding calls with diverse testers, including a local coffee shop owner whose daily Shopify workflows exposed edge cases internal dogfooding missed. For new users, Ugarte advises skipping complex prompt tricks: simply connect core communication tools like email and Slack, and ask the bot directly to identify five operational tasks it can take off their plate.
With the public beta live for only three weeks during recording, Ugarte views Grok Bot as being in its earliest innings. While the tool proved effective for personal workflows, moving agentic systems from single-player productivity into multiplayer enterprise collaboration remains an unresolved operational frontier.
Source quotes
[0:00] Roman Ugarte: The ultimate vision of Grok Bot is incredibly simple. You should have a team of AI bots that help you with your job and help you with your life.
[9:29] Roman Ugarte: three different visions that all kind of share a screen and you can hop between, but it is kind of a shipping your org chart style thing that I think users are reacting negatively to.
[11:20] Roman Ugarte: that can never happen again, we need to solve this tomorrow because tomorrow I'm onboarding this person and it needs to go better.
[28:42] Roman Ugarte: let's kill as many pixels as we can.
[30:02] Roman Ugarte: It's your first day. I'm going to onboard you. You don't have your own laptop. You're going to sit next to me, we're going to share this laptop forever and constantly trip over each other. You're going to have access to my credentials, I'm going to have access to your credentials.
[33:12] Lenny Rachitsky: we're all moving from agents to bots now. Nice job
[38:23] Roman Ugarte: it's not incumbent on them to always be on the cutting edge of AI.
[39:21] Roman Ugarte: How would a human do this? Like what would you want from your teammate in this exact situation?
[60:44] Roman Ugarte: An AI that does 100% of the job feels categorically different from one that gets you 90% there. I've significantly updated what I think AI is capable of.
[60:44] Roman Ugarte: You're not—that's not 90% task completion. You're still doing the thing and it feels that way and it's weighing on you in the same way.
[67:03] Roman Ugarte: we've never felt like we've won and it's always been about the next thing.
[70:04] Roman Ugarte: this is not an ask for permission culture.
[71:45] Lenny Rachitsky: moats are discovered, not planned ahead of time.
[75:11] Roman Ugarte: Go through my Slack, go through my email and suggest like five things that you can take off of my plate and what it would take for you to do that.
Original transcript
[0:00] The ultimate vision of Grockbot is
[0:02] incredibly simple. You should have a
[0:05] team of AI bots that help you with your
[0:08] job and help you with your life.
[0:10] >> Grockpot is the hottest AI product in
[0:12] the world right now. That is a very high
[0:13] bar. There's a lot of competition for
[0:15] that slot.
[0:16] >> We wanted to build something that wasn't
[0:18] just a great product for developers and
[0:21] engineers. We decided to create this
[0:23] very small team internally to go off
[0:25] into a cave for about a month with the
[0:27] sole objective of build an amazing
[0:29] knowledge work product that brings
[0:32] agents to the rest of the company.
[0:33] >> It's been only 3 weeks since launch. I
[0:35] went to a rock meetup. There were
[0:37] hundreds of people there. Standing room
[0:39] only. It's very clear to me that you
[0:41] guys have built something very special.
[0:43] >> Once you start breaking out of this is
[0:45] AI chat with a set of connections
[0:48] instead to this is a colleague with a
[0:50] computer. It just raises the ceiling of
[0:52] what you would think to give to AI.
[0:54] >> You have this tweet, an AI that does
[0:56] 100% of the job feels categorically
[0:58] different from one that gets you 90%
[1:00] there.
[1:00] >> What made me so excited to work on
[1:03] Grockbot is it was the first time for
[1:06] non-coding tasks that I felt like I
[1:09] could truly delegate work to AI, not
[1:12] have to think about it, and I would come
[1:14] back and it's done. What is it that you
[1:16] think you did that is so different that
[1:18] made Grockbot so successful? It was two
[1:21] early decisions that at the time
[1:23] definitely did not feel obvious, but in
[1:26] hindsight I think are critical to what
[1:28] makes Grockbot work.
[1:30] Today my guest is Roman Ugarte. I'm
[1:33] going to keep this intro very short so
[1:34] we can get right into it. Roman was
[1:36] employee number 15 at Cursor. He has had
[1:38] a growth for the last 2 years. Most
[1:40] recently, he helped incubate Grockbot, a
[1:42] product that I am obsessed with. It has
[1:44] changed my life. I use it a 100 times a
[1:47] day for all kinds of things. And I think
[1:49] it's safe to say it is the hottest and
[1:51] most exciting new AI product in the
[1:54] world right now. Roman leads product for
[1:55] Grockbot. He's been part of the core
[1:57] team from early prototype until today.
[2:00] And we get [music] into how it all
[2:01] started, where it's all going, and all
[2:03] the things that he and his team have
[2:04] learned since it launched just a few
[2:06] weeks ago. With that, I bring you Roman
[2:08] Ugarte.
[2:12] Roman, thank you so much for being here
[2:14] and welcome to the podcast. Thank you.
[2:17] It is great to be here. I am so excited
[2:20] to have you here. I am so hooked on
[2:22] Grockbot. I have it over here in my
[2:24] window. I have like 15 bots that I use
[2:26] every day, all the time. Uh I went to a
[2:29] meetup the other day, a Grockbot meetup.
[2:31] There were hundreds of people there.
[2:33] Standing room only. People sharing all
[2:36] the ways they're using Grockbot. It's
[2:39] very clear to me that you guys have
[2:41] built something very special. It's very
[2:44] hard to break through the noise in the
[2:47] AI world. Uh Grockpot is the hottest AI
[2:49] product in the world right now. That is
[2:52] a very high bar. There's a lot of
[2:54] competition for that slot. I personally
[2:56] noticed I've moved a lot of my use cases
[2:58] from co-work and codeex into Grockpot
[3:01] just like just like very quickly which
[3:04] again feels like a really big deal and a
[3:06] very special moment. Uh and so I'm
[3:08] excited to talk about so many things. I
[3:10] want to understand how you guys did
[3:11] this, where this came from. Uh, where
[3:12] this is going, what you've learned about
[3:15] the journey so far. Um, first, nice job.
[3:18] Nice, nice work. This is very hard what
[3:20] you've done.
[3:21] >> Thank you. I mean, I remember onboarding
[3:24] you uh by hand about a month ago, and I
[3:27] think you were skeptical at first. Uh,
[3:29] but we're very glad that you've been
[3:31] using it, and it's been great to see so
[3:33] many people um really take advantage of
[3:35] Grockpot.
[3:36] >> I'm going to talk about that onboarding.
[3:37] Uh that was a very interesting uh
[3:39] element of how this worked. Uh I
[3:41] actually remember in that onboarding I
[3:43] tried to you asked me to do like a let's
[3:45] try something and I was like okay try to
[3:47] come up with a tweet to promote my
[3:48] latest podcast episode. So I'm just like
[3:51] uh come up with a tweet to promote my
[3:53] last episode. That's it. And it was
[3:55] actually very good. It figured out what
[3:57] the hell last episode was how to promote
[3:59] it. So I actually remember in the moment
[4:01] being like wow this is really good. So
[4:03] let's actually start with origin story.
[4:05] Where did it start? What was kind of the
[4:07] original idea and when did the work on
[4:10] this begin?
[4:12] >> Yeah, it started
[4:15] really as a blank page completely from
[4:19] scratch build from zero exercise where I
[4:23] think we'd been feeling for a long time
[4:24] that we wanted to build something that
[4:27] wasn't just a great product for
[4:29] developers and engineers, which is
[4:32] really where we started. And I think
[4:33] we've gained a lot of intuition about
[4:35] how to build great agents and useful
[4:36] products that way. Uh but what would
[4:39] that product look like for knowledge
[4:41] work? And
[4:44] we decided to kind of create this very
[4:47] small team internally. It was really
[4:48] just a handful of people uh to go off
[4:50] into a cave for about for about a month
[4:53] with the sole objective of build an
[4:55] amazing knowledge work product that
[4:58] brings agents to the rest of the
[5:00] company. And I think from the first line
[5:03] of code to when we released this
[5:05] prototype internally, it was only about
[5:07] a month. It was like a very quick um you
[5:09] know scrappy prototype that was pulled
[5:11] together. And I think in hindsight this
[5:14] would not have been possible if it had
[5:15] been I think a much bigger group. I
[5:18] think it took a small focused group that
[5:21] was completely isolated from the rest of
[5:23] the company. And I mean that literally.
[5:24] It was like a separate part of the
[5:25] office where this team sat. Um private
[5:28] Slack channels. And the goal, and I
[5:31] think in hindsight, it was a lot of what
[5:32] allowed us to move so quickly on this,
[5:35] was we needed to make a lot of micro
[5:37] decisions every day. Uh some things that
[5:40] maybe we'll talk about a bit later that
[5:41] were not obvious, were not really things
[5:43] that we'd done on other product surfaces
[5:46] before. And I think if it had been a
[5:48] very big group of people and we were
[5:49] kind of thinking about this 6 to 12
[5:52] monthlong vision, we just wouldn't have
[5:54] really gotten to the place that we ended
[5:56] up landing at. And so that was about a
[5:58] month from first line of code to here's
[6:01] a functional useful product that the
[6:03] core team is excited about. So then
[6:05] there was a moment of rolling this out
[6:07] across the company rolling this out
[6:09] across all the space act. Uh and so
[6:11] there was an all hands where we kind of
[6:14] shared the progress that had been made
[6:15] so far. There's this brand new product.
[6:17] We would love for you to use it. And I
[6:20] think what was most encouraging because
[6:22] at that point we were excited about it.
[6:25] I think we were using it constantly, but
[6:26] it's easy to use the thing that you
[6:28] built and you kind of understand the
[6:29] mechanics and what it's good for. And so
[6:31] this was a real pressure test with
[6:34] reality, like are people actually going
[6:35] to switch from other internal tools,
[6:38] other external tools to use Grockbot as
[6:41] their primary agent surface? Um, and in
[6:44] that first week after that all hands,
[6:47] um, I mean, I can't even tell you just
[6:49] the outcore of of love for Grogbot from
[6:53] people that maybe you wouldn't expect or
[6:54] from groups of the company that maybe
[6:56] you wouldn't expect. Uh, people who, you
[6:58] know, were daily driving Cheshy PT or
[7:00] like a chat interface switching all of
[7:03] their, you know, day-to-day agentic
[7:06] tasks over to Grockbot as like their
[7:08] primary surface for doing work. And so
[7:10] the internal reception was was really
[7:12] extraordinary. um can tell some kind of
[7:15] funny stories from that that week or two
[7:17] period. Um and then once we saw I think
[7:19] the internal reception, we immediately
[7:21] switched into let's get this ready for
[7:23] the world. There's a lot of work to do
[7:24] to scale this out to millions of users.
[7:26] Uh and then that led to the the GA
[7:29] launch that we had a few weeks ago. This
[7:31] episode is brought to you by our
[7:33] season's presenting sponsor, Work OS.
[7:36] What do OpenAI, Anthropic, Cursor,
[7:38] Replet, Sierra, Clay, and hundreds of
[7:41] other winning companies all have in
[7:42] common? They are all powered by work OS.
[7:45] If you're building a product for the
[7:47] enterprise, you've felt the pain of
[7:48] integrating single signon, skim,
[7:51] arbback, audit, logs, and other features
[7:53] required by large companies. Work OS
[7:56] turns those deal blockers into drop-in
[7:58] APIs with a modern developer platform
[8:00] built specifically for B2B SAS.
[8:02] Literally every startup that I'm an
[8:04] investor in that starts to expand up
[8:06] market ends up working with Work OS. And
[8:09] that's because they are the best.
[8:10] Whether you are seedstage startup trying
[8:12] to land your first enterprise customer
[8:14] or a unicorn expanding globally, work OS
[8:17] is the fastest path to becoming
[8:18] enterprise ready and unblocking growth.
[8:21] It's essentially Stripe for enterprise
[8:23] features. Visit works.com to get started
[8:25] or just hit up their Slack where they
[8:27] have [music] actual engineers waiting to
[8:29] answer your questions. Work OS allows
[8:31] you to build faster with delightful
[8:33] APIs, comprehensive docs, and a smooth
[8:35] developer experience. Go to works.com to
[8:38] make your app enterprise ready today.
[8:41] Okay, so many questions. One that is
[8:44] really interesting here. So obviously
[8:46] there's anthropic openai. They went from
[8:48] they had this coding agent that they're
[8:50] like, "Holy this is a big
[8:51] opportunity." And then they're like,
[8:53] "Okay, people are using this for
[8:54] knowledge work. Let's build a knowledge
[8:55] work component." So there's co-work
[8:58] evolved out of that within the product
[9:00] and then codeex they've invested in
[9:02] let's make this useful for all kinds of
[9:04] things. Interestingly, you guys decided,
[9:07] okay, curs, we're not going to build
[9:09] this into cursor. We're gonna start
[9:11] something fresh. Was that was that just
[9:13] like obvious from the beginning? Okay,
[9:14] this is not going to work inside cursor
[9:16] the product. We need to start fresh. How
[9:18] how like controversial was that
[9:19] decision?
[9:20] >> It was not obvious at all. I think
[9:22] you're completely right that that was
[9:23] one of those original decisions that uh
[9:26] at the time we had a lot of discussions
[9:27] about and I'm very glad with where we
[9:29] landed and I think to your point it
[9:32] being a brand new product that you
[9:34] control every pixel of the experience
[9:35] and you have this consistent vision
[9:37] about where knowledge work is going and
[9:39] it's all contained in this in this new
[9:40] thing I think has has contributed a lot
[9:43] to the success but there were a lot of
[9:44] discussions about you know cursor for
[9:46] example and some of our coding products
[9:49] people use it for non-coding tasks all
[9:52] the time. Um, and you know, these coding
[9:55] agents are really excellent at some of
[9:56] these things, but you run into small
[9:58] paper cuts. Sometimes the product itself
[10:01] is kind of intimidating to nontechnical
[10:03] users. There's a brand association with
[10:05] these things. And so, I think we
[10:08] evaluated that path and I think we saw
[10:10] what maybe some of our competitors have
[10:12] been doing of this is all just one
[10:14] surface. You add new tabs for each new
[10:16] form factor and it feels a little
[10:19] cluttered and I think for users they can
[10:21] feel that that this was not a single
[10:24] consistent uh vision of the way that
[10:27] work should work and instead it's three
[10:29] different visions that all kind of share
[10:31] a screen and you can hop between but it
[10:33] is kind of a shipping your org chart
[10:35] style thing that I think users are
[10:37] reacting negatively to. And so we
[10:39] decided let's just start completely from
[10:40] scratch. Let's see where we can get from
[10:43] there. There might be some really
[10:44] amazing opportunities to bring people
[10:46] from other surfaces into this more
[10:48] botnative experience, but it's really
[10:50] important for people to just have like
[10:52] an amazingly simple and amazingly
[10:54] powerful experience.
[10:55] >> That is a really valuable lesson for
[10:57] people to take away here just that that
[10:59] is might be the solution instead of
[11:01] adding in complicated and existing AI
[11:03] product. So interestingly, Codex went
[11:05] the other direction and and it's like a
[11:08] different path and a different product,
[11:09] but it's interestingly they're like now
[11:10] we're going to make it one thing. So
[11:12] there, you know, there's many ways to
[11:13] make it work and it also feels like the
[11:15] path you take there will kind of lead
[11:17] you but maybe maybe we'll look back and
[11:19] be like that was not maybe the best
[11:20] idea. Something you mentioned that you
[11:22] did that is also really unique is this
[11:24] onboarding of early users. Uh I heard
[11:27] you and your team onboarded two to 300
[11:30] people manually including me. Uh talk
[11:33] about why you thought that was necessary
[11:35] and what you learned from that
[11:37] experience and just like how long that
[11:39] period was of this kind of manual
[11:40] onboarding. I mean, you just learned so
[11:42] much and um the first few onboardings
[11:46] were pretty painful. I'm glad you got a
[11:48] good one, Lenny. [laughter]
[11:50] Uh but there were some that were kind of
[11:51] rough and we learned a lot and I think
[11:53] it was important for the core team to be
[11:56] in the room for those and to just sit on
[11:59] a call for 20 minutes when the computer
[12:01] isn't spinning up or when someone's in
[12:03] onboarding and they're just incredibly
[12:04] confused. So that immediately after
[12:06] you're like that can never happen again.
[12:08] we need to solve this tomorrow because
[12:10] tomorrow I'm onboarding this person and
[12:12] it needs to go better. And so there was
[12:14] about a two-week period uh where we were
[12:17] in that mode and onboarded a couple
[12:18] hundred people. Um and not only did we
[12:21] learn a lot about the product, I think
[12:23] we didn't really know uh I think
[12:26] sometimes with these products there's
[12:27] some group think of ways to use them.
[12:30] And I think internally because people
[12:33] inside of SpaceX were just constantly
[12:35] sharing tips and tricks for how to use
[12:37] Grockbot, some patterns were starting to
[12:39] emerge that we thought would be useful
[12:41] to the world, but we weren't really sure
[12:43] and we definitely didn't want to bias
[12:45] the world. Is there an example of that?
[12:47] So when we rolled out Grockbot
[12:49] internally, there was about a week or
[12:52] two where the common pattern of the way
[12:54] people would interact with the product
[12:56] was you would have five to 10 bots and
[12:58] each bot you would give a different
[13:00] scope, different domain and it was kind
[13:02] of shortorthhand for different lanes of
[13:03] work. And then around the end of week
[13:06] two, we started to see these messages
[13:08] internally in Slack of people promoting
[13:11] one of their bots who is a bit of a
[13:13] standout performer. and it was like
[13:15] their kind of primary personal assistant
[13:18] promoting that to their chief of staff.
[13:20] And then they would actually mostly talk
[13:22] to their chief of staff. And the chief
[13:23] of staff would fan out all of these
[13:25] tasks to the other bots and would kind
[13:28] of manage the team. And there are some
[13:31] funny screenshots of people like
[13:32] actually telling their uh you know the
[13:35] bot they're promoting that they're
[13:36] they're promoted and the bot is asking
[13:37] if they get a raise and you know is
[13:39] their token budget higher all of these
[13:41] things. Um, and we kind of took note of
[13:43] that and I think more of the companies
[13:44] started to slightly shift in that
[13:46] direction, but it was not the majority
[13:47] of the company. People use this product
[13:49] in very different ways. And so in some
[13:51] of the onboarding sessions and just from
[13:53] the early access program in general, we
[13:55] really did not want to lead the witness
[13:56] and say, you know, create a chief of
[13:58] staff bot. Here's exactly the way that
[14:01] uh, you know, that chief of staff should
[14:02] manage all of the other bots and see if
[14:05] early access users would get there
[14:07] themselves. And we actually did see that
[14:09] many of them did. And so then we had a
[14:10] bit more of an opinionated take in the
[14:12] product of this feels like a pattern
[14:14] that's working. This feels like a
[14:15] pattern that we should slightly
[14:17] encourage, but it shouldn't be a one-way
[14:19] door. And there were a few other
[14:20] examples of internal thesis that we
[14:23] really wanted to make sure, you know,
[14:25] would bear out in actual external usage
[14:27] without us imposing that in the product.
[14:30] >> Is there anything else there? Any uh
[14:31] examples come to mind? Yeah, I think
[14:33] another thing we really tried to pay
[14:36] attention to in the early onboardings
[14:39] um was just how much users wanted to
[14:42] see. And I think it is something a bit
[14:46] shocking or just different about
[14:48] Grockbot when you first start using it
[14:50] versus some of the other products that
[14:52] you mentioned. um where a lot of the
[14:55] internal mechanics of how Grockbot works
[14:58] are not shown to the user. And the
[15:02] reason for that is we think as these
[15:04] models get smarter, the same way that
[15:06] your teammate, you know, you wouldn't
[15:08] ask for second by- second updates of
[15:10] exactly all the buttons they're pressing
[15:11] and websites they're going to, I think
[15:14] it's too much to ask your bots to do
[15:16] that, too. And I think it's honestly
[15:17] just overwhelming uh and can create more
[15:19] harm than good. And so we moved
[15:21] completely in the other direction of you
[15:24] send a message, you tell your bot to do
[15:26] something, it just starts doing it. It
[15:28] sends you progressive updates as it sees
[15:30] fit. And you just see that like typing
[15:32] indicator in the little green, you know,
[15:35] active uh active um circle kind of Slack
[15:39] like that it's it's active, it's doing
[15:41] work, it'll get back to you soon. But
[15:43] you don't see the internal mechanics,
[15:44] you don't see the tool calls, you don't
[15:46] see exactly every little click it's
[15:48] making on its own computer. And we
[15:50] really wanted to take a strong stance
[15:52] that users did not need to see all of
[15:54] those mechanics. And so that's where we
[15:56] started. And we did get some feedback
[15:58] that's like, I would love to see my
[15:59] bot's to-do list. I would love to see
[16:01] roughly how it's prioritizing tasks and
[16:03] what it's doing. And that's great
[16:04] feedback. But it was useful to hear that
[16:07] nobody wanted the like long stream of
[16:10] just text streaming out and chain of
[16:12] thought sequences. So that also gave us
[16:14] more uh confirmation that that was the
[16:16] right direction. the fact that you did
[16:18] two to 300 onboarding calls on a with a
[16:20] small team. I knew that I know the team
[16:22] grew uh over time, but just that is a
[16:25] huge time commitment and then you could
[16:27] argue a distraction from the building.
[16:29] Clearly not a distraction, clearly a
[16:31] core part of the success. Uh do you feel
[16:34] like that's like that's the volume
[16:35] people need to do to figure out what
[16:39] actually needs to happen? Well, one
[16:41] thing to emphasize is the early access
[16:43] group is not necessarily just people
[16:48] that are highly influential taste
[16:51] makers. you know, you're in this
[16:52] category, Lenny, and we certainly wanted
[16:54] to get a lot of your feedback um just
[16:57] from being very close to many other
[16:59] products on the market and just being a
[17:01] power user of these things, but we also
[17:02] wanted to get uh early access to kind of
[17:06] more unconventional profiles that we as
[17:08] a company had never really interacted
[17:10] with. So one example is uh there's a
[17:12] coffee shop owner that was a friend of a
[17:15] friend through the company who had heard
[17:17] about Grockbot and you know uh one day
[17:19] somebody on the core team had kind of
[17:21] shown them a demo of the test flight and
[17:23] got very excited and this coffee shop
[17:26] owner ended up being not only an
[17:28] amazingly uh an amazing power user of
[17:31] Grodbot but also a rich source of
[17:33] feedback for us. uh we have a very
[17:36] lively thread with with many many uh
[17:38] bugs that get identified or feature
[17:40] requests and it's a completely different
[17:41] use case of running a small business and
[17:44] so for example if you know the Shopify
[17:47] uh integration was a bit flaky or if it
[17:50] wasn't writing copy uh for products in
[17:52] in a particular way we would get really
[17:55] rich feedback on that which is pretty
[17:56] different from the type of feedback we'd
[17:58] get from dog fooding this internally and
[18:00] so I think it was an important exercise
[18:02] for us to check our blind spots and say
[18:04] a this is going to be a very general
[18:07] product that is not just a thing that
[18:09] developers use. In fact, it is likely
[18:11] that this is most powerful for
[18:13] non-developers. We need to understand
[18:15] that group much better. And then B is we
[18:17] absolutely live in this kind of Silicon
[18:20] Valley AI bubble. Uh which I think is is
[18:22] a useful place to be to kind of push the
[18:24] the frontier and push the future of of
[18:26] how these products are evolving. But we
[18:28] need to actively get out of that because
[18:30] I think a product like this has the
[18:32] chance of really being the way that the
[18:34] mainstream user [clears throat] and the
[18:35] mainstream uh kind of business customer
[18:38] can interact with AI in a way that's
[18:40] useful.
[18:41] >> Let's go back to the timelines real
[18:42] quick just to kind of understand that.
[18:45] So it was a month from first line of
[18:46] code to internal beta and then what
[18:49] happened after that? It was about three
[18:51] weeks from internal beta to public
[18:54] launch and then I think we're about
[18:56] three weeks out from public launch as of
[18:59] recording this. Wow. Okay. So, month of
[19:02] building the first thing, three weeks
[19:04] only of iterating and that and then it's
[19:07] been only three weeks since launch. It
[19:09] feels like it's it changed the world in
[19:11] my from my vantage point. So, wow. Okay.
[19:15] What most changed in those I don't know
[19:18] in those three weeks of internal beta,
[19:20] let's say. We unshipped a lot. Um, I
[19:27] wish I could have shown you what things
[19:29] looked like maybe two weeks out from
[19:32] launch where I think we'd realized that
[19:35] the core team, we had a lot of
[19:37] experimental features that we wanted to
[19:39] get internal feedback on uh, which was
[19:41] useful. We also were kind of putting
[19:44] pseudo developery
[19:46] like visibility tools into Grockbot
[19:49] instead of having like a separate
[19:51] observability pane uh for those things.
[19:54] So for example, we actually did expose
[19:56] sometimes a lot of the internal thinking
[19:58] of the models and the specific memories
[20:00] it would store and all of these things
[20:02] uh which was useful to debug issues and
[20:04] if you're building the product, you
[20:05] didn't want to go somewhere else to
[20:07] maybe pull that context. But we had to
[20:09] really aggressively trim what we think
[20:11] the user absolutely needs to see in the
[20:14] surface versus what they don't. I think
[20:16] there's even more room uh there to run
[20:18] which is something the team's focused on
[20:19] right now is how can we just ruthlessly
[20:22] simplify this product and abstract away
[20:25] anything the user doesn't need to
[20:26] actively be thinking about. Uh so that
[20:28] was one big push uh was unhip a lot of a
[20:32] lot of jank. Um, and then I think the
[20:35] second big push those few weeks was
[20:38] making it just work. And I think a lot
[20:42] of what people want from AI is not this
[20:45] thing with lots of drop- down menus and
[20:47] bells and whistles, but just a thing
[20:49] that you describe a task, a task that's
[20:52] meaningful to you and it goes and it
[20:54] does it and it comes back with complete
[20:56] work or it comes back with something for
[20:58] you to react to and then steer it in its
[21:00] kind of next cycle. Um, and so in order
[21:03] to actually deliver on that promise,
[21:05] it's actually not a lot of feature
[21:08] product roadmap style stuff, it's like
[21:11] hill climbing five really important
[21:13] problems in the back end that many users
[21:16] don't directly experience, but you
[21:17] totally feel uh when you know your bot
[21:20] is going off and doing something and
[21:23] can't click the right button or your bot
[21:25] is off and doing something and can't log
[21:26] into a website and it just completely
[21:29] stalls your your ability to make
[21:30] progress on that task. And so those few
[21:32] weeks we collected a really rich set of
[21:34] what are tasks that people actually are
[21:36] giving bot how can we quantify these
[21:39] things and how can we see week over week
[21:41] that across those categories of tasks
[21:43] that were hill climbing on very
[21:45] important dimensions to making that just
[21:46] work behind the scenes.
[21:48] >> Is there an example one of those uh
[21:49] hills you were climbing that was kind of
[21:51] a technical breakthrough or technical
[21:53] challenge you overcame that really
[21:54] helped it just work? Yeah, one example
[21:57] was
[21:59] from rolling out Grockbot. One group
[22:01] inside of the company that was actually
[22:04] incredibly botpilled, so to speak, um
[22:07] was our go to market team was sales. And
[22:10] there are a bunch of tools that sales
[22:13] uses um that do not have wellsupported
[22:16] MCPs or APIs. And I think that's a lot
[22:19] of what made bot so before and after
[22:21] powerful for this group was these were
[22:23] things that they just could not give
[22:25] another AI tool reliably. We would get
[22:28] stuck at some part in the process. Then
[22:30] bot kind of felt like they had an
[22:33] assistant or kind of felt like they
[22:34] onboarded someone to their personal
[22:36] team. They gave it a laptop and it could
[22:38] just run. And so there were a bunch of
[22:42] small things and you know probably a
[22:44] list of of 10 or 20 of them of places
[22:46] where for whatever reason you know the
[22:49] mouse would just not have fine enough
[22:51] control to click on exactly that part of
[22:54] the Salesforce dashboard or something
[22:56] like that um that we would have to take
[22:58] back to the the core team working on
[23:00] really the infrastructure to say here's
[23:02] a very concrete case of where uh the
[23:05] agent not having this visibility into
[23:08] the browser or this visibility into the
[23:10] pixels on the screen is making it
[23:12] impossible for this task to be done. And
[23:14] that was just a lot more tangible than
[23:17] seeing a number on a dashboard slowly
[23:19] creep up. It was kind of like new chunks
[23:21] of work getting unlocked and you would
[23:24] immediately feel the feedback where you
[23:25] would ship an improvement uh that was
[23:27] kind of behind the scenes kind of
[23:29] infrastructury and then the next day you
[23:31] would just get this outpour of you know
[23:33] love and appreciation from the sales
[23:35] team that now this workflow that was
[23:37] failing the last seven days finally
[23:39] works and it's just a constant exercise
[23:41] of finding those next tasks to unlock
[23:44] and then solving them. So, computer use
[23:46] uh basically uh improvements seems like
[23:49] a big unlock. Uh I heard also the um I
[23:52] had Adam Ward on the podcast uh who's
[23:54] head of recruiting, head of hiring,
[23:55] basically head of talent. Uh I heard his
[23:57] team was like one of the top users of of
[24:00] uh Grockbot. Yes, the recruiting team um
[24:03] gave us a lot of great feedback. Anytime
[24:05] the product, especially in the early
[24:07] days, if there was a little bug, we'd
[24:08] get a get a ping from um some folks on
[24:11] the recruiting team. Um yeah, I think
[24:13] the main use cases for recruiting that
[24:16] were particularly interesting uh was
[24:19] first it was incredibly valuable as a
[24:21] sourcing tool and I think one thing Adam
[24:24] talked about on the podcast with you uh
[24:27] and it's a big part of our hiring
[24:28] philosophy internally is be looking for
[24:32] a job being on the market is not a
[24:34] precondition for us trying to hire you.
[24:37] [laughter]
[24:38] And in a lot of ways, um, you know, the
[24:40] best way to hire is really just look at
[24:42] the biggest problems at the company that
[24:45] needs someone to to own it or take it to
[24:48] the next level. Find out of the total
[24:50] universe of people in the world who
[24:52] would be best and then ruthlessly go
[24:55] after them and try to convince them to
[24:57] join. And this is a lot of the
[24:58] philosophy from the very beginning of
[24:59] the company. And so if that's your
[25:01] mindset, really the best recruiting work
[25:04] stream is not or workflows to automate
[25:06] are not, you know, here are a bunch of
[25:08] resumes, read through them, help sort
[25:10] them. The most useful thing is here's an
[25:13] entire universe of potential people.
[25:16] Help match that to this very concrete
[25:18] business problem or this very concrete
[25:20] role that we're recruiting for and help
[25:22] me get in touch with them. Help me get
[25:24] coffee with them. Let's just throw
[25:25] everything at it. And so there have been
[25:27] some cases of um really
[25:31] kind of uh unexpected ways of finding
[25:34] top talent that is is beyond even just
[25:37] you know looking on LinkedIn and trying
[25:39] to find uh interesting people. But who
[25:42] are the co-authors of this paper and the
[25:44] PDF doesn't exist on Google Scholar. It
[25:47] just exists on this conference website.
[25:49] I want you every morning to go to the
[25:52] conference website, download the PDFs.
[25:54] there are any new ones. You should find
[25:56] every new name that we've not yet
[25:58] tracked. You should add that name to a
[26:00] spreadsheet. You should do research. You
[26:02] should look at everybody at SpaceX, see
[26:04] if there's anyone directly connected. If
[26:06] so, you should send them a Slack message
[26:08] asking for an introduction. Like, it's
[26:10] those types of always on sourcing um use
[26:15] cases that I think in the past were
[26:17] incredibly manual and now it's the type
[26:20] of thing AI is superhuman at. and our
[26:22] team can focus on closing great
[26:23] candidates and getting conversations
[26:24] with great candidates and not pulling
[26:26] these huge lists.
[26:28] >> Wow, that is such a cool example. Uh,
[26:30] first of all, someone's about to take
[26:31] the transcript of what you just said,
[26:32] put it into a bot, and create their
[26:34] version of this, which is great. On on
[26:36] the other hand, I think you guys could
[26:37] sell a template of this bot for a
[26:39] billion dollars. If we could basically
[26:41] use Adam's uh team strategy for finding
[26:45] the best people and just turn it into a
[26:46] bot, holy moly, democratizing uh hiring.
[26:50] I want to come back to a few things.
[26:51] Okay. So, one is you made this point
[26:53] about unshipping.
[26:55] Such a important point I think that
[26:58] people can overlook because AI is not
[27:01] good at telling you what to take out.
[27:06] It's very good at okay, here's more more
[27:07] ideas, here's more stuff. And something
[27:10] that's come up a number of times on the
[27:11] podcast is that's a big opportunity.
[27:13] That's a big space for humans to
[27:15] continue to be very important and
[27:17] valuable is knowing what not to ship and
[27:20] what to cut and what not to do. And so
[27:23] it's so interesting to hear that that's
[27:25] been a big part of the internal
[27:27] evolution of from prototype to launch is
[27:30] deciding okay we need to cut a bunch of
[27:32] stuff. Anything more there?
[27:34] >> Yeah. So, one thing we talk about
[27:37] internally is for anything that we're
[27:39] working on for Grockbot,
[27:42] what is the launch post? Like, what is
[27:43] the thing that we would actually tell
[27:45] users? And if it's not tweet, I imagine
[27:48] >> launch tweet. And if it's not
[27:50] compelling, maybe we shouldn't be
[27:51] working on it. um if if it's not
[27:53] something that users will directly feel
[27:55] in the product and to take that even one
[27:57] step further um I think there is this
[28:00] old school software tendency to say
[28:04] things like Grockbot now has and when
[28:08] you think of completing that sentence it
[28:10] would be like a new button to press or
[28:12] it' be a new drop down or it' be a new
[28:15] integration that you can press plus and
[28:17] add and instead to reframe it as
[28:19] Grockbot can now which is is I a much
[28:22] more human way of kind of describing
[28:24] these capabilities. And I think it's
[28:26] forced us to think more in the frame of
[28:29] what are tools and and what are
[28:31] capabilities that we can give Grockbot,
[28:33] not what are new things we can add to
[28:35] the product. Like adding things to the
[28:37] product is not the goal. That's not the
[28:39] thing that's going to push this this
[28:40] product forward and make it more useful
[28:42] to more people. making your bots
[28:44] reliably do really impactful work for
[28:47] you behind the scenes in a way that just
[28:49] works and giving them the capabilities
[28:51] to do that. Like that's what users
[28:53] actually care about. Uh and so I think
[28:55] in the context of unshipping there have
[28:57] been a lot of Grockbot now has things uh
[29:01] that we've realized are actually just
[29:02] capabilities that don't need pixels. You
[29:05] know, let's kill as many pixels as we
[29:07] can. Those can just be things that your
[29:09] bot manipulates behind the scenes for
[29:11] you and you don't need to directly
[29:13] control. And I think one example of this
[29:15] is the way that many of our competitors
[29:17] you set up automations or routines is
[29:20] you go into a sidebar, you press plus,
[29:23] you select, you know, what the trigger
[29:25] event is. Uh you then select uh you know
[29:28] what action it should take after that.
[29:30] You might describe it in natural
[29:31] language and it's just really clunky and
[29:33] it means that people don't set up many
[29:35] automations for for many things. We
[29:37] certainly have seen this in in the
[29:38] coding realm. And so I think what
[29:40] Grockbot did in response to that was
[29:42] actually you should just define
[29:44] automations in natural language. You
[29:45] should tell your bot, remind me that at
[29:47] 8 a.m. every day, please. And then it
[29:49] should just do it. And you should never
[29:50] ever have to see that interface of
[29:53] creating an automation. And so that's
[29:54] kind of the decision that that we've
[29:56] made. And now that's how 99% of
[29:58] automations on the platform get built.
[30:00] And I think there are a bunch of other
[30:01] places where we can do things like that.
[30:03] So, I tweeted about how much I love
[30:05] Grockbot when it launched and a lot of
[30:06] people replied. They're like, "Wait,
[30:08] can't you just do all this with codecs
[30:09] and co-work and you can technically
[30:12] everything as far as I know you can do
[30:14] with Grockbot you can do with the other
[30:17] foundational models, the coding
[30:18] assistants. So, let me just ask you this
[30:20] big question. What is it that you think
[30:22] you did that is so different that
[30:25] allowed that made Grockbot so
[30:27] successful?" I think it was two early
[30:30] decisions that at the time definitely
[30:34] did not feel obvious, but in hindsight I
[30:37] think are critical to what makes
[30:38] Grockbot work for people. And the first
[30:42] is you should never have to think about
[30:45] local and cloud and where are these
[30:48] workflows running? Does my computer have
[30:51] to be awake? If I kick it off from my
[30:53] phone, does it need to be tethered to my
[30:55] computer back at home? Like there's so
[30:57] much jank happening right now when
[30:59] people are trying to conceptualize where
[31:02] this runtime lives. And we made a really
[31:05] early decision that this should just all
[31:07] be in the cloud. And if it's in the
[31:09] cloud and it's this persistent colleague
[31:11] that has its own computer, it can do its
[31:14] own work. It has the same state
[31:16] everywhere you interact with it. It
[31:18] opens up a lot of really amazing
[31:20] opportunities to text your bot, kick it
[31:23] off from your phone. in the future, you
[31:25] should be able to call your bot from
[31:26] anywhere and it should be able to do
[31:28] real work. Like this is its own entity
[31:30] and it lives separately from your
[31:32] device. And I think that was a very
[31:34] important decision that current products
[31:36] uh I think haven't made that same
[31:38] decision and I think it it has a bunch
[31:40] of paper cuts as a result of it that
[31:42] users feel every day. I think the second
[31:44] decision was kind of to take that one
[31:47] step further of not only should this be
[31:50] an agent loop that kind of runs in the
[31:52] cloud and you can interact with in
[31:54] various ways. It's actually really
[31:56] important that these bots have their own
[31:57] computer and part of it is what I
[32:00] described earlier of there are a bunch
[32:02] of tasks that don't have wellsupported
[32:04] MCPS and APIs. We as humans don't do our
[32:08] jobs via MCPS and APIs. Like we use a
[32:11] computer and we click on pixels and we
[32:13] kind of type things in input boxes. And
[32:16] it's very important that your bot has
[32:17] those baseline capabilities as well. Uh,
[32:20] but even to go one step further, I think
[32:22] we're in a really weird moment right now
[32:24] that I think we're going to look back on
[32:26] and be like, I'm surprised that this is
[32:28] the way that a lot of people worked with
[32:29] AI where you're onboarding these super
[32:32] intelligent new colleagues, these AI
[32:34] bots and you're asking them to share the
[32:37] same computer that you have. It's crazy.
[32:39] Like, if you were onboarding someone to
[32:41] your team and you said, "It's your first
[32:43] day. I'm going to onboard you. Uh, you
[32:45] don't have your own laptop. You're going
[32:47] to sit next to me. we're going to share
[32:48] this laptop forever and constantly trip
[32:51] over each other. You're going to have
[32:52] access to my credentials. I'm going to
[32:54] have access to your credentials. Like
[32:55] that's just there's a good reason why
[32:58] that's not the way people operate. And I
[33:00] think bots and these kind of AI
[33:01] colleagues of the future will also need
[33:04] um you know a way to onboard them that's
[33:06] that's somewhat similar. And we've tried
[33:08] to push the product in that direction.
[33:10] >> That is so funny. [laughter]
[33:12] Um why do you think the other companies
[33:14] didn't do this? My guess is they were
[33:18] building off of their existing coding
[33:19] assistant platform and approach and this
[33:22] was like a pretty big shift. I think a
[33:24] lot of it comes down to
[33:27] starting from scratch and how freeing
[33:30] that is and we felt that ourselves where
[33:33] a lot of the primitives in Grockbot we
[33:36] had attempted or we had built in other
[33:39] ways. Um you know cloud infrastructure
[33:42] we built for coding agents. um the way
[33:45] that you could maybe name agents and
[33:47] talk to them as discrete entities. It's
[33:49] a pattern that we're also seeing for
[33:51] developers uh kind of bringing specific
[33:54] named agents into Slack. But instead of
[33:57] kind of trying to retrofit those
[33:59] concepts into some new surface or into
[34:02] an existing surface, which I think would
[34:04] have been the strong default I think for
[34:06] many companies, we decided to start from
[34:08] scratch. We decided to just try to get
[34:10] these things really right for [snorts]
[34:13] general knowledge work which is a new
[34:15] audience and then second for the point
[34:17] in time that we're at now where the
[34:19] models are very capable and if you give
[34:20] them the right tools and the right
[34:21] infrastructure they can do a lot but a
[34:24] lot of these ideas these aren't strokes
[34:26] of genius on our part and I I think for
[34:28] good reason I think these are primitives
[34:31] that had already been getting attention
[34:33] and product market fit by other products
[34:35] you know the open clause of the world um
[34:38] and I think we took a lot of inspiration
[34:39] from that and tried to productize it
[34:41] into a bit of a tighter surface,
[34:43] something that required a little bit
[34:44] less setup and I think was more
[34:46] accessible to more people. And so I
[34:48] think our competitors and other tools
[34:51] that have been trying to solve these
[34:53] types of problems, I think we're all
[34:55] seeing the same opportunity. I think
[34:57] we're seeing a lot of those the feedback
[34:59] from the market, but I think it's just
[35:00] been hard to act on if you're stuck in
[35:04] the existing paradigm and if you have a
[35:06] lot of kind of sunk cost in that
[35:08] existing paradigm, it's very painful to
[35:10] create a new thing from scratch. Uh, and
[35:12] I think a lot of that is what allowed
[35:14] the product to just work and click for
[35:16] so many people. So what I'm hearing here
[35:17] is the keys to success of what made this
[35:20] break out. A cloudbased
[35:23] computer for every uh bot instead of
[35:26] locally. Uh a name kind of like specific
[35:29] bot. And by the way, there's this like
[35:31] we're all moving from agents to bots
[35:32] now. Nice job. Like
[35:35] feels like you guys have pushed the
[35:36] pushed it over now. Okay, we're all bots
[35:38] now. So a bot per kind of task use case
[35:41] very unique versus like a thread
[35:42] conversation or something or like a
[35:44] one-off job. And then it feels like
[35:46] there's it just works was a core part of
[35:49] this and you talked about how long it
[35:51] took to get to that place of like okay
[35:52] now it actually works really well. Um
[35:56] you mentioned OpenClaw obviously this is
[35:59] inspired by that which to me when I
[36:01] first used open claw I'm like holy
[36:03] this is the future how could we not have
[36:07] this and then the Hermes came out and
[36:09] everyone's been trying to build the open
[36:11] cloud that works very easily for
[36:13] everybody. Can you say more about just
[36:15] like how OpenClaw and that story
[36:18] informed the way you guys thought about
[36:19] it?
[36:20] >> Yeah, so I think OpenClaw got two major
[36:23] things right that when we were seeing
[36:25] the way the market was reacting to
[36:27] OpenClaw and ourselves using the product
[36:30] we found quite exciting. I think the
[36:32] first thing was the models are really
[36:35] smart and they're going to continue to
[36:36] get smarter, but even at current
[36:38] capability levels, if you can just give
[36:41] your bot access to the tools that you do
[36:46] that you use to do your job, um it can
[36:49] get a lot of the way there in a lot of
[36:50] the places where people think AI is is
[36:53] dumb or uh maybe not as impactful um as
[36:56] it's been promised. A lot of that I
[36:58] think is downstream of it's just being
[37:00] harnessed in the wrong way. And so if
[37:02] you kind of give access to a much larger
[37:05] set of things, if it has access to its
[37:06] own computer, how far can you go? And I
[37:09] think OpenClaw, you know, really kind of
[37:11] forced that question for many people.
[37:13] And then I think the second way open
[37:15] claw changed the mental model of of AI
[37:18] uh was really viewing these things much
[37:20] more as colleagues and teammates and
[37:22] people and personifying it a bit more
[37:25] and it being this helper entity that has
[37:29] access to your life and can kind of
[37:31] extend you even further. And so we took
[37:34] a lot of that and I think what Grockbot
[37:37] maybe extended was a it needs to be
[37:41] really easy to set up and the hacky you
[37:45] know you have a VPN at home and a Mac
[37:48] mini setup clearly was not going to
[37:50] scale to millions of users clearly is
[37:52] not going to be the way importantly that
[37:54] businesses take advantage of this
[37:56] technology and so we really wanted to
[37:58] build an amazing product with that in
[38:00] mind and then second is I think there
[38:02] are a lot
[38:03] places, a lot of rough edges to sand
[38:06] down and just make a delightful product
[38:07] experience and make these things just
[38:09] work and try to remove some of the
[38:12] abstractions that power users of AI are
[38:15] very familiar with things like skills
[38:17] for example. Um, how can we make a
[38:19] Grockbot user not even have to know what
[38:21] a skill is? They should never have to
[38:23] type a slash command. these things
[38:25] should be created in the background as a
[38:27] useful primitive that the bots have
[38:29] access to, but something that users, you
[38:31] know, it's not incumbent on them to
[38:33] always be on the on the cutting edge of
[38:34] AI. And so that's really where we tried
[38:37] to to innovate. And I think there's
[38:38] still more room to go there.
[38:40] >> Uh, as you say that, I have my Mac Mini
[38:42] with my formerly alive OpenClaw on
[38:44] there. And, uh, that was an era and, uh,
[38:48] it's so awesome the work that it has
[38:50] inspired. I know it continues. I know
[38:52] there's still a lot of value to open
[38:54] cloud, but when I saw Claire Vo, who's
[38:56] been like the biggest proponent of
[38:57] OpenClaw and has it's like become a core
[39:01] part of the way she lives and works with
[39:03] her kids and does all her work. She just
[39:05] switched all of her open claws. She's
[39:08] shut them all down and switched to
[39:09] Frogbot. That's a huge like it sounds
[39:12] funny, but that's actually a huge uh
[39:15] milestone of just how much things have
[39:17] shifted.
[39:19] Um,
[39:21] what's kind of the the vision for
[39:23] Grockbot? What's like where does this
[39:25] go? What does this look like in the
[39:26] future? What's like the ideal platonic
[39:28] version of Grockbot? The ultimate vision
[39:31] of Grockbot is incredibly simple, which
[39:35] is you should have a team of AI bots
[39:40] that help you with your job and help you
[39:43] with your life. And it should really
[39:45] feel like a team. It should really feel
[39:47] like teammates that are autonomous are
[39:50] helping you. You can steer them in
[39:52] various ways. You don't have to
[39:54] micromanage them. They have access to
[39:56] the tools necessary to do great
[39:59] ambitious work. And one thing we really
[40:03] use as a north star on the product side
[40:05] uh in building this is as we kind of get
[40:08] closer to this teammate future, how can
[40:11] we in every product decision we make
[40:13] think about this less from the
[40:15] perspective of a SAS product and more
[40:18] from the perspective of we're trying to
[40:20] build useful AI teammates. And so there
[40:22] have been a bunch of examples where we
[40:24] kind of have to push ourselves to be
[40:26] more like colleague pill in a way. We
[40:29] sometimes use that term where we're
[40:31] having a product debate about something.
[40:34] There are good arguments on one side.
[40:35] There are good arguments on another
[40:37] side. Both paths feel sensible. Like in
[40:40] product land, this maybe doesn't feel uh
[40:42] like there's a clear-cut answer. And
[40:45] then you zoom out a little bit and you
[40:47] remove yourself from the, you know, tech
[40:49] companiness of it all and you start
[40:51] thinking, how would a human do this?
[40:54] Like what would you want from your
[40:55] teammate in this exact situation? And
[40:59] oftentimes the answer is really
[41:01] clarifying and pretty unanimous. There's
[41:04] oftentimes not a lot of disagreement
[41:05] among the room of like how a human
[41:08] teammate you would prefer to work with
[41:09] in a certain way. And then once that
[41:11] answer is there, well then we just need
[41:13] to build it. And there are product
[41:15] implications, there are model
[41:17] implications, there's a lot of things
[41:18] that need to go right to actually
[41:19] deliver on that experience. But in some
[41:21] ways it's not rocket science. Doesn't
[41:23] require you being a genius. you just
[41:26] need to ask the question of what would
[41:27] you want from a human teammate and can
[41:29] we push AI to behave in a similar way
[41:32] and so to give some examples of that I
[41:34] mean we've been thinking about what the
[41:36] right voice experience with uh these
[41:39] bots should be and I think in the
[41:41] context of a human for example we have a
[41:43] really good analog of a lot of times I'm
[41:46] slacking back and forth with a teammate
[41:47] we're sharing context and a lot of times
[41:49] it's just much simpler to get on a
[41:51] fiveminute huddle with them and just
[41:52] press huddle talk back and forth I share
[41:54] my screen. I show exactly what's on my
[41:56] mind. They share their screen. We hop
[41:58] off and then we continue async from
[42:00] there. And that's not really an
[42:02] experience that any AI product has
[42:04] gotten right right now. And it is deeply
[42:06] integral to the way that I think humans
[42:08] collaborate. And so we want to build
[42:10] something like that. And there are a
[42:11] bunch of other examples of these like
[42:13] very clear patterns that just work uh
[42:16] that I think you should also feel when
[42:18] working with AI.
[42:19] >> I love this term colleague build. uh
[42:21] such and it's come up so many times over
[42:23] the course of this chat already how that
[42:25] is uh kind of a throughine to making
[42:27] these decisions for example the computer
[42:30] example you gave is so good obviously
[42:32] people would have their own computer the
[42:33] naming piece is also a very important
[42:35] part of that a big question on my mind
[42:38] in the space and I'm so curious to get
[42:40] your take is the separation between work
[42:43] and personal do you think people will
[42:45] have two different assistants a work and
[42:47] a personal or do you think it'll be one
[42:49] >> when people think about a work product
[42:52] versus a consumer product. I think
[42:54] there's just a lot of baggage that comes
[42:57] from the last decade or two of horrible
[43:01] B2B software. Um, that leads to people
[43:05] seeing a product that is very simple in
[43:08] some ways. Chat GBT was like this. I
[43:10] think Grockbot has many of these
[43:12] properties and assuming that it's not a
[43:15] work product or assuming that it's not a
[43:17] power tool. And when you think of a
[43:19] power tool in this kind of last
[43:21] generation,
[43:23] I in my head picture something a bit
[43:25] like Photoshop for example, where there
[43:28] are all of these different dials to turn
[43:31] very precisely. You know, the user of
[43:33] the tool is this kind of um you know,
[43:36] ultimate um cockpit flyer who knows
[43:41] exactly what all the knobs do and can
[43:42] like use them perfectly. And I think
[43:45] power tools of the future will actually
[43:48] be very different from that. Uh where it
[43:51] is mostly just intent being expressed
[43:54] and good steering on the part of the
[43:57] human and these AI tools abstract away
[44:00] all of the knobs. you should never see
[44:01] them unless you need to directly
[44:03] manipulate it which might happen and
[44:05] there should be a great affordance for
[44:06] that but ultimately it really is just
[44:09] working with a teammate and so the
[44:11] interface for that is quite
[44:12] conversational and so in a lot of ways
[44:14] Grockbot when you look at it like when I
[44:16] walk by someone's desk and I see
[44:18] Grockbot up on their computer for me for
[44:20] a split second I'm like oh are they on
[44:22] like a messaging app and it's like no
[44:23] they're you know this is actually the
[44:25] primary tool that they're using to do
[44:27] much of their work and so I think to
[44:30] question of are you going to have a
[44:32] different set of bots for your personal
[44:34] life and a different set of bots for
[44:36] your work life. Um I do think there will
[44:40] be a separation for many people. They
[44:41] want a separation between personal and
[44:44] and work life and I think that's I think
[44:45] that's great. I think that's important
[44:47] and I think there are a lot of common
[44:48] sense reasons why those things should be
[44:50] separate even from the perspective of of
[44:52] an enterprise. But I think our goal and
[44:54] the thing we're trying to build towards
[44:56] is Grockbot should be the way that a
[44:59] large portion of the things you do
[45:02] day-to-day in your work. You should be
[45:03] able to delegate a lot of that to
[45:05] Grockbot and focus on the higher
[45:07] leverage things. And then it should
[45:08] similarly be the way that you delegate a
[45:10] lot of the low leverage parts of your
[45:12] personal life. And those two things
[45:15] actually are not different problem sets.
[45:17] In a lot of ways, the product form
[45:19] factor and the ways of solving those
[45:20] problems is pretty much the same. And so
[45:23] my instinct is that I think one product
[45:25] will be the best form factor for both of
[45:28] those things. And that's really what we
[45:30] want to build.
[45:30] >> Bam. That's a big TAM right there. Uh I
[45:33] love I love to hear it. Makes so much
[45:35] sense. Obviously the question is how do
[45:37] you avoid crosscontamination, you know,
[45:40] personal stuff somehow uh infiltrating
[45:43] exfiltrating stuff from work. Uh but
[45:46] feels like that's kind of okay. So what
[45:47] I'm hearing is that's the direction. The
[45:48] question is just how to do that and make
[45:50] people feel super safe. have kind of
[45:51] like the sock tube stuff in place and
[45:54] also just feel really fun. This episode
[45:56] is brought to you by Mercury. Radically
[45:58] different banking now with spend. I've
[46:01] been a Mercury customer for so many
[46:02] years now. I switched all my business
[46:04] banking to Mercury and honestly I could
[46:07] not be happier. It's what online banking
[46:09] feels like when it's built by product
[46:11] people, not by bankers. And now with
[46:14] spend, you can give your team individual
[46:16] cards, set spending limits per person or
[46:18] per team, and have expense receipts
[46:21] automatically pulled in from Gmail or
[46:23] over text. You can even give your AI
[46:25] agents their own cards with their own
[46:27] limits and policies. Most founders start
[46:29] out the same way, one card used by
[46:31] everybody at the company. It works until
[46:34] it stops working. Someone goes over, a
[46:36] receipt disappears, you spend two days
[46:38] trying to figure out who spent what and
[46:40] why. Spend is expense management built
[46:43] directly into Mercury. All your team's
[46:45] cards, budgets, and reimbursements. All
[46:47] live in the same place as your business
[46:49] thinking. No chasing, no manual reviews,
[46:52] no end of month scramble. The result is
[46:54] a team that can move fast and a founder
[46:56] who is no longer the bottleneck. Learn
[46:58] more and get signed up at mercury.com.
[47:01] Mercury is a fintech company, not an
[47:03] FDIC insured bank. Banking services
[47:05] provided to Choice Financial Group and
[47:06] column NA members FDIC. The IO card is
[47:09] issued by Patriot Bank and a member FDIC
[47:11] pursuant to a license from Mastercard
[47:13] International Incorporated. Let me ask a
[47:15] couple technical questions. Uh on the
[47:17] computer side, how how do how what's the
[47:19] simplest way to think about what you get
[47:21] as a part of your Grobot account? Is it
[47:23] like a VM that is running in the cloud
[47:25] with multiple login? Is it like a
[47:28] separate VM instance per bot? How do we
[47:30] understand that as much as you could
[47:32] share? Mhm. Yeah. I think to go back to
[47:34] the teammate frame of the product, um to
[47:39] kind of extend the analogy even further,
[47:41] if we were on a team together, you and
[47:43] me, um you know, I think the number of
[47:46] times that you would have to manually
[47:48] take over my computer and start clicking
[47:51] on things and like, you know, you're
[47:54] doing this wrong, you should go here
[47:55] instead and type in manually. Hopefully
[47:58] is pretty close to zero. Hopefully that
[48:01] is not something uh you have to really
[48:03] do with with a colleague or a teammate.
[48:05] And so similarly, I think right now
[48:06] we're in a place where computer use is
[48:08] good. It's getting much better. And in
[48:11] very short order, I think the computer
[48:14] concept will be completely abstracted
[48:16] away from the user. You should never be
[48:18] clicking into a remote virtual machine.
[48:21] You should never have to take control.
[48:23] Uh you know, if something if there's
[48:25] like a wasteful path and you have to
[48:27] kind of steer it into the correct path.
[48:29] Um, so in the medium term, I think the
[48:32] computer concept will be an important
[48:34] concept for users to have, but will not
[48:36] actually be something that they're
[48:37] interacting with. So I think the right
[48:39] way of thinking about Grockbot is it's a
[48:41] team of bots. It's a team of agents that
[48:43] are that do work for you. And in terms
[48:46] of what they have access to, they have
[48:49] access to a very long memory set of your
[48:52] past interactions with them. And so I
[48:55] think there's a current paradigm of you
[48:56] create a new chat for each discrete unit
[48:59] of work. Uh I think there are a lot of
[49:01] problems with that. I find myself
[49:03] copying and pasting between chats all
[49:05] the time. Um I think it's just not a
[49:07] great way of grouping categories of
[49:08] work. Instead, the same way on a team,
[49:11] you have a good way of grouping uh
[49:13] categories of work of kind of roles. You
[49:15] should have roles of kind of different
[49:17] swim lanes of work that you do and it
[49:19] should learn from you and it should get
[49:21] smarter over time. So I think that's one
[49:23] very critical thing is these are
[49:25] longived agents. These are not
[49:26] individual one-off sessions and these
[49:29] agents get smarter over time. And then
[49:31] the second thing is those agents have
[49:32] access to all of the tools that you
[49:34] would expect a human colleague to have
[49:36] which is the APIs, the MCPs. That's
[49:39] great, but then access to its own
[49:41] computer which it can freely manipulate
[49:43] the way that you would. uh at this
[49:44] meetup that I went to uh Shub who's on
[49:46] the I think grow to market team uh
[49:49] demoed something that blew everyone's
[49:51] mind because you have a computer within
[49:53] each agent you can run a lot of
[49:55] different things on the computer he was
[49:57] running Grockbot within Grockbot
[50:00] like the bot can run its own Grock bots
[50:03] and I know he was using it for testing
[50:04] and watching regressions and things like
[50:06] that but that's just like a mind
[50:08] expanding idea and I'm curious how many
[50:10] levels you can go before the universe
[50:12] collapses on itself
[50:14] I do that one too. That one's actually a
[50:17] very useful thing to do is you download
[50:19] Grockbot for one of your bots. Mine is
[50:21] like a QA tester bot. Uh and that way if
[50:24] there's ever bug report or if we're kind
[50:26] of testing out a new a new build, for
[50:28] example, of the desktop app, I can just
[50:31] say, "Hey, here are 10 workflows that we
[50:34] need to make sure are getting better
[50:35] release after release. I want you to
[50:37] test it. I want you to write it to this
[50:39] notion document that has like an
[50:40] extensive list of all of the past tests
[50:42] that we've done of past client versions
[50:44] and compare them. And so I think once
[50:46] you start breaking out of this is AI
[50:49] chat with a set of connections which is
[50:51] I think where most people are
[50:52] conceptually now instead to this is a
[50:55] colleague with a computer and anything I
[50:57] would ask a colleague to do on a
[50:58] computer I can ask Arpot to do. It just
[51:00] raises the ceiling I think of of what
[51:03] you would think to give to AI. Are there
[51:05] any other mindexpanding use cases or
[51:08] ways to use Grockbot that uh you've seen
[51:10] that or you use? Mhm. One pattern that
[51:14] I've seen from many users
[51:16] um that is simple but I think there's a
[51:19] lot of depth uh if you keep investing in
[51:23] making it better. And this is kind of
[51:25] where I can get kind of nerdy about
[51:27] optimizing my setup. um is
[51:31] Grockbot as an infovore in some ways of
[51:36] just consuming huge quantities of
[51:38] information removing that from your own
[51:42] cognitive load giving you peace and then
[51:45] coming to you with the stuff that's
[51:46] important and I think the V1
[51:48] implementation of that which many people
[51:50] do is Grockbot sits on top of Slack and
[51:53] it sits on top of email and I tell it
[51:56] high level here's my role at the here's
[51:59] kind of what I care about. I want you to
[52:01] notify me in these cases. In these
[52:03] cases, you don't need to ping me
[52:05] directly, but you should include this in
[52:07] your daily roundup that I read every
[52:08] day. That's like the V1 implementation.
[52:11] I'm not sure what the V10 implementation
[52:13] is, but like maybe I'm at V3 or four,
[52:16] which is you can give these bots a
[52:18] complete fire hose of information. So I
[52:21] have mine hooked up to like every
[52:23] mention of Grockbot ever on X and it's
[52:26] interacting with our internal context.
[52:28] It's interacting with the QA tester to
[52:30] like see if it can repro any bugs or
[52:33] feedback that we're getting. I've hooked
[52:35] up to my own kind of messaging services
[52:37] to like quickly act on feedback and
[52:39] reach out to people. Um, and I think
[52:41] there's this just like always on
[52:44] kind of chief of staff entity that can
[52:48] preserve your focus on the things that
[52:50] actually matter, but is always like kind
[52:53] of surveilling to see if there's
[52:54] anything that should get your attention.
[52:56] And we've seen some funny cases of
[52:58] people actually giving their Grock bots,
[53:00] which I have not done this yet, but
[53:02] maybe soon, giving their Grock bots
[53:04] access uh the ability to page them. And
[53:07] so if something like super urgent
[53:09] happens and they're at a coffee or
[53:11] whatever, they get paged by Grockbot,
[53:13] which is the type of thing that you only
[53:15] want to do if it's urgent and you really
[53:17] want to you want to trust uh that
[53:19] Grockbot, you know, does not have false
[53:20] positives. So far, those people have
[53:22] reported uh that that it's been very
[53:24] helpful and successful. But I think
[53:25] we're going to see more of that type of
[53:27] stuff um where the agent or the bot
[53:30] should actually be more proactive to you
[53:32] than you reaching out to it. And I think
[53:34] that will be the next shift in AI. This
[53:36] touches on there's a number of things
[53:38] that I've been very impressed with
[53:39] watching your team operate. Uh one is
[53:42] speed which I want to talk about but the
[53:44] other is how you like there's awareness
[53:48] that this is a moment in time to capture
[53:50] a lot of market share and really uh take
[53:55] as much of the market as you can before
[53:56] somebody comes around and like okay now
[53:58] we got something awesome especially one
[53:59] of the foundation labs. So watching just
[54:01] how many free accounts you guys are
[54:03] giving out. Also the uh focus on use
[54:06] cases so smart because it's such a novel
[54:09] thing and you open it up and it's like
[54:11] what do I do with this and there's such
[54:13] a focus on okay here's a bunch of things
[54:15] people do with it and then there's all
[54:17] this talk on Twitter and just like all
[54:19] the ways people are using a template
[54:20] makes so much sense just these two kind
[54:22] of like focuses from what I can tell get
[54:24] as many people on it as possible as fast
[54:26] as possible until somebody's like okay
[54:29] you know because someone's going to come
[54:30] around be like all right here's the next
[54:31] thing uh super smart and also the use
[54:33] case focus. Uh I know you were a goto
[54:36] market person at Kurser before this.
[54:37] Anything you want to share there about
[54:39] just the approach to the to go to market
[54:41] right now for getting this out there. I
[54:43] think the pattern we
[54:46] saw for coding will be somewhat similar
[54:50] to what we see for general knowledge
[54:51] work and I think we've learned a lot
[54:54] from that on the go to market side and
[54:58] more
[54:59] generally um just building practical AI
[55:03] that people use and I think we as a
[55:06] company have culturally really cared
[55:09] about not building demoware uh like
[55:12] building actually useful stuff in the
[55:14] world uh and kind of obsessing over that
[55:17] and there are so many shiny objects and
[55:19] like fun prototypes to build. But
[55:22] ultimately that's a very different
[55:24] problem than getting this in the hands
[55:26] of millions of people and having it
[55:27] transform companies. So that's really I
[55:29] think culturally where we've we've
[55:31] always been focused. And so I think on
[55:33] the go to market side what we saw for
[55:36] coding um was a very simple pattern
[55:39] which was there was an early adopter
[55:41] crowd. The early adopter crowd would use
[55:44] these coding tools and really push them
[55:45] to the limits and they would mostly push
[55:48] them to the limits on individual
[55:50] projects. they would on nights and
[55:52] weekends. I'm thinking like 2023, you
[55:55] know, kind of earlier. Um people would
[55:58] kind of go home from work at at work,
[56:00] they were using a basic IDE. This is
[56:02] preAI. And then at home, they'd work on
[56:05] a side project and they'd be using
[56:07] cursor or they'd be using, you know, the
[56:09] latest and greatest AI coding tool. And
[56:12] that would give them an extreme amount
[56:14] of acceleration. It would feel like they
[56:16] were experiencing the future. And then
[56:18] they would come back to work and they
[56:20] would demand it. They would say,"I
[56:22] cannot picture working any other way
[56:24] than this. I feel like I'm completely
[56:27] walking through molasses right now. This
[56:29] needs to change." And I think for
[56:31] knowledge work, we're going to see a
[56:32] similar pattern of people really feeling
[56:35] the aha moment sometimes in a personal
[56:38] capacity. And I think we're certainly
[56:39] seeing a lot of this like on X right
[56:41] now. You see all these examples of uh
[56:44] Grockbot controlling their home [snorts]
[56:46] robot computer or home robot vacuum
[56:49] cleaner uh or Grockbot, you know,
[56:51] helping them save money on their Tesla
[56:54] charger negotiation. Like all of these
[56:56] fun use cases, but I think the next step
[56:58] is going to be this is not a consumer
[57:02] product. We think this is going to
[57:03] transform businesses. We think this is
[57:05] going to transform teams and it will be
[57:07] bots coming into teams and contributing
[57:10] really economically valuable work
[57:12] especially as they get much smarter.
[57:14] [snorts] And so on the go to market
[57:15] side, we're certainly um making a big
[57:18] push on prioritizing businesses and
[57:21] thinking about not just the single
[57:23] player use case of working with a single
[57:25] bot, but how does a bot work inside of a
[57:27] broader team? How does a bot work inside
[57:29] of real company systems uh that are
[57:33] complicated and there's a lot of context
[57:34] and a lot of history to understand? What
[57:36] does memory look like in kind of a
[57:39] broader uh organization versus kind of a
[57:41] single individual you're catering to?
[57:43] And I think there are a lot of
[57:44] unanswered questions there. But I do
[57:46] think Rockbot is the right primitive to
[57:48] create this switch to agents uh for the
[57:52] rest of the company outside of coding.
[57:54] And that's a place where we're quite
[57:55] focused right now. And along those
[57:57] lines, it's very clear you all
[57:59] understand the power of distribution and
[58:02] how you need to find both an amazing
[58:05] product and get distribution right
[58:07] because you know Grockpot's amazing, but
[58:10] the combination of how smart you guys
[58:13] have been with getting it out there in
[58:14] all these different ways is really
[58:16] impressive and I think that shows you
[58:17] what it takes these days to build
[58:18] something that's really successful. I
[58:20] want to ask about the brand of the
[58:22] different brands around uh this product
[58:25] and the company just so people can try
[58:26] to understand because I know you're
[58:27] going through a transition acquisition
[58:29] SpaceX all these things. So there's
[58:31] Grockbot, there's cursors is that so
[58:33] talk about like the products and the way
[58:35] to think about these different brands
[58:37] today and I know it'll probably continue
[58:38] to evolve just so we could uh
[58:40] communicate about it correctly.
[58:42] >> Definitely. Yeah. Um I think there are
[58:45] three big pillars right now of SpaceX
[58:48] AI. So the first pillar is the coding
[58:51] product instead of products and right
[58:53] now that's Kerser and Grock build and I
[58:56] think we're big believers that
[58:59] having a professional work surface for
[59:02] developers and for the engineering part
[59:05] of the organization is going to be
[59:06] really critical and right now people use
[59:08] Grockbot sometimes to kick off cloud
[59:11] agents or to kind of merge PRs or to do
[59:13] QA a bunch of engineering adjacent tasks
[59:16] but ultimately when you're shipping
[59:18] production software ware. We're big
[59:19] believers that that is going to require,
[59:22] you know, a product where every pixel is
[59:24] optimized for that end user. So, we're
[59:27] making big investments there. The second
[59:29] category is general knowledge work and
[59:32] we think bot is a really exciting step
[59:34] in that direction. There's a lot more
[59:35] work to do of making it more useful,
[59:37] extending it to new surfaces, it really
[59:40] feeling like an AI teammate that you can
[59:42] delegate work to, especially inside of
[59:44] companies and businesses. So, that's
[59:45] kind of the second pillar. And then
[59:47] third is the general model effort. Um we
[59:49] want to train the smartest models in the
[59:51] world um that are really capable. And I
[59:54] think one thing that somewhat
[59:56] distinguishes
[59:58] SpaceX AI from other AI labs um is I
[60:02] think our goal is less to build um you
[60:06] know chase super intelligence or some
[60:08] kind of vague aspirational ideal. uh and
[60:12] the goal is actually very practical
[60:14] which is to build useful AI and we do
[60:17] that on the product side, we do that on
[60:18] the model side and I think part of that
[60:20] is also just cultural of like the group
[60:23] of people contributing to these models
[60:25] are engineers and people who um kind of
[60:29] came into the the model training effort
[60:32] from like a very applied mindset and I
[60:35] think that's what gets this company
[60:38] going and I think is is actually a
[60:39] slightly different direction from some
[60:41] of the other competitors out there.
[60:43] >> Super interesting. Okay, there's a
[60:45] couple directions I want to go. One is
[60:46] you have this tweet that is uh I think
[60:49] you pinned it or maybe it's your last
[60:50] tweet. It's up there in your timeline if
[60:52] people check you out. So the tweet is an
[60:54] AI that does 100% of the job feels
[60:57] categorically different from one that
[60:58] gets you 90% there. I've significantly
[61:01] updated what I think AI is capable of.
[61:05] Say more about that. I think for me what
[61:07] made me so excited to work on Grockbot
[61:11] and contribute to it is it was the first
[61:15] time for non-coding tasks that I felt
[61:19] like I could truly delegate work to AI
[61:23] and not have to think about it and I
[61:25] would come back and it's done. And I
[61:28] think engineers have been feeling this
[61:30] for quite some time. For maybe a year, a
[61:32] year and a half things have been like
[61:33] that. I mean the job of a developer has
[61:36] completely transformed. It is
[61:38] unrecognizable from what it was two
[61:40] years ago and and many many words have
[61:42] been said on that topic. Uh but I think
[61:44] it's underrated how different that
[61:48] experience is from what most people are
[61:50] feeling about AI right now and the way
[61:52] that AI has changed their lives. And it
[61:56] looks quite similar to the way that
[61:58] people would use AI like two years ago
[62:00] where you create a new thread for a
[62:02] task, you type it into a to a, you know,
[62:05] an input box, you hit enter, you watch
[62:08] all of these steps happen, you get an
[62:10] output, it's not quite right, you keep
[62:12] working on it. And Grockbot, I think,
[62:14] shortcircuits a lot of that. When you
[62:16] first kind of lay eyes on the first
[62:18] screen, you're like, whoa, this is
[62:20] clearly different. Let's see if it
[62:22] actually works, but this is different.
[62:23] and then you give it something and it
[62:25] kind of works um you know to a
[62:27] surprising extent uh and I think we're
[62:29] going to do a lot to to make it work
[62:31] much better and so I think what I was
[62:33] expressing in that was when you have a
[62:36] teammate that you only 90% trust uh and
[62:40] you give something to which luckily I do
[62:42] not have the experience of here because
[62:43] I work with great people but if you
[62:45] delegate something to someone and you're
[62:46] like I know I'm going to have to be
[62:48] thinking about this while you're doing
[62:50] it and I know it like probably is not
[62:52] going to be quite there and I'm going to
[62:53] have intervene and kind of steer it
[62:55] slightly.
[62:56] You're not that's not 90% task
[62:58] completion. You're still doing the thing
[63:00] and it feels that way and it's it's
[63:02] weighing on you in the same way versus
[63:05] like truly throwing a nook pass to a
[63:08] colleague and being like you got this.
[63:09] Here's the context. Go off and run. I'm
[63:12] excited to see what you do. Like that's
[63:14] a different category. And I think that's
[63:16] the type of thing that people feel with
[63:18] Grockbot every day are these no look
[63:20] passes and you just trust that it can
[63:22] get it done and then it does and it's
[63:24] just a very magical experience.
[63:26] >> Yeah, I have had that experience
[63:28] consistently. Um, okay. So, another
[63:31] element of how you all operate that has
[63:33] really impressed me and I've not seen
[63:35] this before is how fast you all move.
[63:38] So, I got added to this like Slack as
[63:40] you as I was giving feedback with some
[63:42] folks and it's just like, "Okay, how
[63:44] about okay, tomorrow we're gonna give
[63:45] you some free codes to give out. You
[63:46] could do it tomorrow. We'll do this
[63:47] tomorrow." Or, uh, we're going to launch
[63:48] a marketplace with templates. We're
[63:50] going to launch this in two days. It's
[63:51] just like, what? I don't I don't have
[63:53] time for this. How do you guys with all
[63:55] the things going on? All these things
[63:57] constantly shipping and also staying
[64:00] consistent and high quality and feeling
[64:03] clear that it's towards a specific
[64:04] vision. So, there's kind of like two
[64:06] parts of this question. just what what's
[64:09] the secret to how fast you all have been
[64:11] moving and how do you stay aligned
[64:16] moving that fast towards a vision of
[64:18] that you all want they all believe in
[64:20] and where you want it to go versus just
[64:22] like you know bandating it along the way
[64:25] >> yeah one thing I've been really
[64:28] happy has never changed is that startup
[64:31] feeling inside of the company and for
[64:33] context when I joined cursor originally
[64:35] we were about 15 people. We scaled to
[64:38] about to over a thousand. Um, and then
[64:40] now we're a part of of SpaceXi, which is
[64:43] kind of an even bigger organization. And
[64:45] it's something that is just so fun to be
[64:47] a part of when you're around this group
[64:50] of incredibly talented people.
[64:52] Everyone's moving 100 miles an hour. You
[64:55] trust, you deeply trust everybody to
[64:57] execute on their part of the equation.
[64:59] And there's a clear vision uh that
[65:01] everyone is fired up about and like and
[65:03] knows that that they need to execute on.
[65:06] Um, and you know, as companies grow, and
[65:08] we've had the fortune of hiring really
[65:10] great people from other companies that
[65:11] have gone through hyperrowth, things
[65:13] slow down, and you kind of keep telling
[65:16] yourself, [snorts] "We're still a
[65:17] startup. We still move quickly, but you
[65:20] really don't." And everyone knows that
[65:22] you don't. And it's just, you know, it's
[65:24] easier uh to say than to actually be.
[65:28] And, you know, fingers crossed this this
[65:30] continues to be true. I think it's
[65:31] really critical for our success if this
[65:33] continues to be true. Uh but even as we
[65:36] scaled it has always felt like that
[65:38] startup that kind of I I first joined.
[65:41] Um and I think if you define a startup
[65:43] by number of people or by like the
[65:47] funding round like none of those things
[65:49] really make any sense. The core thing
[65:51] that defines a startup is exactly what
[65:53] you're describing, which is this kind of
[65:55] scramble energy of things are kind of
[65:58] chaotic and kind of disorganized. And
[66:00] like for a lot of people, that's not a
[66:02] pleasant working environment to be in,
[66:04] but it has these amazing properties of
[66:07] you can make extreme impact in a
[66:09] particular direction in a short amount
[66:11] of time. And you really do get out of a
[66:13] system what you put in. And so I think
[66:15] as a culture, I think as an organization
[66:17] and the way we construct ourselves, uh,
[66:19] it's really been to enable that property
[66:22] in a way that I think some of our
[66:24] competitors and and other AI labs have
[66:26] gotten much bigger and you can feel it.
[66:28] Um, and I think us even as we scale
[66:31] there is that that startupy impulse that
[66:33] is is quite important to move quickly on
[66:34] these things.
[66:35] >> Let me pull on this thread and let me
[66:37] ask you this big question that I've been
[66:38] looking forward to asking you. If you if
[66:41] you were to look at cursor from the
[66:43] outside, you it shouldn't have worked.
[66:46] It shouldn't have uh lasted because one,
[66:51] it's in the most competitive market in
[66:54] the world competing against the fastest
[66:56] growing companies in history, open AAI
[66:58] and Anthropic. So that's one, it's like
[67:00] the comp competition is unlike anything
[67:03] anyone's ever experienced. Two, it sits
[67:05] on top of those platforms to power it.
[67:10] And what I've seen as an outsider is
[67:14] what has allowed Cursor to win and have
[67:16] this massive exit and continue to
[67:19] succeed is how quickly you all adjust to
[67:22] the reality of the market. Started as
[67:24] autocomplete and then things moved on to
[67:27] just talking to agents and then into the
[67:28] cloud and now Grockbot. To me, that
[67:31] feels like a core part of the success is
[67:33] uh quickly adjusting to reality and also
[67:38] building the best-in-class experience
[67:39] for a thing that also exists other
[67:41] places. Grockpot's a great example. You
[67:43] could do this other places, but it's the
[67:44] best-in-class experience. Cursor the ID,
[67:46] the best way to code. Uh so, so that's
[67:50] my question. Maybe I answered it, but
[67:52] what do you think has been core to
[67:54] Curser's ability to not just survive in
[67:56] this crazy competitive market, but uh do
[67:59] so incredibly well consistently for so
[68:01] long?
[68:01] >> I mean, a lot of this, and it's a fuzzy
[68:03] answer, a lot of this, I think, is
[68:05] downstream from culture and the culture
[68:08] that you set and the people that you
[68:10] bring in and the way that they approach
[68:11] these problems. And I think for us,
[68:14] exactly as you said, we have never been
[68:18] complacent.
[68:19] uh we've never felt like we've won and
[68:22] it's always been about the next thing
[68:25] and I think there's been a really deep
[68:27] belief across the company that AI is
[68:30] moving incredibly quickly. Our goal is
[68:33] to translate those capabilities into
[68:35] amazing products for customers. But
[68:37] those products are going to change and
[68:40] they need to meet the moment as the
[68:42] capabilities get stronger. And what met
[68:44] the moment two years ago is completely
[68:46] different than what's meeting the moment
[68:48] today. And if we as a company can't
[68:51] completely reinvent ourselves every six
[68:53] months, which recently it's felt even
[68:55] shorter than that of kind of complete
[68:58] like very significant reinventions of
[69:01] our priorities, the core product, what
[69:03] users feel, uh we're going to lose. And
[69:06] I think it's that spirit of always
[69:09] pushing to be on the frontier, never
[69:11] thinking it's over or that we've won or
[69:13] that we've gotten it right. Uh, and just
[69:15] constantly updating our beliefs that has
[69:18] gotten us to where we are now. And to
[69:20] your point on the competitiveness of
[69:21] this space, I mean, one thing that I
[69:23] think is important to point out is AI
[69:25] coding has always been competitive from
[69:28] when cursor first first kind of came to
[69:31] be. And at the time the competitors were
[69:34] Microsoft and others and a handful of
[69:36] maybe 10 or 20 companies. Um and I think
[69:38] it's notable that none of those
[69:41] competitors are at the forefront of AI
[69:44] coding right now in large part not
[69:46] because of any incorrect decisions that
[69:48] they made or any uh lack of resources on
[69:50] their part but this cultural inability
[69:54] to move quickly and to change to meet
[69:57] the moment as the moment's changing. And
[69:59] so I think that's exactly uh what has
[70:01] led us to invest in things like Rockblot
[70:04] for example.
[70:04] >> Are there any uh core values just like
[70:06] specific ways you phrase this to kind of
[70:08] remind everyone of this is how we work?
[70:10] >> Yeah, two values that I find myself
[70:14] coming back to quite a bit. The first
[70:15] one is this idea of deleting the product
[70:18] and I think it exactly ties back to what
[70:20] you're saying right now where when you
[70:22] look at every past iteration of cursor
[70:26] for example but even I think when you
[70:27] look at every past iteration of Grockbot
[70:29] I think we will feel the same thing uh
[70:31] is things going away not new things
[70:34] getting added but you know these
[70:37] scaffolding product overhang style
[70:39] things that get built in because the
[70:41] models have not yet gotten smart enough
[70:43] to just do it themselves. Those things
[70:44] will get moved away over time and we
[70:47] need to feel comfortable making kind of
[70:49] hard decisions that might upset a small
[70:52] set of users or a small set of us
[70:53] internally to do the bigger thing of
[70:57] make the product simple, make the
[70:58] product powerful and adapt to where the
[71:01] future is going. So I think that's been
[71:03] very core. And then the second thing
[71:04] which ties back to the kind of pace of
[71:07] execution um is just do the thing uh
[71:10] which I find myself kind of repeating a
[71:12] lot um even as we've kind of grown as a
[71:15] company is it's on you know we're all in
[71:18] this boat together we want to win and if
[71:21] you see something that you think needs
[71:23] to happen you know this is not an ask
[71:25] for permission culture you go out and
[71:27] you fix the thing and you pull in the
[71:29] resources that you need to make it
[71:30] happen and I think that has made many
[71:33] people very successful here before and I
[71:35] think it's something we really share
[71:36] with with SpaceX AI as well
[71:39] >> agency as uh you may have heard
[71:42] um so interesting
[71:45] one of the big questions that comes up
[71:47] and and uh and this might be my final
[71:50] question is around moes and a lot of
[71:52] people look at cursor is a really
[71:54] interesting example of they're in a
[71:56] market with technically maybe no moes
[71:58] but they've continued to win and succeed
[72:01] the two modes you think about with
[72:02] cursor is the data feedback loop of
[72:04] people autocompleting, learning what
[72:06] they're doing and training models based
[72:07] on that. So that's that's unique. The
[72:09] other is just best-in-class experience
[72:12] and being like a high g daily active
[72:15] user product and finding over time what
[72:18] works and what people need. What have
[72:20] you just learned and I guess any
[72:21] thoughts on Moes in this space that
[72:24] might be helpful for folks that are
[72:26] trying to figure this out for
[72:27] themselves? Yeah, there's a lot of talk
[72:29] about Moes and
[72:33] it is a pretty interesting moment in
[72:35] time to be starting a company. So, I can
[72:37] understand why so many founders are kind
[72:39] of asking themselves that and trying to
[72:41] project out 12 months from now, 24
[72:44] months from now, it just feels like an
[72:45] eternity. I will say that I think if
[72:48] cursor and many other successful
[72:51] companies of this kind of vintage I
[72:54] think if they had thought about moes
[72:58] slash kind of tried to work backwards
[73:01] from some strategy diagram or like you
[73:05] know a maybe more abstract notion of how
[73:07] a company should work. I don't think
[73:10] that would have created this outcome or
[73:13] this product. I think what really
[73:14] created the magic of cursor uh was an
[73:18] obsession with building a useful thing
[73:21] today and I think it was constantly this
[73:24] exercise of you can kind of see where
[73:26] the world is going three months from now
[73:28] six months from now models are going to
[73:30] get smarter a thing that isn't solvable
[73:32] now is finally going to be solvable and
[73:34] I think cursor was a little bit this
[73:36] recurring prompt of how could we pull
[73:39] that stuff to today even if it requires
[73:42] a little bit of of engineering on top to
[73:45] make it work or a lot of engineering on
[73:46] top to make it work. Even it requires
[73:49] changing the product in a specific way
[73:50] so that a user can interact with this
[73:52] new capability. How can we bring that
[73:54] forward and then three months from now
[73:56] we should delete all that stuff because
[73:58] it'll just be good and like basic you
[74:01] know common bare minimum of the product
[74:03] and then we'll build the thing for 3
[74:05] months from then and then it was
[74:06] constantly just doing that over and over
[74:08] again that I think led to users really
[74:11] trusting us and placing you know their
[74:14] their time inside of our product and
[74:16] trusting that we were kind of bringing
[74:17] things to this next frontier and to the
[74:20] next future. And so I would really
[74:22] encourage many founders or people
[74:25] starting out today to be more grounded
[74:28] in that perspective of how can I make
[74:30] something that is not possible now
[74:32] possible. Users are going to come to me
[74:34] to use that thing. I'm going to pull
[74:36] them to the next impossible frontier and
[74:39] then through all of that I'm going to
[74:40] gain a lot of distribution advantages.
[74:43] I'm going to gain data advantages. There
[74:45] will be value there. Uh but I think
[74:47] that's really the place to play.
[74:49] >> I love that answer. Essentially, like
[74:51] the way I'm thinking about it is just
[74:53] build something people are obsessed
[74:54] with. Don't overthink the modes piece.
[74:56] And if you can continue to do that,
[74:58] you'll find something which in cursor
[75:00] case ended up being a few things.
[75:02] >> And that that came up actually recently
[75:04] on another podcast I did. I don't know
[75:05] if it'll come out before after this.
[75:07] This idea that modes are discovered, not
[75:08] planned ahead of time a lot of times.
[75:11] >> Okay, let me actually ask you for
[75:12] Grockbot tips as an actual last
[75:14] question. Uh some people are going to be
[75:16] like, "Oh I got to try this thing.
[75:17] what all these what's all this
[75:19] excitement all about? Um what would be
[75:21] some advice for folks that are trying
[75:23] out let's say for people that are new to
[75:25] it just like here's some keys to success
[75:27] and maybe some power tip for someone
[75:29] that's already with it and just like oh
[75:30] wow I didn't know that.
[75:31] >> Yeah I want to stay away from the you
[75:35] know super hacky pro tip stuff because I
[75:38] think our philosophy as a team and as a
[75:41] company is that those things really
[75:43] shouldn't exist. There shouldn't be all
[75:44] these crazy knobs. you should be able to
[75:47] delegate something to Grockbot and they
[75:49] should do it. Um, and so what I would
[75:50] encourage for someone new who's like
[75:53] just downloading the app, you're looking
[75:55] at this this screen. Um, I think the
[75:58] first thing is give Grockbot the context
[76:02] it needs to be successful. So, in a
[76:04] similar way as if you were onboarding
[76:06] someone to your team, it'd be really
[76:08] helpful for them to have access to, you
[76:11] know, Slack and your email and the
[76:14] company records that you use every
[76:16] single day. So, I'd give it access to
[76:18] the tools and then I would actually ask
[76:20] Grockbot what it can do for you and let
[76:24] it kind of go through those connections
[76:27] that you've initially set up. In my
[76:28] case, it might be I give it my email, I
[76:30] give it Slack. And I was really
[76:32] surprised when I was first onboarding.
[76:34] This is we didn't have any onboarding
[76:35] screens at this time. So this was kind
[76:36] of the first task I gave it was go
[76:38] through my Slack, go through my email
[76:40] and suggest like five things that you
[76:42] can take off of my plate and what it
[76:44] would take for you to do that. And I
[76:46] suggested five and like two of them were
[76:48] actually really helpful and I just
[76:50] immediately spun off two bots to solve
[76:52] those two. Um, and that was my big wow
[76:54] moment of feeling like no other AI tool
[76:57] in the past could have done those two
[76:58] things. It was not like draft an email.
[77:00] it was like do a chunk of work. And so I
[77:03] encourage people who are brand new to do
[77:05] it that way. And then for people who are
[77:07] not brand new, um I kind of am
[77:10] constantly finding new patterns for ways
[77:14] that my bots can interact with each
[77:16] other and can collaborate with each
[77:18] other. And so I've been creating a bit
[77:21] more of a scaffold of kind of where
[77:23] these artifacts that Grockbots create
[77:26] should live and how it can write to a
[77:28] place that's very legible to me. So I
[77:30] have like these frequent digests that I
[77:32] read every day and it kind of pushes to
[77:34] a database and I can just read it very
[77:36] easily. Um, and so I would encourage
[77:39] power users to think about ways that
[77:41] Grockbot can actually write to like a a
[77:44] single store where you can organize a
[77:47] lot of its outputs much easier.
[77:49] >> Damn, we need another episode of going
[77:51] deep on Gro Roman's Grockpot setup which
[77:54] probably has way too much private
[77:55] sensitive information. We couldn't show
[77:56] it, but that's okay. That's an amazing
[77:59] tip. Roman, is there anything that you
[78:01] wanted to share or anything else you
[78:03] wanted to touch on before we get to our
[78:06] very exciting lightning round?
[78:08] >> Nothing. Nothing else on my side.
[78:10] >> We covered so much ground. That was I
[78:12] can't believe that was only an hour and
[78:13] a halfish. Uh I felt like we we've been
[78:15] talking for ages and covered everything
[78:17] I was hoping to cover. With that, we've
[78:19] reached our very exciting lightning
[78:20] round. I've got four questions for you.
[78:22] Are you ready?
[78:22] >> I am ready.
[78:24] >> What are two or three books that you
[78:26] find yourself recommending most to other
[78:27] people?
[78:28] >> Yeah. So, two two books for you. One is
[78:31] I love Kerbonagget. Uh, so Cat's Cradle
[78:34] has been a fun fun recommendation that
[78:36] and a copy that I bought many friends
[78:38] before. Um, and then second is The War
[78:42] of Art by Steven Presfield, uh, that I
[78:44] find myself frequently coming back to,
[78:46] even if it's just a page or two at a
[78:48] time. Um, and I'd recommend for anybody.
[78:51] >> War of Art. Incredible. It's like such a
[78:53] short book and it's like once you read
[78:55] it and it's not the art of war which is
[78:56] what people might think they're hearing.
[78:58] Yes.
[78:58] >> But it's the war of art. It's a play on
[78:59] that and it's about the uh the challenge
[79:02] of being creative and doing creating
[79:03] something new and how to overcome the
[79:06] resistance. Uh I love that
[79:07] recommendation. Uh next question.
[79:09] Favorite recent movie or TV show if
[79:11] you've had any time to watch any of
[79:13] these things.
[79:14] >> Yes. um recently. So every year I do a
[79:18] watch of Casablanca which is one of my
[79:20] favorite movies and it incidentally also
[79:23] has a character with my last name
[79:25] Yugarte which is like the only example
[79:28] of I think a Yugarte in the media. Um so
[79:31] Casablanca always a great rewatch. Um,
[79:34] and then on the TV side, um, I sometimes
[79:38] sneak in an episode of Monk, the
[79:41] detective show, uh, which was one that I
[79:44] watched kind of as a kid with my family
[79:46] and I've come back to now that I live in
[79:48] San Francisco. And it's just a great
[79:50] moment in time snapshot of San Francisco
[79:52] in the late 90s, early 2000s when it was
[79:55] shot. Um, that I I really enjoy.
[79:57] >> First Monk reference on the podcast.
[80:00] Okay. uh favorite or most interesting AI
[80:03] product right now. You can say Rockbot
[80:05] if you want, but if there's anything
[80:06] else, you get bonus points.
[80:07] >> Um I've always been a big AI semantic
[80:12] search nerd. I love any SEM search
[80:16] product, especially the kind of out of
[80:19] the ordinary ones. Um so I I was like a
[80:22] very early user of of Metaphor at the
[80:24] time, which became EXA. And I love kind
[80:26] of using Exa to do all of these maybe
[80:29] more strange queries over the internet,
[80:31] but I see a lot of examples of people
[80:33] building like semantically search over,
[80:36] you know, an embedded image store of the
[80:38] MoMA or kind of things like that. And I
[80:41] always have so much fun playing with
[80:42] those. So, anything semantic search
[80:44] engine over like a weird data set, I
[80:46] love.
[80:47] >> And Exa in particular is one you'd
[80:48] recommend.
[80:49] >> I love Exa. Yeah.
[80:51] >> Very cool. Okay. favorite life motto
[80:53] that you often come back to in work or
[80:55] in life.
[80:56] >> Not as short as a single motto. Um but I
[81:00] love the desiderata which I don't know
[81:03] if you've read but um I have it on my on
[81:06] my door uh and I've had it since I was a
[81:09] teenager and everywhere I move I kind of
[81:11] paste it there and it's it's a very
[81:12] short poem but each line I just I find
[81:16] myself finding something new in it every
[81:18] time I read it and I find it really
[81:20] grounding. Roman, this was amazing. Uh
[81:23] what a what a point in time we're here
[81:25] right now at this moment in time of
[81:27] Grockbot of AI in general. Uh it's going
[81:29] to be really fun to revisit this in a
[81:31] year and be like, "Wow, we were so right
[81:33] and so wrong about so much." Uh thank
[81:35] you so much for doing this. I know it's
[81:37] a very busy time on your team right now.
[81:39] So I really appreciate you carving out a
[81:40] couple hours to chat. Um is there any
[81:42] place you want to point people to?
[81:44] Anything you want to plug other than
[81:45] check out Grockbot? Is that
[81:47] >> Check out Grockbot? Of course. Um, and
[81:49] yeah, main thing would be please send
[81:52] feedback. I think we're in the very
[81:54] early innings of this still. I mean, we
[81:56] released a beta 3 weeks ago. Um, and a
[82:00] lot of the feedback that we've been
[82:01] getting from this early set of users is
[82:03] directly translating to what we built
[82:06] and how we build it. And so really
[82:08] appreciate um, all the input that people
[82:10] are giving.
[82:10] >> Nice job, Roman, and team. I know
[82:12] there's a whole team behind all this.
[82:14] Uh, Roman, thank you so much for being
[82:16] here.
[82:17] >> Awesome. Thanks, Lenny. Bye everyone.
[82:20] Thank you so much for listening. If you
[82:21] found this valuable, you can subscribe
[82:23] to the show on Apple Podcasts, Spotify,
[82:25] or your favorite podcast app. Also,
[82:28] please consider giving us a rating or
[82:30] leaving a review as that really helps
[82:32] other listeners find the podcast. You
[82:34] can find all past episodes or learn more
[82:36] about the show at lennispodcast.com.
[82:39] See you in the next episode.