Grok Bot Retrospective: How a Small Team Built an AI Colleague-Level Agent in One Month

A team of just a few people went heads-down for a month — from the first line of code to an internal prototype — then spent three more weeks iterating before shipping what's been called "the hottest AI product right now": Grok Bot. In this interview, Roman Ugarte, a core member of the Grok Bot team and former employee #15 at Cursor, walks through the entire development journey and explains the fundamental philosophical differences between this product and competitors like Codex and Cowork.

This article is a full reconstruction of that interview, attempting to surface the decisions that "weren't obvious at the time but turned out to be critical."

Why Start From Scratch Instead of Adding Features to Cursor

Anthropic and OpenAI followed similar paths: build a coding agent first, then realize the opportunity extends far beyond coding, and try to stuff knowledge work capabilities back into the original product. Codex is still moving in the direction of "consolidating everything into one." The Grok Bot team made the opposite choice — starting from a blank slate to build an entirely new product.

Roman describes the problem with competitors in concrete terms: everything gets piled into one interface, and every new mode gets another tab, until it becomes increasingly crowded. Users can sense that there's no unified work philosophy behind it — "it feels more like three different ideas crammed onto the same screen" — which is essentially the company's org chart transplanted directly into the product.

Building a new product means owning every detail yourself, and your vision for the future of knowledge work can be expressed consistently in a single coherent product. The team also acknowledged this isn't the only valid path — Codex taking a different route could also succeed, and "the road you've traveled shapes the choices ahead." But for Grok Bot, the freedom that came from starting from zero was the essential precondition for building something that actually works.

Codex is OpenAI's cloud-based coding agent that lets users describe tasks in natural language and have them completed in a sandbox environment without opening a local IDE. Cowork is Anthropic's exploration into multi-agent collaboration. Both follow a similar trajectory to Cursor: starting from coding use cases and gradually expanding toward broader knowledge work, but their core interaction frameworks and product philosophy still originate from code editors. When Roman says "three different ideas crammed onto the same screen," he's describing exactly this pattern of continuously patching an existing product architecture — each new use case gets layered on as another tab or mode switch, leading to an increasingly fragmented experience.

A Small Team Goes Heads-Down: One Month to a Working Prototype

Building from scratch, they assembled a small team — "really just a handful of people" — completely isolated from the rest of the company. Separate office, private chat channels, one goal: build a knowledge work product usable by non-developers.

Roman emphasized that this independent small-team model is what made the pace possible. "If the team were too large, this probably couldn't have been done." Every day brought a flood of small decisions that needed to be made, and a large group spending six months to a year debating grand visions would never have reached where they are today. Move fast, get a rough but working prototype out first — that's the core of the methodology.

From the first line of code to the internal prototype launch took roughly one month. They then presented it to the whole company at an all-hands meeting and rolled it out internally at SpaceX. The enthusiasm in the first week "exceeded expectations" — departments they never anticipated responded with particular enthusiasm, and many people who had previously used ChatGPT daily started migrating their everyday agent tasks over. That was the real-world test.

Onboarding Two to Three Hundred Users by Hand — What the Painful Process Taught Them

The team did something counterintuitive: core members personally walked early users through onboarding one by one, for about two weeks, across a few hundred people. Some might question whether this was a distraction from development, but Roman's conclusion was clear — "This was absolutely not a distraction. It was a key reason we succeeded."

The first few onboarding sessions "were genuinely painful": the computer would fail to start, and they'd sit on the call with the user waiting 20 minutes; watching users completely lost in the setup flow. Every terrible experience forced out a "must fix this by tomorrow" problem, because tomorrow they had another user to onboard.

The team also deliberately sought out people outside their bubble. A coffee shop owner became a power user, and the issues they raised — unstable Shopify connections, product copy that didn't hit the mark — were completely different from what the Silicon Valley insiders reported. This revealed two things: this is a general-purpose product that may deliver even more value to non-developers; and they needed to actively step outside the Silicon Valley AI circle, because this kind of product has a chance to become the primary way ordinary people interact with AI.

Making Robots Feel Like Colleagues: Two Decisions That Truly Mattered

Many have pointed out that most of what Grok Bot can do, Codex and Cowork can also do. Roman acknowledges that's technically true, but attributes the success to two early decisions that weren't obvious at the time.

First: run everything in the cloud. Users don't need to worry about the difference between local and cloud, or whether their computer is on. It's a "perpetually online colleague" with its own computer — no matter whether you interact via phone or elsewhere, the same state is maintained. This unlocked many possibilities and eliminated a lot of the day-to-day friction that competitors leave behind.

Second: each bot has its own computer. Many tasks simply don't have good MCP interfaces or APIs. Human work relies on operating computers — clicking on screen, typing in fields — and the bots need to be able to do the same. Roman used a brilliant analogy: the current way of working with AI is like a new hire showing up on their first day and being told they don't get their own laptop, they'll always share yours, interrupting each other, sharing accounts — nobody works that way in real life. Future AI colleagues need something like a human onboarding process.

