8 Months, $100M Revenue: How Emergent Is Eliminating the Programming Barrier with AI

In today's fiercely competitive AI coding tool landscape, a startup called Emergent has posted some eye-catching numbers: $100 million in revenue in 8 months, nearly 7 million users worldwide, covering 190 countries. In an interview with Anthropic, CEO and co-founder Mukund breaks down the product philosophy and technical choices behind this growth curve.

From Software Testing to a General-Purpose Coding Agent: Three Key Pivots

Emergent didn't set out targeting the "text-to-app" space from the start. When Mukund and his twin brother Madhav first joined YC, their entry point was automated software testing—at his previous company with a 500-person engineering team, he had seen firsthand that testing was the bottleneck to fast software delivery.

But to automate testing, the team had to build their own container technology and coding agent, which led them to a deeper insight: as long as the verification loop is solved, the agent can keep running longer. So on day one of YC, they told their partners they wanted to build a general-purpose coding agent, not a testing tool.

The second pivot came on the commercialization path. The team initially tried enterprise customers but found adoption too slow. Meanwhile, internal non-technical colleagues were using the in-house coding agent even more frequently than developers—which made them realize the real opportunity lay in democratizing software engineering capabilities for everyone.

"We're almost like an applied research lab focused on building production-quality agents."

What this experience left behind: early production experience with multi-agent systems, cross-agent memory management and communication mechanisms, and caching strategies for cost control.

Verification loop refers to the mechanism by which an agent, after generating code or performing actions, can automatically receive feedback (such as test results, runtime errors, or deployment status) and adjust its behavior accordingly. For long-horizon tasks, an agent without a verification loop is like walking blindfolded—errors accumulate and can't be self-corrected. Emergent's early work building containers and agents for automated testing was essentially constructing this "generate-execute-verify-correct" cycle. Once the loop holds, an agent can run autonomously for hours or even days, leaping from single-step code completion to a general-purpose coding agent that can independently complete projects. This is the fundamental reason they dared to pivot to a general-purpose agent on day one of YC.

Why Claude: Writing Code for the World Six Months Out

Mukund mentions a principle that's easily overlooked in the AI industry: build products for the capabilities of models six months from now, not for the models usable today. Emergent started right around the release of Sonnet, whose instruction-following and coding abilities let the team imagine for the first time what a "long-running agent" could look like.

In terms of product positioning, Emergent's users don't compare it to an IDE or dev tool—they compare it to a "development outsourcing firm," which typically quotes $250,000 and a three-month timeline. That means users aren't sensitive to price or latency, but are extremely sensitive to the quality of the final deliverable. So the team has always prioritized the strongest reasoning and coding options when choosing models, and internal evaluations are oriented toward "highest-quality output" rather than "fastest output."

Mukund particularly emphasizes the error accumulation problem: in an agent task running ten thousand steps, small errors amplify rapidly, so instruction-following quality and tight feedback loops matter far more than per-step speed.

Error accumulation is one of the core challenges facing long-horizon agents. Suppose the per-step success rate is 99%—after 100 steps the overall success rate drops to about 37%, and after 1000 steps it approaches zero. In coding tasks, tiny deviations at each step (misunderstanding instructions, choosing the wrong API, ignoring edge cases) become inputs for subsequent steps, causing errors to compound exponentially. Therefore, for agents that need to run thousands of steps, improving per-step instruction-following quality matters far more than chasing per-step speed. Tight feedback loops (such as automated tests and static checks) can cut off error propagation in time, while the model's own reasoning and coding ability determines the baseline per-step success rate. This is the fundamental reason Emergent always prioritizes quality over latency in model selection.

The Real Moat: Code Generation Is Only 20%

When asked about competitive barriers, Mukund's take: the market is growing far faster than any player can serve, so there's no need to obsess over competition. The real differentiation lies at three levels.

First, self-built full-stack infrastructure. The team didn't use third-party container solutions; instead, on top of Kubernetes they built their own container technology supporting disk snapshots and memory snapshots, allowing parallel agents to save state and run for long periods. In Mukund's words, "the agent itself is the product, and the quality of the harness is crucial."

Second, the data compounding from going deep on a single stack. Users don't care about underlying technology choices and leave those decisions to the platform, enabling Emergent to accumulate learning rapidly on one stack. The long-term memory system lets agents learn not only from individual sessions but across all the applications being built—the first time it encounters a particular error or library upgrade, subsequent iterations can handle it with fewer tokens and higher accuracy.

