Y CombinatorMukund & Madhav: How Solving Verification Enabled 7M Apps
Suitebench's multi-agent verification enabled long-horizon autonomy; non-technical builders now ship production software without writing a single line of code.
CHAPTERS
- 0:00 – 1:18
Emergent’s thesis: AI agents unlock domain experts into builders
Mukund and Jared frame Emergent as an empowerment story: AI doesn’t just automate work—it enables people closest to real problems to finally ship software. The conversation sets the tone that the big opportunity is expanding who can build, not just replacing jobs.
- •Emergent aims to remove the “technology barrier” for domain experts
- •Shift in narrative from job replacement to mass empowerment and autonomy
- •Software creation becomes accessible to people with strong problem context
- •The episode will explore how Emergent operationalizes this in product and GTM
- 1:18 – 1:43
Founder backstory: twin builders, big engineering orgs, and a shipping bottleneck insight
Mukund and Madhav share their background—from early programming to PhDs and senior roles at Google/Amazon, plus Mukund’s experience leading ~300 engineers at Dunzo. That experience reveals a key pain: testing and verification slow down shipping, seeding their first product idea.
- •Twins with deep engineering and ML experience (Google, Amazon)
- •Mukund previously ran Dunzo, a major hyperlocal commerce company in India
- •Managing 300 engineers surfaced testing as the biggest bottleneck
- •Startup ambition: build together and ride the coming AI inflection
- 1:43 – 2:52
From AI testing automation to general coding agents: verification as the core loop
They applied to YC initially to automate software testing, but building testing agents led to a broader realization. If you can reliably verify work, you can let agents run longer and automate much more of software engineering end-to-end.
- •Original idea (late 2023): automate software testing; VCs thought it was “too crazy”
- •Key insight: verification enables long-horizon agent work
- •Pivot: from testing agent → general coding agent
- •Verification becomes the foundation for durable agent performance
- 2:52 – 4:18
Getting ahead early: Suitebench, research-first mode, and foundational agent primitives
In early 2024, the landscape was still nascent (Devin newly launched; Cursor early; others not started yet). Emergent focused on becoming #1 on Suitebench, and in the process built core techniques—multi-agent orchestration, memory, routing, and scaling test-time compute.
- •Early market timing: few mature competitors at the start
- •Suitebench became the forcing function for rapid iteration
- •Built/learned fundamentals: multi-agent systems, memory, routing, agent-to-agent comms
- •Research-first approach before thinking deeply about product packaging
- 4:18 – 5:57
Pivot to non-technical users: leaving enterprise, productizing the agent, and global adoption
After attempting an enterprise approach, they found it slow and redirected toward broader users as consumer tools like Lovable and Bolt surged. A small beta launch quickly took off, and today the majority of users are non-technical and spread across ~190 countries.
- •Tried enterprise integration for months; progress was too slow
- •Internal dogfooding showed leverage for building tools fast
- •Beta launch ignited demand; focus shifted to non-technical builders
- •80% of users have zero programming knowledge; global reach across 190+ countries
- 5:57 – 9:46
Why second movers can win in AI: reimagining with new models + distribution via influencers
Madhav explains that each model generation changes what’s possible, letting later entrants rethink product constraints and user needs. Emergent differentiated by targeting production-ready shipping, and they accelerated distribution using a deliberate influencer strategy across short-form platforms.
- •New model generations reset the product landscape (e.g., structured output pain fades)
- •Second movers learn what competitors miss and start from a new ‘imagination baseline’
- •Differentiation: ship to production vs front-end prototypes
- •Distribution wedge: influencer network on TikTok/Instagram plus focused messaging
- 9:46 – 11:17
Production, not prototypes: infra choices, full-stack defaults, and ‘agent experience’ as a metric
Emergent invested in the unglamorous last mile: deployment, infra consistency, and reliable feedback loops for agents. They built their own Kubernetes/container stack, chose a backend+frontend architecture designed for serious apps, and emphasize UX for both humans and agents.
- •Built own cloud sandboxes/infra instead of outsourcing to third-party providers
- •Same infra during build and deploy reduces deployment surprises
- •Full-stack posture: Python backend + React frontend; supports background jobs/queues
- •UX for non-technical users: hide intimidating dev artifacts (diffs/JSON)
- •Internal concept: measure ‘agent experience’ alongside user experience
- 11:17 – 14:49
Agent architecture deep dive: multi-agent delegation, continual learning, and auto-generated skills
They describe how Emergent avoids context-window bottlenecks using delegation and memory. Sub-agents handle specialized tasks while trajectories are aggregated into long-term memory; skills are generated from prior work and added through a CI/CD-like validation process.
- •Main ‘driving’ agent delegates to sub-agents (testing, design search, integrations)
- •Frugal context management to scale to complex apps
- •Long-term memory learns across sessions, not just within one build
- •Skills are auto-generated from prior trajectories and validated via CI/CD
- •Result: repeated tasks (e.g., calendar integrations) improve over time
- 14:49 – 18:21
Riding the model curve without getting commoditized: autonomy, harnessing, and expanding scope
They discuss trusting models to improve (e.g., parsing, unit tests) while evolving the harness to grant more autonomy as models get stronger. Emergent’s moat is framed as shipping-to-production workflows, orchestration across models, and expanding product scope into growth and operations.
- •As models improve, Emergent relaxes rigid harnessing to increase autonomy
- •Concern addressed: foundation models ‘eating’ app-layer companies
- •Claim: coding is ~20%; productionization and user needs are the hard part
- •Use multiple models to extract extra performance and reliability
- •User demands expand beyond building: distribution, growth, and operations tooling
- 18:21 – 21:33
Live demo walkthrough: prompting, clarifications, mobile/web routing, and ‘no API key’ onboarding
The demo shows how a user can request a full app and have Emergent choose the right builder agent—even when the wrong tab is selected. They highlight clarification questions, strong design defaults, and removing technical hurdles like API keys by offering an Emergent-managed key.
- •Prompt-to-app flow with automatic selection of the right agent (mobile vs web)
- •Agent asks clarifying questions before building to lock requirements
- •Examples of real user apps (lead-gen AV setup app; lawyer CRM)
- •Onboarding simplification: use ‘Emergent LLM key’ instead of managing third-party keys
- •Previewed podcast/interview practice app built during the demo
- 21:33 – 24:40
Personalized internal software: building an Asana/Jira-like tool and rethinking versioning
They show a fully Emergent-built internal project management system and explain why customization and cost drove them to replace SaaS tools. The conversation explores how versioning, testing, and releases work when updates are made via natural language rather than traditional Git workflows.
- •Internal Asana/Jira clone built 100% with Emergent; no manual code edits
- •Motivations: workflow customization + saving $3–4k/month in subscriptions
- •Dogfooding pushes platform limits and informs roadmap for complex apps
- •Collaborative feature requests across roles; primary owner manages releases
- •Versioning/testing/deployment handled within Emergent; GitHub optional for users
- 24:40 – 29:04
How Emergent hires and operates lean across SF + Bangalore: ownership, customer empathy, and standards
Mukund explains a high-ownership hiring philosophy and how a small team builds large-scope systems (deployment, memory) with few people. They detail their split geography and a rigorous practice: everyone does customer support and talks to users weekly to stay close to the market.
- •Hiring filters: problem-solving and ownership; high-performance recruiting focus
- •Small team leverage: major subsystems built by 1–2 people
- •Team footprint: mostly Bangalore; small SF office; founders split time
- •Company-wide customer contact: weekly calls + rotating support duty
- •Global userbase supported via AI translation and high internal product standards
- 29:04 – 30:37
Is SaaS dead? Agent-first workflows and the rise of custom, agentic software
They argue SaaS must evolve under two pressures: agents consuming SaaS workflows and users demanding bespoke tools. Emergent already sees a meaningful portion of apps embedding agents directly, signaling a shift toward software that executes workflows autonomously.
- •Two headwinds for SaaS: agent-consumed workflows + demand for customization
- •SaaS survival may require becoming ‘agent-first’
- •~20% of Emergent-built apps are agentic (agents embedded into workflows)
- •Examples include agent-driven CRM/workflow execution
- •Software ‘morphing’ toward autonomous, agent-mediated experiences
- 30:37 – 39:32
The future: longer-horizon agents, verifier layers, and a Cambrian explosion of niche businesses
They forecast agents running for many hours (eventually 24/7) with many collaborating under an overseeing agent, enabled by stronger verification. The closing stories emphasize what seven million apps represent: niche, founder-led software built by domain experts and solopreneurs, reducing the gap between idea and reality.
- •Trendline: task horizons expanding rapidly; multi-agent collaboration becomes normal
- •Core enabler: robust autonomous verification loops; custom fine-tuned verifier layers
- •Strategy: augment frontier models rather than compete head-on with them
- •Users: SMBs, solopreneurs, and domain experts replacing dev shops and translation loss
- •Examples: EquiMind (psychology + equestrian coaching); apps raising capital; “niche of niches”
- •Broader implication: more people run small, personalized businesses powered by AI-built software