Around this philosophy, the team also coined the term "bot": each type of task and use case gets a named bot rather than a throwaway chat window. Internally, a "chief of staff" pattern even emerged — users "promote" one bot to a manager role that delegates tasks to other bots.

The decision to give each bot its own computer relies technically on "Computer Use" — the ability for AI models to directly control graphical interfaces, simulating mouse clicks, keyboard input, screenshot recognition, and other human ways of operating a computer. Anthropic was first to open this capability in Claude in late 2024, and other major models followed. The fundamental difference from traditional API calls or MCP (Model Context Protocol) interfaces is that APIs require target software to have pre-built structured interfaces, while Computer Use lets AI operate any software with a UI just like a real person, requiring no adaptation on the software side. This is the underlying reason Grok Bot can handle enterprise software like Salesforce and Shopify — these tools have closed or heavily restricted APIs for automation, but they all have interfaces. The tradeoff is slower speed and occasional operational errors, which is why the team had to repeatedly fix very specific issues like "the mouse can't hit a certain position."

Removing Features Is Harder — and More Important — Than Adding Them

In the two weeks before launch, the biggest thing the team did was "delete a lot of features." The core team had packed in a ton of experimental, developer-oriented debugging tools — showing the model's internal reasoning, displaying what memories were saved — and had to ruthlessly cut before shipping.

Roman proposed a useful test: when discussing any feature, ask first, "How would we introduce this to users at launch?" If you can't even write a compelling tweet about it, maybe it shouldn't be built at all. Going further, they shifted the narrative from "what new buttons the product has" to "what Grok Bot can now do for you" — the former is software thinking, the latter describes a person's capabilities.

Automatic tasks are a prime example. Competitors require opening a sidebar, clicking plus, selecting triggers and actions — so cumbersome that most people never use it. Grok Bot lets users just say in natural language, "Remind me every morning at 8am," and 99% of automated tasks on the platform are created this way, with users never needing to see the creation interface at all. Skills work the same way — created automatically in the background, without users needing to know the concept of "skills" exists.

Getting Things Truly Done: The Trust Gap From 90% to 100%

Roman has a widely quoted tweet: AI completing a task "fully" versus "90% of the way" feels completely different.

If you only have 90% trust, you can't let go after handing something off — you'll likely need to step in and correct course yourself, which means the task is still sitting on your plate and the burden hasn't disappeared. True delegation is like a no-look pass in basketball: set the context, let it run, and trust it will catch the ball.

To deliver on this promise, the team locked onto roughly five key foundational issues in the background and kept polishing them. Sales and marketing teams were heavy users, and their tools lacked good APIs — Grok Bot's computer operation capability made a huge difference. The team fixed ten to twenty very specific issues, like "the mouse can't hit a certain spot on the Salesforce dashboard." Each time an unglamorous infrastructure improvement shipped, the sales team would excitedly send thanks the next day — "a workflow that kept failing all last week finally works." The recruiting team used it for around-the-clock talent sourcing: scraping new papers from conference websites, finding co-authors, cross-referencing whether anyone at the company knew them — work that used to be entirely manual can now be handed to a bot.

Salesforce is the world's most widely used CRM (customer relationship management) system, and Shopify is the dominant e-commerce platform for small and medium businesses. Both are known for restrictive external APIs and complex interfaces, with extremely high costs for internal automation — classic examples of "AI could theoretically help but rarely lands in practice." This explains why sales and marketing teams responded so strongly to Grok Bot — they spend large amounts of time every day doing manual work in these two systems, and once a bot can reliably handle that, the efficiency gains are nearly immediate. Feedback like "a workflow that kept failing every day finally works" reflects exactly the qualitative shift from "occasionally works" to "genuinely reliable" — the real-world version of what Roman calls the difference between 90% and 100%.

Speed, Culture, and "Moats"

On why Cursor has continued to lead despite pressure from OpenAI and Anthropic — among the fastest-growing companies in history — Roman attributed it to culture: never being complacent, always looking at the next thing. "If you can't completely reinvent yourself every six months, you'll probably lose." When AI coding had ten to twenty competitors, most are no longer at the frontier — often not because of any single decision, but because their culture couldn't change fast enough with the environment.

His view on moats is worth thinking about for founders: what actually made Cursor compelling was an almost obsessive focus on "can we make something useful today," not working backward from a strategic map. By consistently bringing "things that might be possible in three months" to today, users stay because of trust, and advantages in user access, data, and more form naturally in that process — "moats are usually discovered after the fact, not planned in advance."

The ultimate vision is actually simple: everyone should have a team of AI bots helping them work and live, bots you can guide without having to micromanage. Internally, the team calls their decision-making framework "colleague thinking" — when there's a product debate, step back and ask: "If this were a real human colleague, how would you want them to handle this?" The answer usually becomes immediately clear, and agreement tends to follow quickly.