Third, the heavy lifting beyond code generation. Mukund states plainly that code generation is only 20% of the problem—the other 80% is deployment, production maintenance, and security. The team has refactoring agents and pre- and post-deployment agents that check for security vulnerabilities, leaked credentials, and more. One quantifiable result: deployment success rates rose from 84% a few months ago to nearly 98%.

Container disk snapshots and memory snapshots are key underlying technologies supporting long-horizon parallel agents. Traditional containers lose their state once stopped, and can't support an agent preserving its filesystem, process memory, and runtime context across steps. The snapshot capability Emergent built on top of Kubernetes allows an agent to save its complete runtime state (including disk and memory) at any moment and quickly restore it when needed. This lets multiple agents work in parallel, each maintaining its own context, and lets tasks resume from checkpoints after interruption rather than starting over. Without this infrastructure, long-running agents would either be prohibitively expensive (continuously consuming resources) or unable to reliably restore state, drastically degrading the product experience.

User Profile: Not PMs, but Domain Experts

Emergent initially expected users to be mostly semi-technical people like product managers and designers, but actual data shows a large share are business operators and domain experts.

A frequently cited case is Christie, a clinical psychologist in Alaska who is also an equestrian coach and had waited ten years to combine psychology with equestrian training. She had gotten a $250,000 quote from a development outsourcer but the project never got off the ground; ultimately she built Equi Mind with Emergent, an app now live on the App Store with hundreds of users.

Mukund uses macro data to explain this positioning: SMEs worldwide contribute about 70% of employment and 50% of GDP, yet have never had tools to express themselves, because SMEs span a million niche scenarios and traditional SaaS has been economically forced to concentrate on the upstream market. AI's zero-marginal-cost service capability makes it possible, for the first time, to cover those million niche scenarios simultaneously.

Rewriting Four Times in Nine Months: Racing Against Model Iteration

The line from the interview that best captures the team's pace: the internal system was rewritten four times in nine months. Mukund's belief is that every time a new tier of model appears, you should delete what came before and reimagine the product from the new model's perspective. He notes that Opus can already support multiple agents collaborating on the same task, handling longer-horizon work.

For the next step, Emergent's direction is to go from "helping you build software" to "helping you run your entire business." The team is about to launch a product called Wingman, positioned as an enterprise-facing agent that automates business processes across finance, operations, sales, and marketing, with the goal of making autonomous business operation possible on the platform.

In Mukund's view, continuously stronger model capabilities and ever-longer task horizons are certain trends. A year and a half ago almost no one believed a text-to-app product could exist, and today the question has become: where is the next frontier.

For readers following AI application-layer startups, Emergent's path offers a worthwhile reference: don't make assumptions about model capabilities—build compounding advantages in verification loops, full-stack infrastructure, and user outcomes.

Long-horizon agents refer to intelligent agents capable of autonomously planning and executing complex tasks spanning hundreds to thousands of steps and lasting hours or even days. Unlike single-turn conversations or short tasks, long-horizon agents must solve a series of engineering challenges: state persistence, error recovery, context compression, and cost control. As underlying model capabilities improve (expanded reasoning windows, stronger instruction following), the task horizons agents can handle keep lengthening. Emergent rewriting its system four times in nine months was precisely to adapt to the horizon leaps brought by each new generation of models—old architectures often assumed tasks ended within dozens of steps, while new models require systems to support thousands of steps of continuous work, forcing the team to repeatedly redesign memory management, verification loops, and container infrastructure.

One-line Summary

Emergent hit $100M revenue in eight months, reshaping AI coding through verification loops, full-stack infrastructure, and domain-expert users.

Paragraph Summary

Emergent is an AI coding startup that reached $100 million in revenue in 8 months with nearly 7 million users. In an interview, CEO Mukund reviews three key pivots: from automated testing to a general-purpose coding agent, from enterprise customers to democratizing software engineering, and committing to building products for the models of six months out. Emergent chose Claude for its reasoning and coding quality, and built its own container snapshot technology on Kubernetes to support long-horizon parallel agents. The team believes code generation is only 20% of the problem, with deployment, security, and production maintenance making up the other 80%—lifting deployment success rates from 84% to 98%. The user base turned out to be mostly domain experts rather than product managers. The team rewrote its system four times in nine months and is about to launch Wingman, expanding from building software to automating entire business processes.